uniku 0.5.0 → 0.7.0

package/src/uuid/common/sha1.ts

@@ -0,0 +1,102 @@
+/**
+ * Minimal synchronous SHA-1 (FIPS 180-4) for name-based UUIDs.
+ *
+ * Web Crypto's `digest()` is async and every uniku generator is synchronous,
+ * so `uuid/v5` carries its own SHA-1 instead of returning a promise or adding a
+ * dependency. It serves identity only, never as a security primitive.
+ */
+
+const W = new Int32Array(80)
+
+/** Size of the buffer SHA-1 needs to pad a `length`-byte message: a multiple of 64 with room for 9 more bytes. */
+export function sha1PaddedLength(length: number): number {
+  return (Math.floor((length + 8) / 64) + 1) * 64
+}
+
+/**
+ * Hash `msg[0, length)` and write the first 16 digest bytes to `out[offset, offset + 16)`.
+ *
+ * `msg` is caller-owned scratch space of at least `sha1PaddedLength(length)` bytes.
+ * Bytes from `length` on are overwritten with padding, so stale contents are fine.
+ */
+export function sha1Digest128Into(msg: Uint8Array, length: number, out: Uint8Array, offset: number): void {
+  const padded = sha1PaddedLength(length)
+  msg[length] = 0x80
+  msg.fill(0, length + 1, padded - 8)
+
+  const bitsHigh = Math.floor(length / 0x20000000)
+  const bitsLow = (length << 3) >>> 0
+  msg[padded - 8] = bitsHigh >>> 24
+  msg[padded - 7] = bitsHigh >>> 16
+  msg[padded - 6] = bitsHigh >>> 8
+  msg[padded - 5] = bitsHigh
+  msg[padded - 4] = bitsLow >>> 24
+  msg[padded - 3] = bitsLow >>> 16
+  msg[padded - 2] = bitsLow >>> 8
+  msg[padded - 1] = bitsLow
+
+  let h0 = 0x67452301
+  let h1 = 0xefcdab89 | 0
+  let h2 = 0x98badcfe | 0
+  let h3 = 0x10325476
+  let h4 = 0xc3d2e1f0 | 0
+
+  for (let block = 0; block < padded; block += 64) {
+    for (let i = 0; i < 16; i += 1) {
+      const j = block + i * 4
+      W[i] = (msg[j] << 24) | (msg[j + 1] << 16) | (msg[j + 2] << 8) | msg[j + 3]
+    }
+    for (let i = 16; i < 80; i += 1) {
+      const x = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]
+      W[i] = (x << 1) | (x >>> 31)
+    }
+
+    let a = h0
+    let b = h1
+    let c = h2
+    let d = h3
+    let e = h4
+
+    for (let i = 0; i < 80; i += 1) {
+      let f: number
+      let k: number
+      if (i < 20) {
+        f = (b & c) | (~b & d)
+        k = 0x5a827999
+      } else if (i < 40) {
+        f = b ^ c ^ d
+        k = 0x6ed9eba1
+      } else if (i < 60) {
+        f = (b & c) | (b & d) | (c & d)
+        k = 0x8f1bbcdc | 0
+      } else {
+        f = b ^ c ^ d
+        k = 0xca62c1d6 | 0
+      }
+      const t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) | 0
+      e = d
+      d = c
+      c = (b << 30) | (b >>> 2)
+      b = a
+      a = t
+    }
+
+    h0 = (h0 + a) | 0
+    h1 = (h1 + b) | 0
+    h2 = (h2 + c) | 0
+    h3 = (h3 + d) | 0
+    h4 = (h4 + e) | 0
+  }
+
+  writeWord(out, offset, h0)
+  writeWord(out, offset + 4, h1)
+  writeWord(out, offset + 8, h2)
+  writeWord(out, offset + 12, h3)
+}
+
+function writeWord(out: Uint8Array, offset: number, word: number): void {
+  out[offset] = word >>> 24
+  out[offset + 1] = word >>> 16
+  out[offset + 2] = word >>> 8
+  out[offset + 3] = word
+}

package/src/uuid/common/uuid.ts

@@ -1,4 +1,5 @@
 import { BufferError, ParseError } from '../../errors'
+import type { IdGenerator } from '../../generators'
 import { hexValue } from './hex'
 
 const UUID_BYTE_LENGTH = 16
@@ -135,9 +136,14 @@ export function formatUuidUnchecked(bytes: Uint8Array): string {
 }
 
 export function parseUuid(value: string): Uint8Array {
+  return parseUuidFor(value, 'uuid')
+}
+
+/** Parse a UUID string of any version, attributing errors to `strategy`. */
+export function parseUuidFor(value: string, strategy: IdGenerator): Uint8Array {
   if (value.length !== UUID_STRING_LENGTH) {
     throw new ParseError('INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`, {
-      strategy: 'uuid',
+      strategy,
     })
   }
 
@@ -146,7 +152,7 @@ export function parseUuid(value: string): Uint8Array {
     throw new ParseError(
       'INVALID_FORMAT',
       `UUID string has invalid separators at positions 8, 13, 18, 23. Received: "${value}"`,
-      { strategy: 'uuid' },
+      { strategy },
     )
   }
 
@@ -161,7 +167,7 @@ export function parseUuid(value: string): Uint8Array {
     const nibble = hexValue(value.charCodeAt(i))
     if (nibble === -1) {
       throw new ParseError('INVALID_CHAR', `UUID string contains invalid hex character at position ${i}`, {
-        strategy: 'uuid',
+        strategy,
       })
     }
 

package/src/uuid/v5.ts

@@ -0,0 +1,208 @@
+import { isWritableRange } from '../common/validation'
+import { BufferError, InvalidInputError } from '../errors'
+import { sha1Digest128Into, sha1PaddedLength } from './common/sha1'
+import { formatUuid, formatUuidUnchecked, parseUuid } from './common/uuid'
+
+const UUID_BYTES = 16
+// Names that fit hash in this reused buffer; larger ones get a one-off allocation.
+const SCRATCH_BYTES = 512
+const scratch = new Uint8Array(SCRATCH_BYTES)
+const scratchName = scratch.subarray(UUID_BYTES)
+const reusableBuf = new Uint8Array(UUID_BYTES)
+const encoder = /*@__PURE__*/ new TextEncoder()
+
+/**
+ * The input a UUID v5 is derived from: a string, hashed as UTF-8 without Unicode
+ * normalization, or raw bytes.
+ */
+export type UuidV5Name = string | Uint8Array
+
+/** A namespace UUID, as a UUID string or its 16 canonical bytes. */
+export type UuidV5Namespace = string | Uint8Array
+
+/** Derives UUID v5 values for one namespace. Returned by `uuidv5.namespace()`. */
+export type UuidV5Deriver = {
+  /** Derive the UUID v5 string for a name. */
+  (name: UuidV5Name, buf?: undefined, offset?: number): string
+  /** Derive the UUID v5 for a name and write its 16 canonical bytes into a caller-owned buffer. */
+  <TBuf extends Uint8Array = Uint8Array>(name: UuidV5Name, buf: TBuf, offset?: number): TBuf
+}
+
+export type UuidV5 = {
+  /** Derive the UUID v5 string for a name within a namespace. */
+  (name: UuidV5Name, namespace: UuidV5Namespace, buf?: undefined, offset?: number): string
+  /** Derive the UUID v5 for a name within a namespace and write its 16 canonical bytes into a caller-owned buffer. */
+  <TBuf extends Uint8Array = Uint8Array>(name: UuidV5Name, namespace: UuidV5Namespace, buf: TBuf, offset?: number): TBuf
+  /** Validate and parse a namespace once, and return a function that derives IDs within it. */
+  namespace(namespace: UuidV5Namespace): UuidV5Deriver
+  /** Convert a UUID v5 string to its canonical 16-byte representation. */
+  toBytes(id: string): Uint8Array
+  /** Convert 16 canonical UUID bytes to a UUID v5 string. */
+  fromBytes(bytes: Uint8Array): string
+  /** Return whether a value is a syntactically valid UUID v5 string. */
+  isValid(id: unknown): id is string
+  /** The RFC 9562 namespace for fully qualified domain names. */
+  DNS: string
+  /** The RFC 9562 namespace for URLs. */
+  URL: string
+  /** The RFC 9562 namespace for ISO object identifiers (OIDs). */
+  OID: string
+  /** The RFC 9562 namespace for X.500 distinguished names. */
+  X500: string
+  /** The nil UUID (all zeros) */
+  NIL: string
+  /** The max UUID (all ones) */
+  MAX: string
+}
+
+const UUID_V5_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+function parseNamespace(namespace: UuidV5Namespace): Uint8Array {
+  if (typeof namespace === 'string') {
+    return parseUuid(namespace)
+  }
+
+  if (namespace.length !== UUID_BYTES) {
+    throw new InvalidInputError(
+      'BYTES_INVALID_LENGTH',
+      `UUID v5 namespace must be exactly ${UUID_BYTES} bytes, got ${namespace.length}`,
+      { strategy: 'uuid' },
+    )
+  }
+
+  return namespace
+}
+
+function writeV5BytesUnchecked(namespace: Uint8Array, name: UuidV5Name, out: Uint8Array, offset: number): void {
+  let msg: Uint8Array
+  let length: number
+
+  if (typeof name === 'string') {
+    // UTF-8 needs at most 3 bytes per UTF-16 code unit.
+    const capacity = sha1PaddedLength(UUID_BYTES + name.length * 3)
+    msg = capacity <= SCRATCH_BYTES ? scratch : new Uint8Array(capacity)
+    const nameRegion = msg === scratch ? scratchName : msg.subarray(UUID_BYTES)
+    length = UUID_BYTES + encoder.encodeInto(name, nameRegion).written
+  } else {
+    length = UUID_BYTES + name.length
+    const capacity = sha1PaddedLength(length)
+    msg = capacity <= SCRATCH_BYTES ? scratch : new Uint8Array(capacity)
+    msg.set(name, UUID_BYTES)
+  }
+
+  // Name and namespace are copied before `out` is written, so either may alias it.
+  msg.set(namespace)
+  sha1Digest128Into(msg, length, out, offset)
+
+  // Set RFC 9562 version (5) and variant (10xx) bits.
+  out[offset + 6] = (out[offset + 6] & 0x0f) | 0x50
+  out[offset + 8] = (out[offset + 8] & 0x3f) | 0x80
+}
+
+function derive<TBuf extends Uint8Array = Uint8Array>(
+  namespace: Uint8Array,
+  name: UuidV5Name,
+  buf?: TBuf,
+  offset?: number,
+): string | TBuf {
+  if (!buf) {
+    writeV5BytesUnchecked(namespace, name, reusableBuf, 0)
+    return formatUuidUnchecked(reusableBuf)
+  }
+
+  const outputOffset = offset ?? 0
+  if (!isWritableRange(buf, outputOffset, UUID_BYTES)) {
+    throw new BufferError(
+      'BUFFER_OUT_OF_BOUNDS',
+      `UUID byte range ${outputOffset}:${outputOffset + UUID_BYTES - 1} is out of buffer bounds`,
+      { strategy: 'uuid' },
+    )
+  }
+
+  writeV5BytesUnchecked(namespace, name, buf, outputOffset)
+  return buf
+}
+
+/*
+ * Overload: no buffer => return a UUID string.
+ */
+function v5(name: UuidV5Name, namespace: UuidV5Namespace, buf?: undefined, offset?: number): string
+/*
+ * Overload: caller provides a buffer slice to fill with UUID bytes.
+ */
+function v5<TBuf extends Uint8Array = Uint8Array>(
+  name: UuidV5Name,
+  namespace: UuidV5Namespace,
+  buf: TBuf,
+  offset?: number,
+): TBuf
+function v5<TBuf extends Uint8Array = Uint8Array>(
+  name: UuidV5Name,
+  namespace: UuidV5Namespace,
+  buf?: TBuf,
+  offset?: number,
+): string | TBuf {
+  return derive(parseNamespace(namespace), name, buf, offset)
+}
+
+function namespace(namespace: UuidV5Namespace): UuidV5Deriver {
+  // Copy caller bytes so later mutation cannot change derived IDs. `new Uint8Array()` always copies,
+  // unlike `.slice()` on a Node.js Buffer, which returns a view of the same memory.
+  const namespaceBytes =
+    typeof namespace === 'string' ? parseUuid(namespace) : new Uint8Array(parseNamespace(namespace))
+
+  function deriver(name: UuidV5Name, buf?: undefined, offset?: number): string
+  function deriver<TBuf extends Uint8Array = Uint8Array>(name: UuidV5Name, buf: TBuf, offset?: number): TBuf
+  function deriver<TBuf extends Uint8Array = Uint8Array>(name: UuidV5Name, buf?: TBuf, offset?: number): string | TBuf {
+    return derive(namespaceBytes, name, buf, offset)
+  }
+
+  return deriver
+}
+
+function isValid(id: unknown): id is string {
+  return typeof id === 'string' && UUID_V5_REGEX.test(id)
+}
+
+/**
+ * Derive a UUID v5 from a name and a namespace, or write its bytes into a buffer.
+ *
+ * UUID v5 (RFC 9562 section 5.5) is name-based: it hashes the namespace and
+ * name with SHA-1, so the same inputs give the same ID in every process, on
+ * every runtime, with no state to keep. Use it to derive a stable ID from an
+ * identifier you already hold.
+ *
+ * String names are hashed as UTF-8 without Unicode normalization. A UUID v5 is
+ * an identifier, not a secret: anyone who knows or can guess the name and
+ * namespace can compute it, and SHA-1 lets someone who controls the names craft
+ * two that collide.
+ *
+ * @example
+ * ```ts
+ * import { uuidv5 } from 'uniku/uuid/v5'
+ *
+ * const id = uuidv5('www.example.com', uuidv5.DNS)
+ * // => "2ed6657d-e927-568b-95e1-2665a8aea6a2"
+ *
+ * // Parse a namespace once and derive many IDs within it
+ * const sessionId = uuidv5.namespace('1b671a64-40d5-491e-99b0-da01ff1f3341')
+ * sessionId('tool-a:3f2c')
+ *
+ * // Validate
+ * uuidv5.isValid(id) // true
+ * ```
+ */
+export const uuidv5: UuidV5 = Object.assign(v5, {
+  namespace,
+  toBytes: parseUuid,
+  fromBytes: formatUuid,
+  isValid,
+  DNS: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
+  URL: '6ba7b811-9dad-11d1-80b4-00c04fd430c8',
+  OID: '6ba7b812-9dad-11d1-80b4-00c04fd430c8',
+  X500: '6ba7b814-9dad-11d1-80b4-00c04fd430c8',
+  NIL: '00000000-0000-0000-0000-000000000000',
+  MAX: 'ffffffff-ffff-ffff-ffff-ffffffffffff',
+})
+
+export { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'

package/src/uuid/v7.ts

@@ -19,11 +19,11 @@ export type UuidV7Options = {
    */
   counter?: number
   /**
-   * Unsigned 32-bit sequence value.
+   * Deprecated alias for `counter`; unsigned 32-bit sequence value.
    *
-   * @deprecated Use `counter` instead. Will be removed at v1-rc.
+   * @deprecated Use `counter` instead. Will be removed in `1.0.0-rc.1`.
    */
-  // TODO(v1-rc): remove this alias (tracked in docs/STABILITY.md).
+  // TODO(v1-rc.1): remove this alias (tracked in docs/STABILITY.md).
   seq?: number
 }
 

package/src/xid/xid.ts

@@ -26,11 +26,11 @@ export type XidOptions = {
    */
   msecs?: number
   /**
-   * Unix timestamp in seconds.
+   * Deprecated alias for `msecs`; Unix timestamp in seconds.
    *
-   * @deprecated Use `msecs` instead. Will be removed at v1-rc.
+   * @deprecated Use `msecs` instead. Will be removed in `1.0.0-rc.1`.
    */
-  // TODO(v1-rc): remove this alias (tracked in docs/STABILITY.md).
+  // TODO(v1-rc.1): remove this alias (tracked in docs/STABILITY.md).
   secs?: number
   /** 24-bit counter. Explicit values do not consume shared state. */
   counter?: number

package/build/uuid-BPebYihz.mjs

@@ -1,2 +0,0 @@
-import{BufferError as e,ParseError as t}from"./errors.mjs";function n(e){return e>=48&&e<=57?e-48:e>=65&&e<=70?e-65+10:e>=97&&e<=102?e-97+10:-1}const r=[0,0,1,1,2,2,3,3,-1,4,4,5,5,-1,6,6,7,7,-1,8,8,9,9,-1,10,10,11,11,12,12,13,13,14,14,15,15],i=[!0,!1,!0,!1,!0,!1,!0,!1,!1,!0,!1,!0,!1,!1,!0,!1,!0,!1,!1,!0,!1,!0,!1,!1,!0,!1,!0,!1,!0,!1,!0,!1,!0,!1,!0,!1],a=Array.from({length:256},(e,t)=>t.toString(16).padStart(2,`0`));function o(t){if(t.length!==16)throw new e(`BYTES_INVALID_LENGTH`,`UUID bytes must be exactly 16 bytes, got ${t.length}`,{strategy:`uuid`});return s(t)}function s(e){return a[e[0]]+a[e[1]]+a[e[2]]+a[e[3]]+`-`+a[e[4]]+a[e[5]]+`-`+a[e[6]]+a[e[7]]+`-`+a[e[8]]+a[e[9]]+`-`+a[e[10]]+a[e[11]]+a[e[12]]+a[e[13]]+a[e[14]]+a[e[15]]}function c(e){if(e.length!==36)throw new t(`INVALID_LENGTH`,`UUID string must be 36 characters, got ${e.length}`,{strategy:`uuid`});if(e[8]!==`-`||e[13]!==`-`||e[18]!==`-`||e[23]!==`-`)throw new t(`INVALID_FORMAT`,`UUID string has invalid separators at positions 8, 13, 18, 23. Received: "${e}"`,{strategy:`uuid`});let a=new Uint8Array(16);for(let o=0;o<36;o+=1){let s=r[o];if(s===-1)continue;let c=n(e.charCodeAt(o));if(c===-1)throw new t(`INVALID_CHAR`,`UUID string contains invalid hex character at position ${o}`,{strategy:`uuid`});i[o]?a[s]=c<<4:a[s]|=c}return a}export{s as n,c as r,o as t};
-//# sourceMappingURL=uuid-BPebYihz.mjs.map

package/build/uuid-BPebYihz.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuid-BPebYihz.mjs","names":[],"sources":["../src/uuid/common/hex.ts","../src/uuid/common/uuid.ts"],"sourcesContent":["// ASCII code ranges for hex character validation\nconst ASCII_0 = 48 // '0'\nconst ASCII_9 = 57 // '9'\nconst ASCII_A = 65 // 'A'\nconst ASCII_F = 70 // 'F'\nconst ASCII_a = 97 // 'a'\nconst ASCII_f = 102 // 'f'\n\n/**\n * Convert a hex character ASCII code to its numeric value (0-15).\n * Returns -1 for invalid hex characters.\n */\nexport function hexValue(code: number): number {\n  if (code >= ASCII_0 && code <= ASCII_9) {\n    return code - ASCII_0\n  }\n  if (code >= ASCII_A && code <= ASCII_F) {\n    return code - ASCII_A + 10\n  }\n  if (code >= ASCII_a && code <= ASCII_f) {\n    return code - ASCII_a + 10\n  }\n  return -1 // Invalid hex character\n}\n","import { BufferError, ParseError } from '../../errors'\nimport { hexValue } from './hex'\n\nconst UUID_BYTE_LENGTH = 16\nconst UUID_STRING_LENGTH = 36\n\n// Mapping from UUID string position to byte index.\n// -1 indicates a dash position that should be skipped.\n// This avoids intermediate string allocations during parsing.\nconst UUID_CHAR_TO_BYTE: number[] = [\n  0,\n  0,\n  1,\n  1,\n  2,\n  2,\n  3,\n  3, // chars 0-7 → bytes 0-3\n  -1, // char 8 is '-'\n  4,\n  4,\n  5,\n  5, // chars 9-12 → bytes 4-5\n  -1, // char 13 is '-'\n  6,\n  6,\n  7,\n  7, // chars 14-17 → bytes 6-7\n  -1, // char 18 is '-'\n  8,\n  8,\n  9,\n  9, // chars 19-22 → bytes 8-9\n  -1, // char 23 is '-'\n  10,\n  10,\n  11,\n  11,\n  12,\n  12,\n  13,\n  13,\n  14,\n  14,\n  15,\n  15, // chars 24-35 → bytes 10-15\n]\n\n// Whether each position is the high nibble (true) or low nibble (false)\nconst UUID_CHAR_IS_HIGH: boolean[] = [\n  true,\n  false,\n  true,\n  false,\n  true,\n  false,\n  true,\n  false, // chars 0-7\n  false, // dash (ignored)\n  true,\n  false,\n  true,\n  false, // chars 9-12\n  false, // dash\n  true,\n  false,\n  true,\n  false, // chars 14-17\n  false, // dash\n  true,\n  false,\n  true,\n  false, // chars 19-22\n  false, // dash\n  true,\n  false,\n  true,\n  false,\n  true,\n  false,\n  true,\n  false,\n  true,\n  false,\n  true,\n  false, // chars 24-35\n]\n\n// Pre-computed lookup table for byte-to-hex conversion (0x00 -> \"00\", 0xff -> \"ff\")\n//\n// Note: this table must remain defined in the same module as `formatUuid`, otherwise the v8 optimizer\n// will cause a performance drop of ~36%.\nconst HEX_TABLE: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))\n\nexport function formatUuid(bytes: Uint8Array): string {\n  if (bytes.length !== UUID_BYTE_LENGTH) {\n    throw new BufferError(\n      'BYTES_INVALID_LENGTH',\n      `UUID bytes must be exactly ${UUID_BYTE_LENGTH} bytes, got ${bytes.length}`,\n      {\n        strategy: 'uuid',\n      },\n    )\n  }\n\n  return formatUuidUnchecked(bytes)\n}\n\nexport function formatUuidUnchecked(bytes: Uint8Array): string {\n  // Direct string concatenation - optimized for V8's string builder.\n  // This approach avoids loop overhead and intermediate allocations.\n  // See: https://github.com/uuidjs/uuid/pull/434\n  return (\n    HEX_TABLE[bytes[0]] +\n    HEX_TABLE[bytes[1]] +\n    HEX_TABLE[bytes[2]] +\n    HEX_TABLE[bytes[3]] +\n    '-' +\n    HEX_TABLE[bytes[4]] +\n    HEX_TABLE[bytes[5]] +\n    '-' +\n    HEX_TABLE[bytes[6]] +\n    HEX_TABLE[bytes[7]] +\n    '-' +\n    HEX_TABLE[bytes[8]] +\n    HEX_TABLE[bytes[9]] +\n    '-' +\n    HEX_TABLE[bytes[10]] +\n    HEX_TABLE[bytes[11]] +\n    HEX_TABLE[bytes[12]] +\n    HEX_TABLE[bytes[13]] +\n    HEX_TABLE[bytes[14]] +\n    HEX_TABLE[bytes[15]]\n  )\n}\n\nexport function parseUuid(value: string): Uint8Array {\n  if (value.length !== UUID_STRING_LENGTH) {\n    throw new ParseError('INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`, {\n      strategy: 'uuid',\n    })\n  }\n\n  // Validate separator positions directly (more efficient than full loop)\n  if (value[8] !== '-' || value[13] !== '-' || value[18] !== '-' || value[23] !== '-') {\n    throw new ParseError(\n      'INVALID_FORMAT',\n      `UUID string has invalid separators at positions 8, 13, 18, 23. Received: \"${value}\"`,\n      { strategy: 'uuid' },\n    )\n  }\n\n  // Parse bytes directly from UUID string without intermediate string allocations.\n  // This avoids the 9 allocations (5 slices + 4 concatenations) of the naive approach.\n  const bytes = new Uint8Array(UUID_BYTE_LENGTH)\n\n  for (let i = 0; i < UUID_STRING_LENGTH; i += 1) {\n    const byteIdx = UUID_CHAR_TO_BYTE[i]\n    if (byteIdx === -1) continue // Skip dash positions\n\n    const nibble = hexValue(value.charCodeAt(i))\n    if (nibble === -1) {\n      throw new ParseError('INVALID_CHAR', `UUID string contains invalid hex character at position ${i}`, {\n        strategy: 'uuid',\n      })\n    }\n\n    if (UUID_CHAR_IS_HIGH[i]) {\n      bytes[byteIdx] = nibble << 4\n    } else {\n      bytes[byteIdx] |= nibble\n    }\n  }\n\n  return bytes\n}\n"],"mappings":"2DAYA,SAAgB,EAAS,EAAsB,CAU7C,OATI,GAAQ,IAAW,GAAQ,GACtB,EAAO,GAEZ,GAAQ,IAAW,GAAQ,GACtB,EAAO,GAAU,GAEtB,GAAQ,IAAW,GAAQ,IACtB,EAAO,GAAU,GAEnB,EACT,CCpBA,MAMM,EAA8B,CAClC,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,GACA,EACA,EACA,EACA,EACA,GACA,EACA,EACA,EACA,EACA,GACA,EACA,EACA,EACA,EACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,EACF,EAGM,EAA+B,CACnC,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,EACF,EAMM,EAAsB,MAAM,KAAK,CAAE,OAAQ,GAAI,GAAI,EAAG,IAAM,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,EAAG,GAAG,CAAC,EAEjG,SAAgB,EAAW,EAA2B,CACpD,GAAI,EAAM,SAAW,GACnB,MAAM,IAAI,EACR,uBACA,4CAA6D,EAAM,SACnE,CACE,SAAU,MACZ,CACF,EAGF,OAAO,EAAoB,CAAK,CAClC,CAEA,SAAgB,EAAoB,EAA2B,CAI7D,OACE,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,IACA,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,IACA,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,IACA,EAAU,EAAM,IAChB,EAAU,EAAM,IAChB,IACA,EAAU,EAAM,KAChB,EAAU,EAAM,KAChB,EAAU,EAAM,KAChB,EAAU,EAAM,KAChB,EAAU,EAAM,KAChB,EAAU,EAAM,IAEpB,CAEA,SAAgB,EAAU,EAA2B,CACnD,GAAI,EAAM,SAAW,GACnB,MAAM,IAAI,EAAW,iBAAkB,0CAA0C,EAAM,SAAU,CAC/F,SAAU,MACZ,CAAC,EAIH,GAAI,EAAM,KAAO,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,IAC9E,MAAM,IAAI,EACR,iBACA,6EAA6E,EAAM,GACnF,CAAE,SAAU,MAAO,CACrB,EAKF,IAAM,EAAQ,IAAI,WAAW,EAAgB,EAE7C,IAAK,IAAI,EAAI,EAAG,EAAI,GAAoB,GAAK,EAAG,CAC9C,IAAM,EAAU,EAAkB,GAClC,GAAI,IAAY,GAAI,SAEpB,IAAM,EAAS,EAAS,EAAM,WAAW,CAAC,CAAC,EAC3C,GAAI,IAAW,GACb,MAAM,IAAI,EAAW,eAAgB,0DAA0D,IAAK,CAClG,SAAU,MACZ,CAAC,EAGC,EAAkB,GACpB,EAAM,GAAW,GAAU,EAE3B,EAAM,IAAY,CAEtB,CAEA,OAAO,CACT"}