@nocobase/plugin-notification-in-app-message 2.1.7 → 2.1.8

package/dist/node_modules/uuid/dist/esm-browser/stringify.js

@@ -1,31 +1,35 @@
 import validate from './validate.js';
-
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
-  byteToHex.push((i + 0x100).toString(16).slice(1));
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).slice(1));
 }
 export function unsafeStringify(arr, offset = 0) {
-  // Note: Be careful editing this code!  It's been tuned for performance
-  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
-  //
-  // Note to future-self: No, you can't remove the `toLowerCase()` call.
-  // REF: https://github.com/uuidjs/uuid/pull/677#issuecomment-1757351351
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
 }
 function stringify(arr, offset = 0) {
-  var uuid = unsafeStringify(arr, offset);
-  // Consistency check for valid UUID.  If this throws, it's likely due to one
-  // of the following:
-  // - One or more input array values don't map to a hex octet (leading to
-  // "undefined" in the uuid)
-  // - Invalid input values for the RFC `version` or `variant` fields
-  if (!validate(uuid)) {
-    throw TypeError('Stringified UUID is invalid');
-  }
-  return uuid;
+    const uuid = unsafeStringify(arr, offset);
+    if (!validate(uuid)) {
+        throw TypeError('Stringified UUID is invalid');
+    }
+    return uuid;
 }
-export default stringify;
+export default stringify;

package/dist/node_modules/uuid/dist/esm-browser/types.d.ts

@@ -0,0 +1,21 @@
+export type UUIDTypes<TBuf extends Uint8Array = Uint8Array> = string | TBuf;
+export type Version1Options = {
+    node?: Uint8Array;
+    clockseq?: number;
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+    msecs?: number;
+    nsecs?: number;
+    _v6?: boolean;
+};
+export type Version4Options = {
+    random?: Uint8Array;
+    rng?: () => Uint8Array;
+};
+export type Version6Options = Version1Options;
+export type Version7Options = {
+    random?: Uint8Array;
+    msecs?: number;
+    seq?: number;
+    rng?: () => Uint8Array;
+};

package/dist/node_modules/uuid/dist/esm-browser/types.js

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/uuid/dist/esm-browser/uuid-bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node_modules/uuid/dist/esm-browser/uuid-bin.js

@@ -0,0 +1,70 @@
+import * as assert from 'assert';
+import v1 from './v1.js';
+import v3 from './v3.js';
+import v4 from './v4.js';
+import v5 from './v5.js';
+import v6 from './v6.js';
+import v7 from './v7.js';
+function usage() {
+    console.log('Usage:');
+    console.log('  uuid');
+    console.log('  uuid v1');
+    console.log('  uuid v3 <name> <namespace uuid>');
+    console.log('  uuid v4');
+    console.log('  uuid v5 <name> <namespace uuid>');
+    console.log('  uuid v6');
+    console.log('  uuid v7');
+    console.log('  uuid --help');
+    console.log('\nNote: <namespace uuid> may be "URL" or "DNS" to use the corresponding UUIDs defined by RFC9562');
+}
+const args = process.argv.slice(2);
+if (args.indexOf('--help') >= 0) {
+    usage();
+    process.exit(0);
+}
+const version = args.shift() || 'v4';
+switch (version) {
+    case 'v1':
+        console.log(v1());
+        break;
+    case 'v3': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v3 name not specified');
+        assert.ok(namespace != null, 'v3 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v3.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v3.DNS;
+        }
+        console.log(v3(name, namespace));
+        break;
+    }
+    case 'v4':
+        console.log(v4());
+        break;
+    case 'v5': {
+        const name = args.shift();
+        let namespace = args.shift();
+        assert.ok(name != null, 'v5 name not specified');
+        assert.ok(namespace != null, 'v5 namespace not specified');
+        if (namespace === 'URL') {
+            namespace = v5.URL;
+        }
+        if (namespace === 'DNS') {
+            namespace = v5.DNS;
+        }
+        console.log(v5(name, namespace));
+        break;
+    }
+    case 'v6':
+        console.log(v6());
+        break;
+    case 'v7':
+        console.log(v7());
+        break;
+    default:
+        usage();
+        process.exit(1);
+}

package/dist/node_modules/uuid/dist/esm-browser/v1.d.ts

@@ -0,0 +1,11 @@
+import { Version1Options } from './types.js';
+type V1State = {
+    node?: Uint8Array;
+    clockseq?: number;
+    msecs?: number;
+    nsecs?: number;
+};
+declare function v1(options?: Version1Options, buf?: undefined, offset?: number): string;
+declare function v1<Buf extends Uint8Array = Uint8Array>(options: Version1Options | undefined, buf: Buf, offset?: number): Buf;
+export declare function updateV1State(state: V1State, now: number, rnds: Uint8Array): V1State;
+export default v1;

package/dist/node_modules/uuid/dist/esm-browser/v1.js

@@ -1,125 +1,83 @@
 import rng from './rng.js';
 import { unsafeStringify } from './stringify.js';
-
-// **`v1()` - Generate time-based UUID**
-//
-// Inspired by https://github.com/LiosK/UUID.js
-// and http://docs.python.org/library/uuid.html
-
-var _nodeId;
-var _clockseq;
-
-// Previous uuid creation time
-var _lastMSecs = 0;
-var _lastNSecs = 0;
-
-// See https://github.com/uuidjs/uuid for API details
+const _state = {};
 function v1(options, buf, offset) {
-  var i = buf && offset || 0;
-  var b = buf || new Array(16);
-  options = options || {};
-  var node = options.node;
-  var clockseq = options.clockseq;
-
-  // v1 only: Use cached `node` and `clockseq` values
-  if (!options._v6) {
-    if (!node) {
-      node = _nodeId;
+    let bytes;
+    const isV6 = options?._v6 ?? false;
+    if (options) {
+        const optionsKeys = Object.keys(options);
+        if (optionsKeys.length === 1 && optionsKeys[0] === '_v6') {
+            options = undefined;
+        }
     }
-    if (clockseq == null) {
-      clockseq = _clockseq;
+    if (options) {
+        bytes = v1Bytes(options.random ?? options.rng?.() ?? rng(), options.msecs, options.nsecs, options.clockseq, options.node, buf, offset);
     }
-  }
-
-  // Handle cases where we need entropy.  We do this lazily to minimize issues
-  // related to insufficient system entropy.  See #189
-  if (node == null || clockseq == null) {
-    var seedBytes = options.random || (options.rng || rng)();
-
-    // Randomize node
-    if (node == null) {
-      node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
-
-      // v1 only: cache node value for reuse
-      if (!_nodeId && !options._v6) {
-        // per RFC4122 4.5: Set MAC multicast bit (v1 only)
-        node[0] |= 0x01; // Set multicast bit
-
-        _nodeId = node;
-      }
+    else {
+        const now = Date.now();
+        const rnds = rng();
+        updateV1State(_state, now, rnds);
+        bytes = v1Bytes(rnds, _state.msecs, _state.nsecs, isV6 ? undefined : _state.clockseq, isV6 ? undefined : _state.node, buf, offset);
     }
-
-    // Randomize clockseq
-    if (clockseq == null) {
-      // Per 4.2.2, randomize (14 bit) clockseq
-      clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
-      if (_clockseq === undefined && !options._v6) {
-        _clockseq = clockseq;
-      }
+    return buf ?? unsafeStringify(bytes);
+}
+export function updateV1State(state, now, rnds) {
+    state.msecs ??= -Infinity;
+    state.nsecs ??= 0;
+    if (now === state.msecs) {
+        state.nsecs++;
+        if (state.nsecs >= 10000) {
+            state.node = undefined;
+            state.nsecs = 0;
+        }
+    }
+    else if (now > state.msecs) {
+        state.nsecs = 0;
+    }
+    else if (now < state.msecs) {
+        state.node = undefined;
+    }
+    if (!state.node) {
+        state.node = rnds.slice(10, 16);
+        state.node[0] |= 0x01;
+        state.clockseq = ((rnds[8] << 8) | rnds[9]) & 0x3fff;
+    }
+    state.msecs = now;
+    return state;
+}
+function v1Bytes(rnds, msecs, nsecs, clockseq, node, buf, offset = 0) {
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    if (!buf) {
+        buf = new Uint8Array(16);
+        offset = 0;
+    }
+    else {
+        if (offset < 0 || offset + 16 > buf.length) {
+            throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+        }
+    }
+    msecs ??= Date.now();
+    nsecs ??= 0;
+    clockseq ??= ((rnds[8] << 8) | rnds[9]) & 0x3fff;
+    node ??= rnds.slice(10, 16);
+    msecs += 12219292800000;
+    const tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+    buf[offset++] = (tl >>> 24) & 0xff;
+    buf[offset++] = (tl >>> 16) & 0xff;
+    buf[offset++] = (tl >>> 8) & 0xff;
+    buf[offset++] = tl & 0xff;
+    const tmh = ((msecs / 0x100000000) * 10000) & 0xfffffff;
+    buf[offset++] = (tmh >>> 8) & 0xff;
+    buf[offset++] = tmh & 0xff;
+    buf[offset++] = ((tmh >>> 24) & 0xf) | 0x10;
+    buf[offset++] = (tmh >>> 16) & 0xff;
+    buf[offset++] = (clockseq >>> 8) | 0x80;
+    buf[offset++] = clockseq & 0xff;
+    for (let n = 0; n < 6; ++n) {
+        buf[offset++] = node[n];
     }
-  }
-
-  // v1 & v6 timestamps are 100 nano-second units since the Gregorian epoch,
-  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so time is
-  // handled internally as 'msecs' (integer milliseconds) and 'nsecs'
-  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
-  var msecs = options.msecs !== undefined ? options.msecs : Date.now();
-
-  // Per 4.2.1.2, use count of uuid's generated during the current clock
-  // cycle to simulate higher resolution clock
-  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
-
-  // Time since last uuid creation (in msecs)
-  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000;
-
-  // Per 4.2.1.2, Bump clockseq on clock regression
-  if (dt < 0 && options.clockseq === undefined) {
-    clockseq = clockseq + 1 & 0x3fff;
-  }
-
-  // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
-  // time interval
-  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
-    nsecs = 0;
-  }
-
-  // Per 4.2.1.2 Throw error if too many uuids are requested
-  if (nsecs >= 10000) {
-    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
-  }
-  _lastMSecs = msecs;
-  _lastNSecs = nsecs;
-  _clockseq = clockseq;
-
-  // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
-  msecs += 12219292800000;
-
-  // `time_low`
-  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
-  b[i++] = tl >>> 24 & 0xff;
-  b[i++] = tl >>> 16 & 0xff;
-  b[i++] = tl >>> 8 & 0xff;
-  b[i++] = tl & 0xff;
-
-  // `time_mid`
-  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
-  b[i++] = tmh >>> 8 & 0xff;
-  b[i++] = tmh & 0xff;
-
-  // `time_high_and_version`
-  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
-  b[i++] = tmh >>> 16 & 0xff;
-
-  // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
-  b[i++] = clockseq >>> 8 | 0x80;
-
-  // `clock_seq_low`
-  b[i++] = clockseq & 0xff;
-
-  // `node`
-  for (var n = 0; n < 6; ++n) {
-    b[i + n] = node[n];
-  }
-  return buf || unsafeStringify(b);
+    return buf;
 }
-export default v1;
+export default v1;

package/dist/node_modules/uuid/dist/esm-browser/v1ToV6.d.ts

@@ -0,0 +1,2 @@
+export default function v1ToV6(uuid: string): string;
+export default function v1ToV6(uuid: Uint8Array): Uint8Array;

package/dist/node_modules/uuid/dist/esm-browser/v1ToV6.js

@@ -1,20 +1,10 @@
 import parse from './parse.js';
 import { unsafeStringify } from './stringify.js';
-
-/**
- * Convert a v1 UUID to a v6 UUID
- *
- * @param {string|Uint8Array} uuid - The v1 UUID to convert to v6
- * @returns {string|Uint8Array} The v6 UUID as the same type as the `uuid` arg
- * (string or Uint8Array)
- */
 export default function v1ToV6(uuid) {
-  var v1Bytes = typeof uuid === 'string' ? parse(uuid) : uuid;
-  var v6Bytes = _v1ToV6(v1Bytes);
-  return typeof uuid === 'string' ? unsafeStringify(v6Bytes) : v6Bytes;
+    const v1Bytes = typeof uuid === 'string' ? parse(uuid) : uuid;
+    const v6Bytes = _v1ToV6(v1Bytes);
+    return typeof uuid === 'string' ? unsafeStringify(v6Bytes) : v6Bytes;
+}
+function _v1ToV6(v1Bytes) {
+    return Uint8Array.of(((v1Bytes[6] & 0x0f) << 4) | ((v1Bytes[7] >> 4) & 0x0f), ((v1Bytes[7] & 0x0f) << 4) | ((v1Bytes[4] & 0xf0) >> 4), ((v1Bytes[4] & 0x0f) << 4) | ((v1Bytes[5] & 0xf0) >> 4), ((v1Bytes[5] & 0x0f) << 4) | ((v1Bytes[0] & 0xf0) >> 4), ((v1Bytes[0] & 0x0f) << 4) | ((v1Bytes[1] & 0xf0) >> 4), ((v1Bytes[1] & 0x0f) << 4) | ((v1Bytes[2] & 0xf0) >> 4), 0x60 | (v1Bytes[2] & 0x0f), v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]);
 }
-
-// Do the field transformation needed for v1 -> v6
-function _v1ToV6(v1Bytes, randomize = false) {
-  return Uint8Array.of((v1Bytes[6] & 0x0f) << 4 | v1Bytes[7] >> 4 & 0x0f, (v1Bytes[7] & 0x0f) << 4 | (v1Bytes[4] & 0xf0) >> 4, (v1Bytes[4] & 0x0f) << 4 | (v1Bytes[5] & 0xf0) >> 4, (v1Bytes[5] & 0x0f) << 4 | (v1Bytes[0] & 0xf0) >> 4, (v1Bytes[0] & 0x0f) << 4 | (v1Bytes[1] & 0xf0) >> 4, (v1Bytes[1] & 0x0f) << 4 | (v1Bytes[2] & 0xf0) >> 4, 0x60 | v1Bytes[2] & 0x0f, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]);
-}

package/dist/node_modules/uuid/dist/esm-browser/v3.d.ts

@@ -0,0 +1,9 @@
+import { 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;
+declare namespace v3 {
+    var DNS: string;
+    var URL: string;
+}
+export default v3;

package/dist/node_modules/uuid/dist/esm-browser/v3.js

@@ -1,4 +1,9 @@
-import v35 from './v35.js';
 import md5 from './md5.js';
-var v3 = v35('v3', 0x30, md5);
-export default v3;
+import v35, { DNS, URL } from './v35.js';
+export { DNS, URL } from './v35.js';
+function v3(value, namespace, buf, offset) {
+    return v35(0x30, md5, value, namespace, buf, offset);
+}
+v3.DNS = DNS;
+v3.URL = URL;
+export default v3;

package/dist/node_modules/uuid/dist/esm-browser/v35.d.ts

@@ -0,0 +1,7 @@
+import { 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";
+type HashFunction = (bytes: Uint8Array) => Uint8Array;
+export default function v35<TBuf extends Uint8Array = Uint8Array>(version: 0x30 | 0x50, hash: HashFunction, value: string | Uint8Array, namespace: UUIDTypes, buf?: TBuf, offset?: number): UUIDTypes<TBuf>;
+export {};

package/dist/node_modules/uuid/dist/esm-browser/v35.js

@@ -1,55 +1,39 @@
-import { unsafeStringify } from './stringify.js';
 import parse from './parse.js';
-function stringToBytes(str) {
-  str = unescape(encodeURIComponent(str)); // UTF8 escape
-
-  var bytes = [];
-  for (var i = 0; i < str.length; ++i) {
-    bytes.push(str.charCodeAt(i));
-  }
-  return bytes;
-}
-export var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
-export var URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
-export default function v35(name, version, hashfunc) {
-  function generateUUID(value, namespace, buf, offset) {
-    var _namespace;
-    if (typeof value === 'string') {
-      value = stringToBytes(value);
+import { unsafeStringify } from './stringify.js';
+export function stringToBytes(str) {
+    str = unescape(encodeURIComponent(str));
+    const bytes = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; ++i) {
+        bytes[i] = str.charCodeAt(i);
     }
+    return bytes;
+}
+export const DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+export const URL = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
+export default function v35(version, hash, value, namespace, buf, offset) {
+    const valueBytes = typeof value === 'string' ? stringToBytes(value) : value;
+    const namespaceBytes = typeof namespace === 'string' ? parse(namespace) : namespace;
     if (typeof namespace === 'string') {
-      namespace = parse(namespace);
+        namespace = parse(namespace);
     }
-    if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
-      throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
+    if (namespace?.length !== 16) {
+        throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
     }
-
-    // Compute hash of namespace and value, Per 4.3
-    // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
-    // hashfunc([...namespace, ... value])`
-    var bytes = new Uint8Array(16 + value.length);
-    bytes.set(namespace);
-    bytes.set(value, namespace.length);
-    bytes = hashfunc(bytes);
-    bytes[6] = bytes[6] & 0x0f | version;
-    bytes[8] = bytes[8] & 0x3f | 0x80;
+    let bytes = new Uint8Array(16 + valueBytes.length);
+    bytes.set(namespaceBytes);
+    bytes.set(valueBytes, namespaceBytes.length);
+    bytes = hash(bytes);
+    bytes[6] = (bytes[6] & 0x0f) | version;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
     if (buf) {
-      offset = offset || 0;
-      for (var i = 0; i < 16; ++i) {
-        buf[offset + i] = bytes[i];
-      }
-      return buf;
+        offset = 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];
+        }
+        return buf;
     }
     return unsafeStringify(bytes);
-  }
-
-  // Function#name is not settable on some platforms (#270)
-  try {
-    generateUUID.name = name;
-  } catch (err) {}
-
-  // For CommonJS default export support
-  generateUUID.DNS = DNS;
-  generateUUID.URL = URL;
-  return generateUUID;
-}
+}

package/dist/node_modules/uuid/dist/esm-browser/v4.d.ts

@@ -0,0 +1,4 @@
+import { 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/node_modules/uuid/dist/esm-browser/v4.js

@@ -2,24 +2,26 @@ import native from './native.js';
 import rng from './rng.js';
 import { unsafeStringify } from './stringify.js';
 function v4(options, buf, offset) {
-  if (native.randomUUID && !buf && !options) {
-    return native.randomUUID();
-  }
-  options = options || {};
-  var rnds = options.random || (options.rng || rng)();
-
-  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
-  rnds[6] = rnds[6] & 0x0f | 0x40;
-  rnds[8] = rnds[8] & 0x3f | 0x80;
-
-  // Copy bytes to buffer, if provided
-  if (buf) {
-    offset = offset || 0;
-    for (var i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
+    if (native.randomUUID && !buf && !options) {
+        return native.randomUUID();
     }
-    return buf;
-  }
-  return unsafeStringify(rnds);
+    options = options || {};
+    const rnds = options.random ?? options.rng?.() ?? rng();
+    if (rnds.length < 16) {
+        throw new Error('Random bytes length must be >= 16');
+    }
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    if (buf) {
+        offset = 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] = rnds[i];
+        }
+        return buf;
+    }
+    return unsafeStringify(rnds);
 }
-export default v4;
+export default v4;

package/dist/node_modules/uuid/dist/esm-browser/v5.d.ts

@@ -0,0 +1,9 @@
+import { 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;
+declare namespace v5 {
+    var DNS: string;
+    var URL: string;
+}
+export default v5;

package/dist/node_modules/uuid/dist/esm-browser/v5.js

@@ -1,4 +1,9 @@
-import v35 from './v35.js';
 import sha1 from './sha1.js';
-var v5 = v35('v5', 0x50, sha1);
-export default v5;
+import v35, { DNS, URL } from './v35.js';
+export { DNS, URL } from './v35.js';
+function v5(value, namespace, buf, offset) {
+    return v35(0x50, sha1, value, namespace, buf, offset);
+}
+v5.DNS = DNS;
+v5.URL = URL;
+export default v5;

package/dist/node_modules/uuid/dist/esm-browser/v6.d.ts

@@ -0,0 +1,4 @@
+import { 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;