uniku 0.4.3 → 0.6.0

package/src/ulid/ulid.ts

@@ -75,8 +75,9 @@ function writeUlidBytesUnchecked(time: number, random: Uint8Array, buf: Uint8Arr
 function writeUlidBytes(time: number, random: Uint8Array, buf: Uint8Array, offset: number): void {
   if (!isWritableRange(buf, offset, ULID_BYTES)) {
     throw new BufferError(
-      'ULID_BUFFER_OUT_OF_BOUNDS',
+      'BUFFER_OUT_OF_BOUNDS',
       `ULID byte range ${offset}:${offset + ULID_BYTES - 1} is out of buffer bounds`,
+      { strategy: 'ulid' },
     )
   }
   writeUlidBytesUnchecked(time, random, buf, offset)
@@ -110,18 +111,20 @@ function ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf
     // Explicit options provided - use them directly without monotonic state
     const optMsecs = options.msecs
     if (optMsecs !== undefined && !isIntegerInRange(optMsecs, 0, MAX_MSECS)) {
-      throw new InvalidInputError(
-        'ULID_TIMESTAMP_OUT_OF_RANGE',
-        `Timestamp must be an integer between 0 and ${MAX_MSECS}`,
-      )
+      throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', `Timestamp must be an integer between 0 and ${MAX_MSECS}`, {
+        strategy: 'ulid',
+      })
     }
     time = optMsecs ?? Date.now()
     const optRandom = options.random
     if (optRandom) {
       if (optRandom.length < RANDOM_BYTES) {
         throw new InvalidInputError(
-          'ULID_RANDOM_BYTES_TOO_SHORT',
+          'RANDOM_BYTES_TOO_SHORT',
           `Random bytes length must be >= ${RANDOM_BYTES} for ULID`,
+          {
+            strategy: 'ulid',
+          },
         )
       }
       random = optRandom
@@ -142,8 +145,9 @@ function ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf
       if (!incrementBytesInPlace(state.lastRandom)) {
         state.lastRandom.fill(0xff)
         throw new InvalidInputError(
-          'ULID_RANDOM_OVERFLOW',
+          'RANDOM_OVERFLOW',
           'ULID random component overflowed while preserving monotonic order',
+          { strategy: 'ulid' },
         )
       }
       random = state.lastRandom

package/src/uuid/common/uuid.ts

@@ -95,8 +95,11 @@ const HEX_TABLE: string[] = Array.from({ length: 256 }, (_, i) => i.toString(16)
 export function formatUuid(bytes: Uint8Array): string {
   if (bytes.length !== UUID_BYTE_LENGTH) {
     throw new BufferError(
-      'UUID_BYTES_INVALID_LENGTH',
+      'BYTES_INVALID_LENGTH',
       `UUID bytes must be exactly ${UUID_BYTE_LENGTH} bytes, got ${bytes.length}`,
+      {
+        strategy: 'uuid',
+      },
     )
   }
 
@@ -133,14 +136,17 @@ export function formatUuidUnchecked(bytes: Uint8Array): string {
 
 export function parseUuid(value: string): Uint8Array {
   if (value.length !== UUID_STRING_LENGTH) {
-    throw new ParseError('UUID_INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`)
+    throw new ParseError('INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`, {
+      strategy: 'uuid',
+    })
   }
 
   // Validate separator positions directly (more efficient than full loop)
   if (value[8] !== '-' || value[13] !== '-' || value[18] !== '-' || value[23] !== '-') {
     throw new ParseError(
-      'UUID_INVALID_SEPARATORS',
+      'INVALID_FORMAT',
       `UUID string has invalid separators at positions 8, 13, 18, 23. Received: "${value}"`,
+      { strategy: 'uuid' },
     )
   }
 
@@ -154,7 +160,9 @@ export function parseUuid(value: string): Uint8Array {
 
     const nibble = hexValue(value.charCodeAt(i))
     if (nibble === -1) {
-      throw new ParseError('UUID_INVALID_HEX_CHAR', `UUID string contains invalid hex character at position ${i}`)
+      throw new ParseError('INVALID_CHAR', `UUID string contains invalid hex character at position ${i}`, {
+        strategy: 'uuid',
+      })
     }
 
     if (UUID_CHAR_IS_HIGH[i]) {

package/src/uuid/v4.ts

@@ -69,14 +69,17 @@ function _v4<TBuf extends Uint8Array = Uint8Array>(
 ): string | TBuf {
   const random = options?.random
   if (random && random.length < UUID_BYTES) {
-    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`)
+    throw new InvalidInputError('RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`, {
+      strategy: 'uuid',
+    })
   }
 
   const outputOffset = buf ? (offset ?? 0) : 0
   if (buf && !isWritableRange(buf, outputOffset, UUID_BYTES)) {
     throw new BufferError(
-      'UUID_BUFFER_OUT_OF_BOUNDS',
+      'BUFFER_OUT_OF_BOUNDS',
       `UUID byte range ${outputOffset}:${outputOffset + UUID_BYTES - 1} is out of buffer bounds`,
+      { strategy: 'uuid' },
     )
   }
 

package/src/uuid/v7.ts

@@ -15,8 +15,15 @@ export type UuidV7Options = {
    */
   msecs?: number
   /**
-   * Unsigned 32-bit sequence value.
+   * Unsigned 32-bit counter value.
    */
+  counter?: number
+  /**
+   * Deprecated alias for `counter`; unsigned 32-bit sequence value.
+   *
+   * @deprecated Use `counter` instead. Will be removed in `1.0.0-rc.1`.
+   */
+  // TODO(v1-rc.1): remove this alias (tracked in docs/STABILITY.md).
   seq?: number
 }
 
@@ -25,7 +32,7 @@ export type UuidV7 = {
   (): string
   /** Generate a UUID v7 with explicit options or write its 16 canonical bytes into a caller-owned buffer. */
   <TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf
-  /** Generate a UUID v7 string with optional timestamp, sequence, or random bytes. */
+  /** Generate a UUID v7 string with optional timestamp, counter, or random bytes. */
   (options?: UuidV7Options, buf?: undefined, offset?: number): string
   /** Convert a UUID v7 string to its canonical 16-byte representation. */
   toBytes(id: string): Uint8Array
@@ -92,8 +99,9 @@ function writeV7BytesUnchecked(rnds: Uint8Array, msecs: number, seq: number, buf
 function writeV7Bytes(rnds: Uint8Array, msecs: number, seq: number, buf: Uint8Array, offset: number): void {
   if (!isWritableRange(buf, offset, UUID_BYTES)) {
     throw new BufferError(
-      'UUID_BUFFER_OUT_OF_BOUNDS',
+      'BUFFER_OUT_OF_BOUNDS',
       `UUID byte range ${offset}:${offset + UUID_BYTES - 1} is out of buffer bounds`,
+      { strategy: 'uuid' },
     )
   }
   writeV7BytesUnchecked(rnds, msecs, seq, buf, offset)
@@ -106,18 +114,26 @@ function v7WithOptions<TBuf extends Uint8Array = Uint8Array>(
 ): string | TBuf {
   const optMsecs = options.msecs
   if (optMsecs !== undefined && !isIntegerInRange(optMsecs, 0, MAX_MSECS)) {
-    throw new InvalidInputError(
-      'UUID_TIMESTAMP_OUT_OF_RANGE',
-      `Timestamp must be an integer between 0 and ${MAX_MSECS}`,
-    )
+    throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', `Timestamp must be an integer between 0 and ${MAX_MSECS}`, {
+      strategy: 'uuid',
+    })
+  }
+  if (options.counter !== undefined && options.seq !== undefined) {
+    throw new InvalidInputError('CONFLICTING_OPTIONS', 'Pass only one of `counter` or `seq`, not both', {
+      strategy: 'uuid',
+    })
   }
-  const optSeq = options.seq
+  const optSeq = options.counter ?? options.seq
   if (optSeq !== undefined && !isIntegerInRange(optSeq, 0, MAX_SEQ)) {
-    throw new InvalidInputError('UUID_SEQUENCE_OUT_OF_RANGE', `Sequence must be an integer between 0 and ${MAX_SEQ}`)
+    throw new InvalidInputError('COUNTER_OUT_OF_RANGE', `Counter must be an integer between 0 and ${MAX_SEQ}`, {
+      strategy: 'uuid',
+    })
   }
   const optRandom = options.random
   if (optRandom && optRandom.length < UUID_BYTES) {
-    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`)
+    throw new InvalidInputError('RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`, {
+      strategy: 'uuid',
+    })
   }
 
   const rnds = optRandom ?? rng()

package/src/xid/base32hex.ts

@@ -16,10 +16,9 @@ for (let i = 0; i < ENCODING.length; i += 1) {
 /** Encode the 12 canonical XID bytes as lowercase base32hex. */
 export function encodeBase32Hex(bytes: Uint8Array): string {
   if (bytes.length !== XID_BYTES) {
-    throw new BufferError(
-      'XID_BYTES_INVALID_LENGTH',
-      `XID bytes must be exactly ${XID_BYTES} bytes, got ${bytes.length}`,
-    )
+    throw new BufferError('BYTES_INVALID_LENGTH', `XID bytes must be exactly ${XID_BYTES} bytes, got ${bytes.length}`, {
+      strategy: 'xid',
+    })
   }
 
   ENCODED[0] = ENCODING_CODES[bytes[0] >> 3]
@@ -62,20 +61,22 @@ export function encodeCounterSuffix(lastIdentityByte: number, counter: number):
 /** Decode a canonical lowercase base32hex XID string to its 12 bytes. */
 export function decodeBase32Hex(id: string): Uint8Array {
   if (id.length !== XID_LENGTH) {
-    throw new ParseError('XID_INVALID_LENGTH', `XID string must be ${XID_LENGTH} characters, got ${id.length}`)
+    throw new ParseError('INVALID_LENGTH', `XID string must be ${XID_LENGTH} characters, got ${id.length}`, {
+      strategy: 'xid',
+    })
   }
 
   const values = new Uint8Array(XID_LENGTH)
   for (let i = 0; i < XID_LENGTH; i += 1) {
     const value = DECODING[id.charCodeAt(i)]
     if (value === 255) {
-      throw new ParseError('XID_INVALID_CHAR', `Invalid XID character: ${id[i]}`)
+      throw new ParseError('INVALID_CHAR', `Invalid XID character: ${id[i]}`, { strategy: 'xid' })
     }
     values[i] = value
   }
 
   if (values[19] !== 0 && values[19] !== 16) {
-    throw new ParseError('XID_NON_CANONICAL', 'XID trailing bits must be canonically encoded')
+    throw new ParseError('NON_CANONICAL', 'XID trailing bits must be canonically encoded', { strategy: 'xid' })
   }
 
   return new Uint8Array([

package/src/xid/xid.ts

@@ -1,5 +1,6 @@
 import { writeTimestamp32 } from '../common/bytes'
 import { randomBytes, randomUint32 } from '../common/random'
+import { resolveTimestampSecs } from '../common/timestamp'
 import { isIntegerInRange, isWritableRange } from '../common/validation'
 import { BufferError, InvalidInputError } from '../errors'
 import { decodeBase32Hex, encodeBase32Hex, encodeCounterSuffix } from './base32hex'
@@ -19,7 +20,17 @@ export type XidOptions = {
   machineId?: Uint8Array
   /** 16-bit process identity. */
   processId?: number
-  /** Unix timestamp in seconds. Defaults to the current second. */
+  /**
+   * Unix timestamp in milliseconds. Defaults to Date.now().
+   * XID stores whole seconds, so sub-second precision is truncated.
+   */
+  msecs?: number
+  /**
+   * Deprecated alias for `msecs`; Unix timestamp in seconds.
+   *
+   * @deprecated Use `msecs` instead. Will be removed in `1.0.0-rc.1`.
+   */
+  // 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
@@ -81,18 +92,20 @@ function writeXidBytesUnchecked(
 function validateOptions(options: XidOptions): void {
   if (options.machineId !== undefined && options.machineId.length < MACHINE_ID_BYTES) {
     throw new InvalidInputError(
-      'XID_MACHINE_ID_BYTES_TOO_SHORT',
+      'MACHINE_ID_BYTES_TOO_SHORT',
       `Machine ID bytes length must be >= ${MACHINE_ID_BYTES} for XID`,
+      { strategy: 'xid' },
     )
   }
   if (options.processId !== undefined && !isIntegerInRange(options.processId, 0, MAX_PROCESS_ID)) {
-    throw new InvalidInputError('XID_PROCESS_ID_OUT_OF_RANGE', `Process ID must be between 0 and ${MAX_PROCESS_ID}`)
-  }
-  if (options.secs !== undefined && !isIntegerInRange(options.secs, 0, MAX_SECS)) {
-    throw new InvalidInputError('XID_TIMESTAMP_OUT_OF_RANGE', `Timestamp must be between 0 and ${MAX_SECS}`)
+    throw new InvalidInputError('PROCESS_ID_OUT_OF_RANGE', `Process ID must be between 0 and ${MAX_PROCESS_ID}`, {
+      strategy: 'xid',
+    })
   }
   if (options.counter !== undefined && !isIntegerInRange(options.counter, 0, MAX_COUNTER)) {
-    throw new InvalidInputError('XID_COUNTER_OUT_OF_RANGE', `Counter must be between 0 and ${MAX_COUNTER}`)
+    throw new InvalidInputError('COUNTER_OUT_OF_RANGE', `Counter must be between 0 and ${MAX_COUNTER}`, {
+      strategy: 'xid',
+    })
   }
 }
 
@@ -113,7 +126,8 @@ function xidFn<TBuf extends Uint8Array = Uint8Array>(options?: XidOptions, buf?:
 
   if (options !== undefined) validateOptions(options)
 
-  const secs = options?.secs ?? Math.floor(Date.now() / 1000)
+  const resolvedSecs = options === undefined ? undefined : resolveTimestampSecs(options, 0, MAX_SECS, 'xid')
+  const secs = resolvedSecs ?? Math.floor(Date.now() / 1000)
   if (options?.machineId === undefined || options.processId === undefined) {
     initializeIdentity()
   }
@@ -123,10 +137,9 @@ function xidFn<TBuf extends Uint8Array = Uint8Array>(options?: XidOptions, buf?:
 
   if (buf !== undefined) {
     if (!isWritableRange(buf, offset, XID_BYTES)) {
-      throw new BufferError(
-        'XID_BUFFER_OUT_OF_BOUNDS',
-        `XID byte range ${offset}:${offset + 11} is out of buffer bounds`,
-      )
+      throw new BufferError('BUFFER_OUT_OF_BOUNDS', `XID byte range ${offset}:${offset + 11} is out of buffer bounds`, {
+        strategy: 'xid',
+      })
     }
     writeXidBytesUnchecked(secs, machineId, processId, counter, buf, offset)
     return buf

package/build/errors-Dgoyi-ci.d.mts

@@ -1,38 +0,0 @@
-//#region src/errors.d.ts
-/**
-* Base error for all uniku errors.
-* Provides `_tag` for discriminated matching (compatible with Effect's `catchTag`)
-* and `code` for machine-readable error identification.
-*/
-declare abstract class UniqueIdError extends Error {
-  abstract readonly _tag: string;
-  abstract readonly code: string;
-  constructor(message: string);
-}
-/**
-* Thrown when generator arguments are invalid (bad size, alphabet, length, timestamp, version).
-*/
-declare class InvalidInputError extends UniqueIdError {
-  readonly code: string;
-  readonly _tag = "InvalidInputError";
-  constructor(code: string, message: string);
-}
-/**
-* Thrown when parsing/decoding an ID string that has invalid format or characters.
-*/
-declare class ParseError extends UniqueIdError {
-  readonly code: string;
-  readonly _tag = "ParseError";
-  constructor(code: string, message: string);
-}
-/**
-* Thrown when a byte array or buffer is too short or an offset is out of bounds.
-*/
-declare class BufferError extends UniqueIdError {
-  readonly code: string;
-  readonly _tag = "BufferError";
-  constructor(code: string, message: string);
-}
-//#endregion
-export { UniqueIdError as i, InvalidInputError as n, ParseError as r, BufferError as t };
-//# sourceMappingURL=errors-Dgoyi-ci.d.mts.map

package/build/errors-Dgoyi-ci.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-Dgoyi-ci.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;AAKA;;;;uBAAsB,aAAA,SAAsB,KAAA;EAAA,kBACxB,IAAA;EAAA,kBACA,IAAA;EAElB,WAAA,CAAY,OAAA;AAAA;;AAAA;AASd;cAAa,iBAAA,SAA0B,aAAA;EAAA,SAInC,IAAA;EAAA,SAHO,IAAA;EAET,WAAA,CACE,IAAA,UACA,OAAA;AAAA;;;;cASS,UAAA,SAAmB,aAAA;EAAA,SAI5B,IAAA;EAAA,SAHO,IAAA;EAET,WAAA,CACE,IAAA,UACA,OAAA;AAAA;;;;cASS,WAAA,SAAoB,aAAA;EAAA,SAI7B,IAAA;EAAA,SAHO,IAAA;EAET,WAAA,CACE,IAAA,UACA,OAAA;AAAA"}

package/build/generators.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generators.d.mts","names":[],"sources":["../src/generators.ts"],"mappings":";;AAWA;;;;AAAuG;AAKvG;;cALa,aAAA;;AAKqB;;KAAtB,WAAA,WAAsB,aAAA"}

package/build/uuid-CnQIYoQi.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(`UUID_BYTES_INVALID_LENGTH`,`UUID bytes must be exactly 16 bytes, got ${t.length}`);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(`UUID_INVALID_LENGTH`,`UUID string must be 36 characters, got ${e.length}`);if(e[8]!==`-`||e[13]!==`-`||e[18]!==`-`||e[23]!==`-`)throw new t(`UUID_INVALID_SEPARATORS`,`UUID string has invalid separators at positions 8, 13, 18, 23. Received: "${e}"`);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(`UUID_INVALID_HEX_CHAR`,`UUID string contains invalid hex character at position ${o}`);i[o]?a[s]=c<<4:a[s]|=c}return a}export{s as n,c as r,o as t};
-//# sourceMappingURL=uuid-CnQIYoQi.mjs.map

package/build/uuid-CnQIYoQi.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuid-CnQIYoQi.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      'UUID_BYTES_INVALID_LENGTH',\n      `UUID bytes must be exactly ${UUID_BYTE_LENGTH} bytes, got ${bytes.length}`,\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('UUID_INVALID_LENGTH', `UUID string must be 36 characters, got ${value.length}`)\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      'UUID_INVALID_SEPARATORS',\n      `UUID string has invalid separators at positions 8, 13, 18, 23. Received: \"${value}\"`,\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('UUID_INVALID_HEX_CHAR', `UUID string contains invalid hex character at position ${i}`)\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,4BACA,4CAA6D,EAAM,QACrE,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,sBAAuB,0CAA0C,EAAM,QAAQ,EAItG,GAAI,EAAM,KAAO,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,IAC9E,MAAM,IAAI,EACR,0BACA,6EAA6E,EAAM,EACrF,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,wBAAyB,0DAA0D,GAAG,EAGzG,EAAkB,GACpB,EAAM,GAAW,GAAU,EAE3B,EAAM,IAAY,CAEtB,CAEA,OAAO,CACT"}