uniku 0.0.13 → 0.2.0

package/build/uuid/v7.mjs

@@ -1,2 +1,2 @@
-import{n as e}from"../random-CWCVvNLb.mjs";import{BufferError as t,InvalidInputError as n,ParseError as r,UniqueIdError as i}from"../errors.mjs";import{n as a,t as o}from"../uuid-QysI8pWE.mjs";const s=/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,c=new Uint8Array(16),l={msecs:-1/0,seq:0};function u(e,r,i,a,o=0){if(e.length<16)throw new n(`UUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`);if(o<0||o+16>a.length)throw new t(`UUID_BUFFER_OUT_OF_BOUNDS`,`UUID byte range ${o}:${o+15} is out of buffer bounds`);return r??=Date.now(),i??=e[6]<<23|e[7]<<16|e[8]<<8|e[9],a[o++]=r/1099511627776&255,a[o++]=r/4294967296&255,a[o++]=r/16777216&255,a[o++]=r/65536&255,a[o++]=r/256&255,a[o++]=r&255,a[o++]=112|i>>>28&15,a[o++]=i>>>20&255,a[o++]=128|i>>>14&63,a[o++]=i>>>6&255,a[o++]=i<<2&255|e[10]&3,a[o++]=e[11],a[o++]=e[12],a[o++]=e[13],a[o++]=e[14],a[o++]=e[15],a}function d(t,n,r){let i;if(t)i=u(t.random??e(),t.msecs,t.seq,n??c,n?r:0);else{let t=Date.now(),a=e();t>l.msecs?(l.seq=a[6]<<23|a[7]<<16|a[8]<<8|a[9],l.msecs=t):(l.seq=l.seq+1|0,l.seq<0&&(l.seq=0,l.msecs++)),i=u(a,l.msecs,l.seq,n??c,n?r:0)}return n?i:o(i)}function f(e){let t=a(e),n=0;for(let e=0;e<6;e+=1)n=n*256+t[e];return n}function p(e){return typeof e==`string`&&s.test(e)}const m=Object.assign(d,{toBytes:a,fromBytes:o,timestamp:f,isValid:p,NIL:`00000000-0000-0000-0000-000000000000`,MAX:`ffffffff-ffff-ffff-ffff-ffffffffffff`});export{t as BufferError,n as InvalidInputError,r as ParseError,i as UniqueIdError,m as uuidv7};
+import{r as e}from"../random-C_nRoaUe.mjs";import{BufferError as t,InvalidInputError as n,ParseError as r,UniqueIdError as i}from"../errors.mjs";import{n as a,t as o}from"../uuid-C9VcXh5N.mjs";const s=/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,c=new Uint8Array(16),l={msecs:-1/0,seq:0};function u(e,r,i,a,o=0){if(e.length<16)throw new n(`UUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`);if(o<0||o+16>a.length)throw new t(`UUID_BUFFER_OUT_OF_BOUNDS`,`UUID byte range ${o}:${o+15} is out of buffer bounds`);return r??=Date.now(),i??=e[6]<<23|e[7]<<16|e[8]<<8|e[9],a[o++]=r/1099511627776&255,a[o++]=r/4294967296&255,a[o++]=r/16777216&255,a[o++]=r/65536&255,a[o++]=r/256&255,a[o++]=r&255,a[o++]=112|i>>>28&15,a[o++]=i>>>20&255,a[o++]=128|i>>>14&63,a[o++]=i>>>6&255,a[o++]=i<<2&255|e[10]&3,a[o++]=e[11],a[o++]=e[12],a[o++]=e[13],a[o++]=e[14],a[o++]=e[15],a}function d(t,n,r){let i;if(t)i=u(t.random??e(),t.msecs,t.seq,n??c,n?r:0);else{let t=Date.now(),a=e();t>l.msecs?(l.seq=a[6]<<23|a[7]<<16|a[8]<<8|a[9],l.msecs=t):(l.seq=l.seq+1|0,l.seq<0&&(l.seq=0,l.msecs++)),i=u(a,l.msecs,l.seq,n??c,n?r:0)}return n?i:o(i)}function f(e){let t=a(e),n=0;for(let e=0;e<6;e+=1)n=n*256+t[e];return n}function p(e){return typeof e==`string`&&s.test(e)}const m=Object.assign(d,{toBytes:a,fromBytes:o,timestamp:f,isValid:p,NIL:`00000000-0000-0000-0000-000000000000`,MAX:`ffffffff-ffff-ffff-ffff-ffffffffffff`});export{t as BufferError,n as InvalidInputError,r as ParseError,i as UniqueIdError,m as uuidv7};
 //# sourceMappingURL=v7.mjs.map

package/build/{uuid-QysI8pWE.mjs → uuid-C9VcXh5N.mjs}

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

package/build/{uuid-QysI8pWE.mjs.map → uuid-C9VcXh5N.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"uuid-QysI8pWE.mjs","names":["UUID_CHAR_TO_BYTE: number[]","UUID_CHAR_IS_HIGH: boolean[]","HEX_TABLE: string[]"],"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 { 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  // 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":"0CAYA,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,GCnBT,MAMMA,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,GACD,CAGKC,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,GACD,CAMKC,EAAsB,MAAM,KAAK,CAAE,OAAQ,IAAK,EAAG,EAAG,IAAM,EAAE,SAAS,GAAG,CAAC,SAAS,EAAG,IAAI,CAAC,CAElG,SAAgB,EAAW,EAA2B,CAIpD,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,KAIpB,SAAgB,EAAU,EAA2B,CACnD,GAAI,EAAM,SAAW,GACnB,MAAM,IAAI,EAAW,sBAAuB,0CAA0C,EAAM,SAAS,CAIvG,GAAI,EAAM,KAAO,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,IAC9E,MAAM,IAAI,EACR,0BACA,6EAA6E,EAAM,GACpF,CAKH,IAAM,EAAQ,IAAI,WAAW,GAAiB,CAE9C,IAAK,IAAI,EAAI,EAAG,EAAI,GAAoB,GAAK,EAAG,CAC9C,IAAM,EAAU,EAAkB,GAClC,GAAI,IAAY,GAAI,SAEpB,IAAM,EAAS,EAAS,EAAM,WAAW,EAAE,CAAC,CAC5C,GAAI,IAAW,GACb,MAAM,IAAI,EAAW,wBAAyB,0DAA0D,IAAI,CAG1G,EAAkB,GACpB,EAAM,GAAW,GAAU,EAE3B,EAAM,IAAY,EAItB,OAAO"}
+{"version":3,"file":"uuid-C9VcXh5N.mjs","names":["UUID_CHAR_TO_BYTE: number[]","UUID_CHAR_IS_HIGH: boolean[]","HEX_TABLE: string[]"],"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 { 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  // 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":"0CAYA,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,GCnBT,MAMMA,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,GACD,CAGKC,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,GACD,CAMKC,EAAsB,MAAM,KAAK,CAAE,OAAQ,IAAK,EAAG,EAAG,IAAM,EAAE,SAAS,GAAG,CAAC,SAAS,EAAG,IAAI,CAAC,CAElG,SAAgB,EAAW,EAA2B,CAIpD,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,KAIpB,SAAgB,EAAU,EAA2B,CACnD,GAAI,EAAM,SAAW,GACnB,MAAM,IAAI,EAAW,sBAAuB,0CAA0C,EAAM,SAAS,CAIvG,GAAI,EAAM,KAAO,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,KAAO,EAAM,MAAQ,IAC9E,MAAM,IAAI,EACR,0BACA,6EAA6E,EAAM,GACpF,CAKH,IAAM,EAAQ,IAAI,WAAW,GAAiB,CAE9C,IAAK,IAAI,EAAI,EAAG,EAAI,GAAoB,GAAK,EAAG,CAC9C,IAAM,EAAU,EAAkB,GAClC,GAAI,IAAY,GAAI,SAEpB,IAAM,EAAS,EAAS,EAAM,WAAW,EAAE,CAAC,CAC5C,GAAI,IAAW,GACb,MAAM,IAAI,EAAW,wBAAyB,0DAA0D,IAAI,CAG1G,EAAkB,GACpB,EAAM,GAAW,GAAU,EAE3B,EAAM,IAAY,EAItB,OAAO"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "private": false,
   "name": "uniku",
-  "version": "0.0.13",
-  "description": "Minimal, tree-shakeable UUID utilities for every JavaScript runtime",
+  "version": "0.2.0",
+  "description": "Minimal, tree-shakeable unique ID generators for every JavaScript runtime",
   "author": {
     "name": "Alberto Schiabel",
     "email": "alberto.schiabel@gmail.com",
@@ -23,9 +23,12 @@
     "uuidv4",
     "uuidv7",
     "ulid",
+    "typeid",
     "cuid2",
     "nanoid",
     "ksuid",
+    "objectid",
+    "mongodb",
     "unique",
     "id",
     "identifier",
@@ -70,6 +73,11 @@
       "import": "./build/ulid/ulid.mjs",
       "default": "./build/ulid/ulid.mjs"
     },
+    "./typeid": {
+      "types": "./build/typeid/typeid.d.mts",
+      "import": "./build/typeid/typeid.mjs",
+      "default": "./build/typeid/typeid.mjs"
+    },
     "./cuid2": {
       "types": "./build/cuid2/cuid2.d.mts",
       "import": "./build/cuid2/cuid2.mjs",
@@ -85,6 +93,11 @@
       "import": "./build/ksuid/ksuid.mjs",
       "default": "./build/ksuid/ksuid.mjs"
     },
+    "./objectid": {
+      "types": "./build/objectid/objectid.d.mts",
+      "import": "./build/objectid/objectid.mjs",
+      "default": "./build/objectid/objectid.mjs"
+    },
     "./errors": {
       "types": "./build/errors.d.mts",
       "import": "./build/errors.mjs",
@@ -99,7 +112,9 @@
     "@owpz/ksuid": "^25.7.20",
     "@paralleldrive/cuid2": "^3.3.0",
     "@types/bun": "^1.3.8",
+    "bson": "^7.3.1",
     "nanoid": "^5.1.6",
+    "typeid-js": "1.2.0",
     "ulid": "3.0.2",
     "uuid": "13.0.0"
   },

package/src/nanoid/nanoid.ts

@@ -10,11 +10,12 @@ const NANOID_REGEX = /^[A-Za-z0-9_-]+$/
 // Keep Nanoid's private pool for its default hot path. It consumes `size`
 // bytes directly without the shared helper's UUID/CUID2-oriented branches.
 const POOL_SIZE_MULTIPLIER = 128
+const MAX_POOL_SIZE = 65_536
 let pool: Uint8Array | undefined
 let poolOffset = 0
 
 function fillPool(bytes: number): void {
-  const size = bytes * POOL_SIZE_MULTIPLIER
+  const size = Math.min(bytes * POOL_SIZE_MULTIPLIER, MAX_POOL_SIZE)
   if (!pool || pool.length < size) {
     pool = new Uint8Array(size)
     crypto.getRandomValues(pool)
@@ -26,6 +27,15 @@ function fillPool(bytes: number): void {
   poolOffset += bytes
 }
 
+function defaultAlphabetFromPool(size: number): string {
+  fillPool(size)
+  let id = ''
+  for (let i = poolOffset - size; i < poolOffset; i++) {
+    id += URL_ALPHABET[pool![i] & 63]
+  }
+  return id
+}
+
 export type NanoidOptions = {
   /**
    * Random bytes for deterministic output (testing).
@@ -104,12 +114,7 @@ function nanoidFn(sizeOrOptions?: number | NanoidOptions): string {
   // ULTRA-FAST PATH: No arguments = default nanoid
   // Uses simple pooled random bytes (npm nanoid style) for best performance
   if (sizeOrOptions === undefined) {
-    fillPool(DEFAULT_SIZE)
-    let id = ''
-    for (let i = poolOffset - DEFAULT_SIZE; i < poolOffset; i++) {
-      id += URL_ALPHABET[pool![i] & 63]
-    }
-    return id
+    return defaultAlphabetFromPool(DEFAULT_SIZE)
   }
 
   let size = DEFAULT_SIZE
@@ -131,6 +136,10 @@ function nanoidFn(sizeOrOptions?: number | NanoidOptions): string {
 
   if (size === 0) return ''
 
+  if (alphabet === URL_ALPHABET && randomBytes === undefined) {
+    return defaultAlphabetFromPool(size)
+  }
+
   const alphabetLen = alphabet.length
 
   // FAST PATH: Power-of-2 alphabet (includes default 64-char)

package/src/objectid/hex.ts

@@ -0,0 +1,89 @@
+import { BufferError, ParseError } from '../errors'
+
+/**
+ * Hex encoding/decoding for ObjectID.
+ * Alphabet: 0-9a-f (lowercase on encode, case-insensitive on decode)
+ *
+ * ObjectID binary format: 12 bytes (96 bits)
+ * - 4 bytes: big-endian Unix timestamp in seconds
+ * - 5 bytes: per-process random value
+ * - 3 bytes: big-endian counter
+ *
+ * String format: 24 characters of hex
+ */
+
+const HEX_CHARS = '0123456789abcdef'
+const OBJECTID_BYTES = 12
+const OBJECTID_STRING_LEN = 24
+
+// Pre-computed encode table: byte value (0-255) -> 2-char lowercase hex string.
+const ENCODE_TABLE: string[] = Array.from(
+  { length: 256 },
+  (_, byte) => HEX_CHARS[(byte >> 4) & 0xf] + HEX_CHARS[byte & 0xf],
+)
+
+// Pre-computed decode table covering every UTF-16 code unit charCodeAt can
+// return, so lookups never go out of bounds and a single `=== 255` check
+// rejects invalid input (including non-ASCII) without a per-character range
+// check. Costs 128 KiB once at module load; valid inputs only touch the first
+// 128 bytes, so cache behavior is unaffected.
+// Note: unlike Base62, hex decoding is case-insensitive - 'a' and 'A' both decode to 10.
+const DECODING = new Uint8Array(65536)
+DECODING.fill(255) // 255 = invalid marker
+
+for (let i = 0; i <= 9; i += 1) {
+  DECODING['0'.charCodeAt(0) + i] = i
+}
+for (let i = 0; i < 6; i += 1) {
+  DECODING['a'.charCodeAt(0) + i] = 10 + i
+  DECODING['A'.charCodeAt(0) + i] = 10 + i
+}
+
+/**
+ * Encode 12 ObjectID bytes to a 24-character lowercase hex string.
+ */
+export function encodeObjectIdHex(bytes: Uint8Array): string {
+  if (bytes.length < OBJECTID_BYTES) {
+    throw new BufferError(
+      'OBJECTID_BYTES_TOO_SHORT',
+      `ObjectID bytes must be at least ${OBJECTID_BYTES} bytes, got ${bytes.length}`,
+    )
+  }
+
+  let encoded = ''
+  for (let i = 0; i < OBJECTID_BYTES; i += 1) {
+    encoded += ENCODE_TABLE[bytes[i]]
+  }
+  return encoded
+}
+
+/**
+ * Decode a 24-character hex string to 12 ObjectID bytes.
+ */
+export function decodeObjectIdHex(str: string): Uint8Array {
+  if (str.length !== OBJECTID_STRING_LEN) {
+    throw new ParseError(
+      'OBJECTID_INVALID_LENGTH',
+      `ObjectID string must be ${OBJECTID_STRING_LEN} characters, got ${str.length}`,
+    )
+  }
+
+  const bytes = new Uint8Array(OBJECTID_BYTES)
+  for (let i = 0; i < OBJECTID_BYTES; i += 1) {
+    const hiIndex = i * 2
+    const loIndex = hiIndex + 1
+    const hi = DECODING[str.charCodeAt(hiIndex)]
+    const lo = DECODING[str.charCodeAt(loIndex)]
+
+    if (hi === 255) {
+      throw new ParseError('OBJECTID_INVALID_CHAR', `Invalid ObjectID character: ${str[hiIndex]}`)
+    }
+    if (lo === 255) {
+      throw new ParseError('OBJECTID_INVALID_CHAR', `Invalid ObjectID character: ${str[loIndex]}`)
+    }
+
+    bytes[i] = (hi << 4) | lo
+  }
+
+  return bytes
+}

package/src/objectid/objectid.ts

@@ -0,0 +1,266 @@
+import { writeTimestamp32 } from '../common/bytes'
+import { randomBytes, randomUint32 } from '../common/random'
+import { BufferError, InvalidInputError } from '../errors'
+import { decodeObjectIdHex, encodeObjectIdHex } from './hex'
+
+/**
+ * MongoDB ObjectID
+ *
+ * A 96-bit (12-byte) identifier consisting of:
+ * - 4 bytes: big-endian Unix timestamp in seconds
+ * - 5 bytes: per-process random value
+ * - 3 bytes: big-endian counter, always incrementing (wraps at 0xFFFFFF back to 0)
+ *
+ * Encoded as a 24-character lowercase hex string.
+ */
+
+const OBJECTID_BYTES = 12
+const TIMESTAMP_BYTES = 4
+const RANDOM_BYTES = 5
+const COUNTER_BYTES = 3
+const MAX_SECS = 0xffffffff
+const MAX_COUNTER = 0xffffff
+
+// Validation regex: case-insensitive per KTD7, matching bson's ObjectId.isValid()
+const OBJECTID_REGEX = /^[0-9a-f]{24}$/i
+
+export type ObjectIdOptions = {
+  /**
+   * 5 bytes of random data to use for the ObjectID's random field.
+   */
+  random?: Uint8Array
+  /**
+   * Timestamp in seconds since Unix epoch.
+   * Defaults to Math.floor(Date.now() / 1000).
+   */
+  secs?: number
+  /**
+   * 24-bit counter value (0 to 0xFFFFFF).
+   */
+  counter?: number
+}
+
+export type ObjectId = {
+  (): string
+  <TBuf extends Uint8Array = Uint8Array>(options: ObjectIdOptions | undefined, buf: TBuf, offset?: number): TBuf
+  (options?: ObjectIdOptions, buf?: undefined, offset?: number): string
+  toBytes(id: string): Uint8Array
+  fromBytes(bytes: Uint8Array): string
+  timestamp(id: string): number
+  isValid(id: unknown): id is string
+  /** The nil ObjectID (all zeros) */
+  NIL: string
+  /** The max ObjectID (all 0xff) */
+  MAX: string
+}
+
+type ObjectIdState = {
+  random: Uint8Array | undefined
+  counter: number | undefined
+}
+
+/**
+ * Module-level state for the per-process random value and the always-incrementing counter.
+ *
+ * IMPORTANT: This state persists across all objectid() calls in the module's lifetime.
+ * - In serverless/edge functions with warm starts, state persists between invocations.
+ *   Unlike ULID/UUIDv7's per-timestamp sequence reset, the counter continuing to climb
+ *   across warm starts is exactly the anti-collision behavior the ObjectID spec intends.
+ * - For isolated state, pass explicit `random`, `secs`, or `counter` via options.
+ * - Tests should mock Date.now() or provide explicit options for deterministic behavior.
+ */
+const state: ObjectIdState = {
+  random: undefined,
+  counter: undefined,
+}
+
+/**
+ * Draw 5 fresh random bytes into a newly-owned buffer, copying immediately so the
+ * result is unaffected by any later pool refill triggered by other random draws
+ * (e.g. the counter's `randomUint32()` call) before these bytes are consumed.
+ */
+function freshRandom(): Uint8Array {
+  const bytes = new Uint8Array(RANDOM_BYTES)
+  bytes.set(randomBytes(RANDOM_BYTES))
+  return bytes
+}
+
+function objectIdBytes(secs: number, random: Uint8Array, counter: number, buf?: Uint8Array, offset = 0): Uint8Array {
+  if (!buf) {
+    buf = new Uint8Array(OBJECTID_BYTES)
+    offset = 0
+  } else if (offset < 0 || offset + OBJECTID_BYTES > buf.length) {
+    throw new BufferError(
+      'OBJECTID_BUFFER_OUT_OF_BOUNDS',
+      `ObjectID byte range ${offset}:${offset + OBJECTID_BYTES - 1} is out of buffer bounds`,
+    )
+  }
+
+  // Timestamp (32-bit big-endian seconds since Unix epoch) -> bytes 0-3
+  writeTimestamp32(buf, offset, secs)
+
+  // Random (5 bytes) -> bytes 4-8
+  for (let i = 0; i < RANDOM_BYTES; i += 1) {
+    buf[offset + TIMESTAMP_BYTES + i] = random[i]
+  }
+
+  // Counter (24-bit big-endian) -> bytes 9-11
+  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES] = (counter >>> 16) & 0xff
+  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + 1] = (counter >>> 8) & 0xff
+  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + COUNTER_BYTES - 1] = counter & 0xff
+
+  return buf
+}
+
+/*
+ * Overload: no buffer => return an ObjectID string.
+ */
+function objectIdFn(options?: ObjectIdOptions, buf?: undefined, offset?: number): string
+/*
+ * Overload: caller provides a buffer slice to fill with ObjectID bytes.
+ */
+function objectIdFn<TBuf extends Uint8Array = Uint8Array>(
+  options: ObjectIdOptions | undefined,
+  buf: TBuf,
+  offset?: number,
+): TBuf
+function objectIdFn<TBuf extends Uint8Array = Uint8Array>(
+  options?: ObjectIdOptions,
+  buf?: TBuf,
+  offset = 0,
+): string | TBuf {
+  let secs: number
+  let random: Uint8Array
+  let counter: number
+
+  if (options) {
+    const optRandom = options.random
+    if (optRandom && optRandom.length < RANDOM_BYTES) {
+      throw new InvalidInputError(
+        'OBJECTID_RANDOM_BYTES_TOO_SHORT',
+        `Random bytes length must be >= ${RANDOM_BYTES} for ObjectID`,
+      )
+    }
+
+    const optSecs = options.secs
+    if (optSecs !== undefined && (optSecs < 0 || optSecs > MAX_SECS)) {
+      throw new InvalidInputError('OBJECTID_TIMESTAMP_OUT_OF_RANGE', `Timestamp must be between 0 and ${MAX_SECS}`)
+    }
+
+    const optCounter = options.counter
+    if (optCounter !== undefined && (optCounter < 0 || optCounter > MAX_COUNTER)) {
+      throw new InvalidInputError('OBJECTID_COUNTER_OUT_OF_RANGE', `Counter must be between 0 and ${MAX_COUNTER}`)
+    }
+
+    // Options bypass persistent state entirely: every field is sourced fresh (given
+    // value, or an independently-defaulted one), never read from or written to
+    // `state` (see KTD2). This is what makes options-based generation deterministic
+    // when all three fields are supplied.
+    secs = optSecs ?? Math.floor(Date.now() / 1000)
+    random = optRandom ?? freshRandom()
+    counter = optCounter ?? randomUint32() & MAX_COUNTER
+  } else {
+    // Lazily initialize persistent state on first no-option call.
+    if (state.random === undefined) {
+      state.random = freshRandom()
+    }
+    if (state.counter === undefined) {
+      state.counter = randomUint32() & MAX_COUNTER
+    }
+
+    /**
+     * Note: by default, Cloudflare Workers "freezes" time during request handling to prevent
+     * side-channel attacks. This means that Date.now() will return the same value for the entire
+     * duration of a request.
+     * Implications:
+     * - all ObjectIDs generated within a single request will share the same timestamp.
+     * - monotonic ordering relies entirely on the ever-incrementing counter.
+     */
+    secs = Math.floor(Date.now() / 1000)
+    random = state.random
+    state.counter = (state.counter + 1) & MAX_COUNTER
+    counter = state.counter
+  }
+
+  if (buf) {
+    objectIdBytes(secs, random, counter, buf, offset)
+    return buf
+  }
+
+  const bytes = objectIdBytes(secs, random, counter)
+  return encodeObjectIdHex(bytes)
+}
+
+/**
+ * Convert an ObjectID hex string to 12 bytes.
+ */
+function toBytes(id: string): Uint8Array {
+  return decodeObjectIdHex(id)
+}
+
+/**
+ * Convert 12 bytes to an ObjectID hex string.
+ */
+function fromBytes(bytes: Uint8Array): string {
+  return encodeObjectIdHex(bytes)
+}
+
+/**
+ * Extract the timestamp from an ObjectID string.
+ * Returns Unix timestamp in milliseconds for API consistency with ulid/uuidv7/ksuid.
+ * Note: ObjectID only has second precision, so the returned value will always end in 000.
+ */
+function timestamp(id: string): number {
+  const bytes = decodeObjectIdHex(id)
+  // First 4 bytes are big-endian timestamp (seconds since Unix epoch)
+  const secs = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0
+  return secs * 1000
+}
+
+/**
+ * Validate an ObjectID string format.
+ * Case-insensitive (KTD7), matching bson's ObjectId.isValid() and this repo's existing
+ * convention (ulid, ksuid) of accepting mixed-case input for parsing, even though
+ * generation always emits lowercase (matching MongoDB driver output).
+ */
+function isValid(id: unknown): id is string {
+  return typeof id === 'string' && OBJECTID_REGEX.test(id)
+}
+
+/**
+ * Generate a MongoDB ObjectID string or write the bytes into a buffer.
+ *
+ * ObjectID is a 12-byte identifier consisting of a 4-byte timestamp, a 5-byte
+ * per-process random value, and a 3-byte always-incrementing counter, encoded
+ * as a 24-character lowercase hex string. It is time-ordered and compatible
+ * with MongoDB's own ObjectID implementation.
+ *
+ * @example
+ * ```ts
+ * import { objectid } from 'uniku/objectid'
+ *
+ * const id = objectid()
+ * // => "667c3f2a1e2b3c4d5e6f7081"
+ *
+ * // Extract timestamp
+ * const ts = objectid.timestamp(id)
+ * console.log(new Date(ts))
+ *
+ * // Validate
+ * objectid.isValid(id) // true
+ *
+ * // Convert to/from bytes (12 bytes)
+ * const bytes = objectid.toBytes(id)
+ * const restored = objectid.fromBytes(bytes)
+ * ```
+ */
+export const objectid: ObjectId = Object.assign(objectIdFn, {
+  toBytes,
+  fromBytes,
+  timestamp,
+  isValid,
+  NIL: '0'.repeat(24),
+  MAX: 'f'.repeat(24),
+})
+
+export { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'