uniku 0.0.12 → 0.0.13

package/README.md

@@ -7,7 +7,7 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 
-One library. Every ID format. Every runtime. Zero dependencies.
+One library. Every ID format. Every runtime. One runtime dependency (`@noble/hashes`, CUID2 only).
 
 > **uniku** */uˈniːku/* — Maltese for "unique"
 
@@ -32,12 +32,15 @@ console.log(first < second && second < third) // true
 | CUID2              |   ✅  |  ❌  |   ❌   |  ❌  |   ✅  |   ❌  |
 | Nanoid             |   ✅  |  ❌  |   ✅   |  ❌  |   ❌  |   ❌  |
 | KSUID              |   ✅  |  ❌  |   ❌   |  ❌  |   ❌  |   ✅  |
-| Tree-shakeable     |   ✅  |  ❌  |   ✅   |  ✅  |   ✅  |   ✅  |
-| ESM-only           |   ✅  |  ❌  |   ✅   |  ✅  |   ✅  |   ✅  |
-| Edge/Workers       |   ✅  |  ⚠️  |   ✅   |  ⚠️  |   ✅  |   ✅  |
-| Byte ↔ String      |   ✅  |  ✅  |   -   |  ✅   |   -  |   ✅  |
+| Tree-shakeable     |   ✅  |  ✅  |   ✅   |  ✅  |   ✅  |   ❌  |
+| ESM-only           |   ✅  | ✅¹  |   ✅   |  ❌  |   ✅  |   ❌  |
+| Edge/Workers       |   ✅  |  ✅  |   ✅   |  ⚠️  |   ✅  |  ⚠️  |
+| Byte ↔ String      |   ✅  |  ✅  |   -   |  ⚠️²  |   -  |   ✅  |
 
-> **Note**: Byte ↔ String conversion doesn't make sense for nanoid and cuid2, since they are string-native formats with no canonical binary representation.
+> **Notes:**
+> - Byte ↔ String conversion doesn't make sense for nanoid and cuid2, since they are string-native formats with no canonical binary representation.
+> - ¹ `uuid@13` is ESM-only; earlier versions support CommonJS.
+> - ² `ulid` only provides timestamp encoding/decoding, not full binary serialization.
 
 ### Works Everywhere
 
@@ -173,12 +176,14 @@ deno install npm:uniku
 
 | Import | Minified + gzipped |
 |--------|-------------------:|
-| `uniku/uuid/v4` | ~940 B |
-| `uniku/uuid/v7` | ~1.1 KB |
-| `uniku/ulid` | ~1.5 KB |
-| `uniku/cuid2` | ~1.1 KB* |
-| `uniku/nanoid` | ~938 B |
-| `uniku/ksuid` | ~1.0 KB |
+| `uniku/uuid/v4` | ~1.1 KB |
+| `uniku/uuid/v7` | ~1.4 KB |
+| `uniku/ulid` | ~1.8 KB |
+| `uniku/cuid2` | ~1007 B* |
+| `uniku/nanoid` | ~1.1 KB |
+| `uniku/ksuid` | ~1.3 KB |
+
+* The CUID2 entry point imports SHA3-512 from `@noble/hashes`; this table's entry-point size excludes that external dependency.
 
 ## Quick Start
 

package/build/{bytes-BBjKLOBR.mjs → bytes-NRtBOHK5.mjs}

@@ -1,2 +1,2 @@
 function e(e){for(let t=e.length-1;t>=0;--t){if(e[t]<255)return e[t]+=1,!0;e[t]=0}return!1}function t(e,t,n){e[t]=n/1099511627776&255,e[t+1]=n/4294967296&255,e[t+2]=n/16777216&255,e[t+3]=n/65536&255,e[t+4]=n/256&255,e[t+5]=n&255}function n(e,t,n){e[t]=n>>>24&255,e[t+1]=n>>>16&255,e[t+2]=n>>>8&255,e[t+3]=n&255}export{n,t as r,e as t};
-//# sourceMappingURL=bytes-BBjKLOBR.mjs.map
+//# sourceMappingURL=bytes-NRtBOHK5.mjs.map

package/build/{bytes-BBjKLOBR.mjs.map → bytes-NRtBOHK5.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"bytes-BBjKLOBR.mjs","names":[],"sources":["../src/common/bytes.ts"],"sourcesContent":["/**\n * Common byte manipulation utilities shared across ID generators.\n */\n\n/**\n * Increment a byte array by 1 in-place, propagating carry from LSB to MSB.\n * Mutates the input array directly - no allocation.\n *\n * Used by ULID and KSUID for monotonic ordering within the same time unit.\n *\n * @returns true if increment succeeded, false if all bytes overflowed to 0\n */\nexport function incrementBytesInPlace(bytes: Uint8Array): boolean {\n  for (let i = bytes.length - 1; i >= 0; i -= 1) {\n    if (bytes[i] < 255) {\n      bytes[i] += 1\n      return true\n    }\n    bytes[i] = 0\n  }\n\n  // All bytes overflowed to 0 - astronomically unlikely (1 in 2^80 for ULID, 1 in 2^128 for KSUID)\n  return false\n}\n\n/**\n * Write a 48-bit timestamp as big-endian bytes.\n * Used by UUID v7 and ULID for millisecond-precision timestamps.\n *\n * @param buf - Target buffer\n * @param offset - Starting byte offset\n * @param msecs - Milliseconds since Unix epoch (must fit in 48 bits)\n */\nexport function writeTimestamp48(buf: Uint8Array, offset: number, msecs: number): void {\n  buf[offset] = (msecs / 0x10000000000) & 0xff\n  buf[offset + 1] = (msecs / 0x100000000) & 0xff\n  buf[offset + 2] = (msecs / 0x1000000) & 0xff\n  buf[offset + 3] = (msecs / 0x10000) & 0xff\n  buf[offset + 4] = (msecs / 0x100) & 0xff\n  buf[offset + 5] = msecs & 0xff\n}\n\n/**\n * Write a 32-bit timestamp as big-endian bytes.\n * Used by KSUID for second-precision timestamps.\n *\n * `writeTimestamp32(buf, offset, timestamp)` is equivalent to `new DataView(buf.buffer, offset, 4).setUint32(offset, timestamp, false)`,\n * but it's faster because it doesn't require creating a DataView object.\n *\n * @param buf - Target buffer\n * @param offset - Starting byte offset\n * @param secs - Seconds (must fit in 32 bits)\n */\nexport function writeTimestamp32(buf: Uint8Array, offset: number, secs: number): void {\n  buf[offset] = (secs >>> 24) & 0xff\n  buf[offset + 1] = (secs >>> 16) & 0xff\n  buf[offset + 2] = (secs >>> 8) & 0xff\n  buf[offset + 3] = secs & 0xff\n}\n"],"mappings":"AAYA,SAAgB,EAAsB,EAA4B,CAChE,IAAK,IAAI,EAAI,EAAM,OAAS,EAAG,GAAK,EAAG,IAAQ,CAC7C,GAAI,EAAM,GAAK,IAEb,MADA,GAAM,IAAM,EACL,GAET,EAAM,GAAK,EAIb,MAAO,GAWT,SAAgB,EAAiB,EAAiB,EAAgB,EAAqB,CACrF,EAAI,GAAW,EAAQ,cAAiB,IACxC,EAAI,EAAS,GAAM,EAAQ,WAAe,IAC1C,EAAI,EAAS,GAAM,EAAQ,SAAa,IACxC,EAAI,EAAS,GAAM,EAAQ,MAAW,IACtC,EAAI,EAAS,GAAM,EAAQ,IAAS,IACpC,EAAI,EAAS,GAAK,EAAQ,IAc5B,SAAgB,EAAiB,EAAiB,EAAgB,EAAoB,CACpF,EAAI,GAAW,IAAS,GAAM,IAC9B,EAAI,EAAS,GAAM,IAAS,GAAM,IAClC,EAAI,EAAS,GAAM,IAAS,EAAK,IACjC,EAAI,EAAS,GAAK,EAAO"}
+{"version":3,"file":"bytes-NRtBOHK5.mjs","names":[],"sources":["../src/common/bytes.ts"],"sourcesContent":["/**\n * Common byte manipulation utilities shared across ID generators.\n */\n\n/**\n * Increment a byte array by 1 in-place, propagating carry from LSB to MSB.\n * Mutates the input array directly - no allocation.\n *\n * Used by ULID and KSUID for monotonic ordering within the same time unit.\n *\n * @returns true if increment succeeded, false if all bytes overflowed to 0\n */\nexport function incrementBytesInPlace(bytes: Uint8Array): boolean {\n  for (let i = bytes.length - 1; i >= 0; i -= 1) {\n    if (bytes[i] < 255) {\n      bytes[i] += 1\n      return true\n    }\n    bytes[i] = 0\n  }\n\n  // All bytes overflowed to 0 - astronomically unlikely (1 in 2^80 for ULID, 1 in 2^128 for KSUID)\n  return false\n}\n\n/**\n * Write a 48-bit timestamp as big-endian bytes.\n * Used by UUID v7 and ULID for millisecond-precision timestamps.\n *\n * @param buf - Target buffer\n * @param offset - Starting byte offset\n * @param msecs - Milliseconds since Unix epoch (must fit in 48 bits)\n */\nexport function writeTimestamp48(buf: Uint8Array, offset: number, msecs: number): void {\n  buf[offset] = (msecs / 0x10000000000) & 0xff\n  buf[offset + 1] = (msecs / 0x100000000) & 0xff\n  buf[offset + 2] = (msecs / 0x1000000) & 0xff\n  buf[offset + 3] = (msecs / 0x10000) & 0xff\n  buf[offset + 4] = (msecs / 0x100) & 0xff\n  buf[offset + 5] = msecs & 0xff\n}\n\n/**\n * Write a 32-bit timestamp as big-endian bytes.\n * Used by KSUID for second-precision timestamps.\n *\n * `writeTimestamp32(buf, offset, timestamp)` is equivalent to `new DataView(buf.buffer, offset, 4).setUint32(offset, timestamp, false)`,\n * but it's faster because it doesn't require creating a DataView object.\n *\n * @param buf - Target buffer\n * @param offset - Starting byte offset\n * @param secs - Seconds (must fit in 32 bits)\n */\nexport function writeTimestamp32(buf: Uint8Array, offset: number, secs: number): void {\n  buf[offset] = (secs >>> 24) & 0xff\n  buf[offset + 1] = (secs >>> 16) & 0xff\n  buf[offset + 2] = (secs >>> 8) & 0xff\n  buf[offset + 3] = secs & 0xff\n}\n"],"mappings":"AAYA,SAAgB,EAAsB,EAA4B,CAChE,IAAK,IAAI,EAAI,EAAM,OAAS,EAAG,GAAK,EAAG,IAAQ,CAC7C,GAAI,EAAM,GAAK,IAEb,MADA,GAAM,IAAM,EACL,GAET,EAAM,GAAK,EAIb,MAAO,GAWT,SAAgB,EAAiB,EAAiB,EAAgB,EAAqB,CACrF,EAAI,GAAW,EAAQ,cAAiB,IACxC,EAAI,EAAS,GAAM,EAAQ,WAAe,IAC1C,EAAI,EAAS,GAAM,EAAQ,SAAa,IACxC,EAAI,EAAS,GAAM,EAAQ,MAAW,IACtC,EAAI,EAAS,GAAM,EAAQ,IAAS,IACpC,EAAI,EAAS,GAAK,EAAQ,IAc5B,SAAgB,EAAiB,EAAiB,EAAgB,EAAoB,CACpF,EAAI,GAAW,IAAS,GAAM,IAC9B,EAAI,EAAS,GAAM,IAAS,GAAM,IAClC,EAAI,EAAS,GAAM,IAAS,EAAK,IACjC,EAAI,EAAS,GAAK,EAAO"}

package/build/cuid2/cuid2.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"cuid2.d.mts","names":["cuid2: Cuid2"],"sources":["../../src/cuid2/cuid2.ts"],"sourcesContent":[],"mappings":";;;KAIY,YAAA;;;AAAZ;AAeA;EA4MA,MAAaA,CAAAA,EAAAA,MAAO;;;;;;;WA/MT;;KAGC,KAAA;aACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2MAA,OAAO"}
+{"version":3,"file":"cuid2.d.mts","names":["cuid2: Cuid2"],"sources":["../../src/cuid2/cuid2.ts"],"sourcesContent":[],"mappings":";;;KAIY,YAAA;;;AAAZ;AAeA;EA2LA,MAAaA,CAAAA,EAAAA,MAAO;;;;;;;WA9LT;;KAGC,KAAA;aACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0LAA,OAAO"}

package/build/cuid2/cuid2.mjs

@@ -1,2 +1,2 @@
-import{InvalidInputError as e,UniqueIdError as t}from"../errors.mjs";import{sha3_512 as n}from"@noble/hashes/sha3.js";function r(e){let t=4+e*128,n,r=!1;if(typeof SharedArrayBuffer<`u`)try{n=new SharedArrayBuffer(t),r=!0}catch{n=new ArrayBuffer(t)}else n=new ArrayBuffer(t);let i=new Int32Array(n,0,1),a=new Uint8Array(n,4);return crypto.getRandomValues(a),{buffer:n,bytes:a,offset:i,useAtomics:r}}function i(e,t){if(e.useAtomics){let n=Atomics.add(e.offset,0,t);return n+t<=e.bytes.length?n:Atomics.compareExchange(e.offset,0,n+t,t)===n+t?(crypto.getRandomValues(e.bytes),0):i(e,t)}else{let n=e.offset[0];return n+t>e.bytes.length&&(crypto.getRandomValues(e.bytes),n=0),e.offset[0]=n+t,n}}function a(e,t){let n=i(e,t);return e.bytes.subarray(n,n+t)}const o=/^[a-z][0-9a-z]+$/,s=`0123456789abcdefghijklmnopqrstuvwxyz`,c=new TextEncoder;let l;function u(){return l||=r(4),l}const d={counter:void 0,fingerprint:void 0};function f(){let e=a(u(),4);return((e[0]<<24|e[1]<<16|e[2]<<8|e[3])>>>0)%476782368}function p(e){let t=0n;for(let n of e)t=t*256n+BigInt(n);return t}function m(e){if(e===0n)return`0`;let t=[];for(;e>0n;)t.push(s[Number(e%36n)]),e/=36n;return t.reverse().join(``)}function h(e){return`abcdefghijklmnopqrstuvwxyz`[Math.floor(e()*26)]}function g(e,t){let n=Array(e);for(let r=0;r<e;r++)n[r]=s[Math.floor(t()*36)];return n.join(``)}function _(e){return n(c.encode(e))}function v(){let e=y;return m(p(_(Object.keys(globalThis).toString()+g(32,e)))).slice(1,33)}function y(){let e=u(),t=i(e,4),n=e.bytes;return(n[t]*16777216+n[t+1]*65536+n[t+2]*256+n[t+3])/4294967296}function b(t){if(t){if(t.length===0)throw new e(`CUID2_RANDOM_BYTES_EMPTY`,`Random byte array cannot be empty`);let n=0;return()=>{let e=t[n%t.length]/256;return n+=1,e}}return y}function x(t){let n=t?.length??24;if(n<2||n>32)throw new e(`CUID2_LENGTH_OUT_OF_RANGE`,`CUID2 length must be between 2 and 32. Received: ${n}`);let r=b(t?.random);d.counter===void 0&&(d.counter=f()),d.fingerprint===void 0&&(d.fingerprint=v());let i=h(r),a=Date.now().toString(36);d.counter+=1;let o=d.counter.toString(36);return i+m(p(_(a+g(n,r)+o+d.fingerprint))).slice(1,n)}function S(e){return typeof e==`string`&&e.length>=2&&e.length<=32&&o.test(e)}const C=Object.assign(x,{isValid:S});export{e as InvalidInputError,t as UniqueIdError,C as cuid2};
+import{t as e}from"../random-CWCVvNLb.mjs";import{InvalidInputError as t,UniqueIdError as n}from"../errors.mjs";import{sha3_512 as r}from"@noble/hashes/sha3.js";const i=/^[a-z][0-9a-z]+$/,a=`0123456789abcdefghijklmnopqrstuvwxyz`,o=new TextEncoder,s={counter:void 0,fingerprint:void 0};function c(){return e()%476782368}function l(e){let t=0n;for(let n of e)t=t*256n+BigInt(n);return t}function u(e){if(e===0n)return`0`;let t=[];for(;e>0n;)t.push(a[Number(e%36n)]),e/=36n;return t.reverse().join(``)}function d(e){return`abcdefghijklmnopqrstuvwxyz`[Math.floor(e()*26)]}function f(e,t){let n=Array(e);for(let r=0;r<e;r++)n[r]=a[Math.floor(t()*36)];return n.join(``)}function p(e){return r(o.encode(e))}function m(){let e=h;return u(l(p(Object.keys(globalThis).toString()+f(32,e)))).slice(1,33)}function h(){return e()/4294967296}function g(e){if(e){if(e.length===0)throw new t(`CUID2_RANDOM_BYTES_EMPTY`,`Random byte array cannot be empty`);let n=0;return()=>{let t=e[n%e.length]/256;return n+=1,t}}return h}function _(e){let n=e?.length??24;if(n<2||n>32)throw new t(`CUID2_LENGTH_OUT_OF_RANGE`,`CUID2 length must be between 2 and 32. Received: ${n}`);let r=g(e?.random);s.counter===void 0&&(s.counter=c()),s.fingerprint===void 0&&(s.fingerprint=m());let i=d(r),a=Date.now().toString(36);s.counter+=1;let o=s.counter.toString(36);return i+u(l(p(a+f(n,r)+o+s.fingerprint))).slice(1,n)}function v(e){return typeof e==`string`&&e.length>=2&&e.length<=32&&i.test(e)}const y=Object.assign(_,{isValid:v});export{t as InvalidInputError,n as UniqueIdError,y as cuid2};
 //# sourceMappingURL=cuid2.mjs.map

package/build/cuid2/cuid2.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"cuid2.mjs","names":["buffer: SharedArrayBuffer | ArrayBuffer","pool","pool: RandomPool | undefined","state: { counter: number | undefined; fingerprint: string | undefined }","chars: string[]","cuid2: Cuid2"],"sources":["../../src/common/random-pool.ts","../../src/cuid2/cuid2.ts"],"sourcesContent":["/**\n * Thread-safe random byte pool utilities using Atomics (when SharedArrayBuffer is available).\n * Falls back to regular pooling in environments without SharedArrayBuffer.\n *\n * This module provides STATELESS utilities - each consumer creates and manages its own pool.\n * Pass the pool state to each function (C-style) for explicit, predictable behavior.\n *\n * @example\n * ```ts\n * // Each module creates its own pool\n * let pool: RandomPool | undefined\n *\n * function getBytes(count: number): number {\n *   if (!pool) pool = createPool(count)\n *   return getPooledBytes(pool, count)\n * }\n * ```\n */\n\nconst POOL_SIZE_MULTIPLIER = 128\nconst POOL_HEADER_SIZE = 4 // 4 bytes for Int32 offset counter\n\n/**\n * Pool state - passed to all pool functions.\n * Each module creates and owns its own pool instance.\n */\nexport type RandomPool = {\n  buffer: SharedArrayBuffer | ArrayBuffer\n  bytes: Uint8Array\n  offset: Int32Array\n  useAtomics: boolean\n}\n\n/**\n * Create a new random pool. Uses SharedArrayBuffer + Atomics when available\n * for thread-safety in Web Worker scenarios.\n *\n * @param minSize - Minimum bytes needed per request (pool = minSize * 128)\n */\nexport function createPool(minSize: number): RandomPool {\n  const poolSize = minSize * POOL_SIZE_MULTIPLIER\n  const totalSize = POOL_HEADER_SIZE + poolSize\n\n  let buffer: SharedArrayBuffer | ArrayBuffer\n  let useAtomics = false\n\n  // Try SharedArrayBuffer first (thread-safe with Atomics)\n  if (typeof SharedArrayBuffer !== 'undefined') {\n    try {\n      buffer = new SharedArrayBuffer(totalSize)\n      useAtomics = true\n    } catch {\n      // SharedArrayBuffer may be disabled (security restrictions)\n      buffer = new ArrayBuffer(totalSize)\n    }\n  } else {\n    buffer = new ArrayBuffer(totalSize)\n  }\n\n  // First 4 bytes = atomic offset counter, rest = random bytes\n  const offset = new Int32Array(buffer, 0, 1)\n  const bytes = new Uint8Array(buffer, POOL_HEADER_SIZE)\n  crypto.getRandomValues(bytes)\n\n  return { buffer, bytes, offset, useAtomics }\n}\n\n/**\n * Get pooled random bytes. Thread-safe when SharedArrayBuffer is available.\n * Returns the starting index in the pool for the requested bytes.\n *\n * @param pool - The pool state (from createPool)\n * @param count - Number of bytes needed\n * @returns Starting offset in pool.bytes\n *\n * @example\n * ```ts\n * const offset = getPooledBytes(pool, 21)\n * for (let i = offset; i < offset + 21; i++) {\n *   // Use pool.bytes[i]\n * }\n * ```\n */\nexport function getPooledBytes(pool: RandomPool, count: number): number {\n  if (pool.useAtomics) {\n    // Thread-safe path using Atomics\n    const startOffset = Atomics.add(pool.offset, 0, count)\n\n    if (startOffset + count <= pool.bytes.length) {\n      return startOffset\n    }\n\n    // Pool exhausted - need to refill\n    // Use compareExchange to ensure only one thread refills\n    const resetResult = Atomics.compareExchange(pool.offset, 0, startOffset + count, count)\n    if (resetResult === startOffset + count) {\n      // We won the race - refill the pool\n      crypto.getRandomValues(pool.bytes)\n      return 0\n    }\n\n    // Another thread is refilling or already refilled - retry\n    return getPooledBytes(pool, count)\n  } else {\n    // Single-threaded path\n    let currentOffset = pool.offset[0]\n\n    if (currentOffset + count > pool.bytes.length) {\n      crypto.getRandomValues(pool.bytes)\n      currentOffset = 0\n    }\n\n    pool.offset[0] = currentOffset + count\n    return currentOffset\n  }\n}\n\n/**\n * Get a Uint8Array slice of random bytes from the pool.\n *\n * Note: Returns a subarray VIEW into the pool. If you need the bytes to persist\n * beyond the current synchronous operation, use getRandomBytesCopy() instead.\n *\n * @param pool - The pool state\n * @param count - Number of bytes needed\n */\nexport function getRandomBytes(pool: RandomPool, count: number): Uint8Array {\n  const offset = getPooledBytes(pool, count)\n  return pool.bytes.subarray(offset, offset + count)\n}\n\n/**\n * Get a COPY of random bytes from the pool.\n * Use this when bytes need to persist (e.g., returned to caller who may use them later).\n *\n * @param pool - The pool state\n * @param count - Number of bytes needed\n */\nexport function getRandomBytesCopy(pool: RandomPool, count: number): Uint8Array {\n  const offset = getPooledBytes(pool, count)\n  return pool.bytes.slice(offset, offset + count)\n}\n\n/**\n * Fill the provided buffer with random bytes from the pool.\n *\n * @param pool - The pool state\n * @param out - Buffer to fill\n */\nexport function fillRandomBytes(pool: RandomPool, out: Uint8Array): void {\n  const offset = getPooledBytes(pool, out.length)\n  out.set(pool.bytes.subarray(offset, offset + out.length))\n}\n","import { sha3_512 } from '@noble/hashes/sha3.js'\nimport { createPool, getPooledBytes, getRandomBytes, type RandomPool } from '../common/random-pool'\nimport { InvalidInputError } from '../errors'\n\nexport type Cuid2Options = {\n  /**\n   * Length of the generated ID (2-32 characters).\n   * Default: 24\n   */\n  length?: number\n  /**\n   * Custom random bytes for deterministic testing.\n   * Must be at least 1 byte. For adequate entropy, use at least 16 bytes.\n   * Note: The fingerprint always uses cryptographically secure random bytes,\n   * regardless of this option.\n   */\n  random?: Uint8Array\n}\n\nexport type Cuid2 = {\n  (options?: Cuid2Options): string\n  isValid(id: unknown): id is string\n}\n\nconst DEFAULT_LENGTH = 24\nconst MAX_LENGTH = 32\nconst MIN_LENGTH = 2\n\n// Maximum initial counter value from cuid2 spec - provides ~29 bits of\n// initial entropy to prevent cross-process collisions at startup\nconst INITIAL_COUNT_MAX = 476782367\n\n// Validation regex: first char must be a-z, rest can be a-z or 0-9\nconst CUID2_REGEX = /^[a-z][0-9a-z]+$/\n\n// Base36 alphabet\nconst ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'\nconst LETTER_ALPHABET = 'abcdefghijklmnopqrstuvwxyz'\n\n// Reusable TextEncoder instance (stateless, safe to share)\nconst textEncoder = new TextEncoder()\n\n// CUID2's own pool - lazily initialized on first use\n// Uses 4 bytes per random() call\nlet pool: RandomPool | undefined\n\nfunction ensurePool(): RandomPool {\n  if (!pool) pool = createPool(4)\n  return pool\n}\n\n/**\n * Module-level state for counter and fingerprint.\n * Counter is initialized lazily on first call to prevent unnecessary crypto operations.\n * Fingerprint is also generated lazily on first call.\n */\nconst state: { counter: number | undefined; fingerprint: string | undefined } = {\n  counter: undefined,\n  fingerprint: undefined,\n}\n\n/**\n * Initialize counter using crypto for consistency with other entropy sources.\n */\nfunction initializeCounter(): number {\n  const buffer = getRandomBytes(ensurePool(), 4)\n  return (((buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]) >>> 0) % (INITIAL_COUNT_MAX + 1)\n}\n\n// --- Base36 utilities ---\n\nfunction bufToBigInt(buf: Uint8Array): bigint {\n  let value = 0n\n  for (const byte of buf) {\n    value = value * 256n + BigInt(byte)\n  }\n  return value\n}\n\nfunction bigIntToBase36(value: bigint): string {\n  if (value === 0n) return '0'\n  const chars: string[] = []\n  while (value > 0n) {\n    chars.push(ALPHABET[Number(value % 36n)])\n    value = value / 36n\n  }\n  return chars.reverse().join('')\n}\n\nfunction randomLetter(random: () => number): string {\n  return LETTER_ALPHABET[Math.floor(random() * 26)]\n}\n\nfunction createEntropy(length: number, random: () => number): string {\n  const chars = new Array<string>(length)\n  for (let i = 0; i < length; i++) {\n    chars[i] = ALPHABET[Math.floor(random() * 36)]\n  }\n  return chars.join('')\n}\n\n// --- SHA3 hash wrapper ---\n\nfunction hash(input: string): Uint8Array {\n  return sha3_512(textEncoder.encode(input))\n}\n\n// --- Fingerprint generation ---\n\nconst BIG_LENGTH = 32\n\nfunction createFingerprint(): string {\n  // Always use CSPRNG for fingerprint to ensure security regardless of custom random option\n  const random = getCryptoRandom\n  const globals = Object.keys(globalThis).toString()\n  const sourceString = globals + createEntropy(BIG_LENGTH, random)\n  const hashed = hash(sourceString)\n  return bigIntToBase36(bufToBigInt(hashed)).slice(1, BIG_LENGTH + 1)\n}\n\n// --- Random function factory ---\n\n/**\n * Get a random number in [0, 1) using CUID2's own random pool.\n * Thread-safe when SharedArrayBuffer is available.\n */\nfunction getCryptoRandom(): number {\n  const p = ensurePool()\n  const offset = getPooledBytes(p, 4)\n  const bytes = p.bytes\n  const value =\n    (bytes[offset] * 0x1000000 + bytes[offset + 1] * 0x10000 + bytes[offset + 2] * 0x100 + bytes[offset + 3]) /\n    0x100000000\n  return value\n}\n\nfunction getRandomFn(random?: Uint8Array): () => number {\n  if (random) {\n    if (random.length === 0) {\n      throw new InvalidInputError('CUID2_RANDOM_BYTES_EMPTY', 'Random byte array cannot be empty')\n    }\n    let index = 0\n    return () => {\n      const value = random[index % random.length] / 256\n      index += 1\n      return value\n    }\n  }\n  return getCryptoRandom\n}\n\n// --- Main generator ---\n\nfunction cuid2Fn(options?: Cuid2Options): string {\n  const length = options?.length ?? DEFAULT_LENGTH\n\n  if (length < MIN_LENGTH || length > MAX_LENGTH) {\n    throw new InvalidInputError(\n      'CUID2_LENGTH_OUT_OF_RANGE',\n      `CUID2 length must be between ${MIN_LENGTH} and ${MAX_LENGTH}. Received: ${length}`,\n    )\n  }\n\n  const random = getRandomFn(options?.random)\n\n  // Initialize counter lazily on first call\n  if (state.counter === undefined) {\n    state.counter = initializeCounter()\n  }\n\n  // Initialize fingerprint lazily on first call (always uses CSPRNG)\n  if (state.fingerprint === undefined) {\n    state.fingerprint = createFingerprint()\n  }\n\n  const firstLetter = randomLetter(random)\n  const time = Date.now().toString(36)\n  state.counter += 1\n  const count = state.counter.toString(36)\n  const salt = createEntropy(length, random)\n\n  const hashInput = time + salt + count + state.fingerprint\n  const hashed = hash(hashInput)\n  const base36Hash = bigIntToBase36(bufToBigInt(hashed))\n\n  // Drop first char of hash to avoid histogram bias, prepend random letter\n  return firstLetter + base36Hash.slice(1, length)\n}\n\n// --- Validation (type guard) ---\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length >= MIN_LENGTH && id.length <= MAX_LENGTH && CUID2_REGEX.test(id)\n}\n\n/**\n * Generate a CUID2 string.\n *\n * CUID2 is a secure, collision-resistant identifier that hashes multiple\n * entropy sources using SHA3-512. Unlike time-ordered IDs (ULID, UUID v7),\n * CUID2 prevents enumeration attacks by making IDs non-predictable.\n *\n * Note: CUID2 does not provide toBytes/fromBytes because it is a string-native\n * format with no canonical binary representation (unlike UUID's 16-byte format).\n *\n * @example\n * ```ts\n * import { cuid2 } from 'uniku/cuid2'\n *\n * const id = cuid2()\n * // => \"pfh0haxfpzowht3oi213cqos\"\n *\n * // Custom length\n * const shortId = cuid2({ length: 10 })\n * // => \"tz4a98xxat\"\n *\n * // Validation (type guard)\n * const maybeId: unknown = getUserInput()\n * if (cuid2.isValid(maybeId)) {\n *   console.log(maybeId.length) // TypeScript knows maybeId is string\n * }\n * ```\n */\nexport const cuid2: Cuid2 = Object.assign(cuid2Fn, {\n  isValid,\n})\n\nexport { InvalidInputError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"cuid2.mjs","names":["state: { counter: number | undefined; fingerprint: string | undefined }","chars: string[]","cuid2: Cuid2"],"sources":["../../src/cuid2/cuid2.ts"],"sourcesContent":["import { sha3_512 } from '@noble/hashes/sha3.js'\nimport { randomUint32 } from '../common/random'\nimport { InvalidInputError } from '../errors'\n\nexport type Cuid2Options = {\n  /**\n   * Length of the generated ID (2-32 characters).\n   * Default: 24\n   */\n  length?: number\n  /**\n   * Custom random bytes for deterministic testing.\n   * Must be at least 1 byte. For adequate entropy, use at least 16 bytes.\n   * Note: The fingerprint always uses cryptographically secure random bytes,\n   * regardless of this option.\n   */\n  random?: Uint8Array\n}\n\nexport type Cuid2 = {\n  (options?: Cuid2Options): string\n  isValid(id: unknown): id is string\n}\n\nconst DEFAULT_LENGTH = 24\nconst MAX_LENGTH = 32\nconst MIN_LENGTH = 2\n\n// Maximum initial counter value from cuid2 spec - provides ~29 bits of\n// initial entropy to prevent cross-process collisions at startup\nconst INITIAL_COUNT_MAX = 476782367\n\n// Validation regex: first char must be a-z, rest can be a-z or 0-9\nconst CUID2_REGEX = /^[a-z][0-9a-z]+$/\n\n// Base36 alphabet\nconst ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'\nconst LETTER_ALPHABET = 'abcdefghijklmnopqrstuvwxyz'\n\n// Reusable TextEncoder instance (stateless, safe to share)\nconst textEncoder = new TextEncoder()\n\n/**\n * Module-level state for counter and fingerprint.\n * Counter is initialized lazily on first call to prevent unnecessary crypto operations.\n * Fingerprint is also generated lazily on first call.\n */\nconst state: { counter: number | undefined; fingerprint: string | undefined } = {\n  counter: undefined,\n  fingerprint: undefined,\n}\n\n/**\n * Initialize counter using crypto for consistency with other entropy sources.\n */\nfunction initializeCounter(): number {\n  return randomUint32() % (INITIAL_COUNT_MAX + 1)\n}\n\n// --- Base36 utilities ---\n\nfunction bufToBigInt(buf: Uint8Array): bigint {\n  let value = 0n\n  for (const byte of buf) {\n    value = value * 256n + BigInt(byte)\n  }\n  return value\n}\n\nfunction bigIntToBase36(value: bigint): string {\n  if (value === 0n) return '0'\n  const chars: string[] = []\n  while (value > 0n) {\n    chars.push(ALPHABET[Number(value % 36n)])\n    value = value / 36n\n  }\n  return chars.reverse().join('')\n}\n\nfunction randomLetter(random: () => number): string {\n  return LETTER_ALPHABET[Math.floor(random() * 26)]\n}\n\nfunction createEntropy(length: number, random: () => number): string {\n  const chars = new Array<string>(length)\n  for (let i = 0; i < length; i++) {\n    chars[i] = ALPHABET[Math.floor(random() * 36)]\n  }\n  return chars.join('')\n}\n\n// --- SHA3 hash wrapper ---\n\nfunction hash(input: string): Uint8Array {\n  return sha3_512(textEncoder.encode(input))\n}\n\n// --- Fingerprint generation ---\n\nconst BIG_LENGTH = 32\n\nfunction createFingerprint(): string {\n  // Always use CSPRNG for fingerprint to ensure security regardless of custom random option\n  const random = getCryptoRandom\n  const globals = Object.keys(globalThis).toString()\n  const sourceString = globals + createEntropy(BIG_LENGTH, random)\n  const hashed = hash(sourceString)\n  return bigIntToBase36(bufToBigInt(hashed)).slice(1, BIG_LENGTH + 1)\n}\n\n// --- Random function factory ---\n\n/**\n * Get a random number in [0, 1) using CUID2's own random pool.\n */\nfunction getCryptoRandom(): number {\n  return randomUint32() / 0x100000000\n}\n\nfunction getRandomFn(random?: Uint8Array): () => number {\n  if (random) {\n    if (random.length === 0) {\n      throw new InvalidInputError('CUID2_RANDOM_BYTES_EMPTY', 'Random byte array cannot be empty')\n    }\n    let index = 0\n    return () => {\n      const value = random[index % random.length] / 256\n      index += 1\n      return value\n    }\n  }\n  return getCryptoRandom\n}\n\n// --- Main generator ---\n\nfunction cuid2Fn(options?: Cuid2Options): string {\n  const length = options?.length ?? DEFAULT_LENGTH\n\n  if (length < MIN_LENGTH || length > MAX_LENGTH) {\n    throw new InvalidInputError(\n      'CUID2_LENGTH_OUT_OF_RANGE',\n      `CUID2 length must be between ${MIN_LENGTH} and ${MAX_LENGTH}. Received: ${length}`,\n    )\n  }\n\n  const random = getRandomFn(options?.random)\n\n  // Initialize counter lazily on first call\n  if (state.counter === undefined) {\n    state.counter = initializeCounter()\n  }\n\n  // Initialize fingerprint lazily on first call (always uses CSPRNG)\n  if (state.fingerprint === undefined) {\n    state.fingerprint = createFingerprint()\n  }\n\n  const firstLetter = randomLetter(random)\n  const time = Date.now().toString(36)\n  state.counter += 1\n  const count = state.counter.toString(36)\n  const salt = createEntropy(length, random)\n\n  const hashInput = time + salt + count + state.fingerprint\n  const hashed = hash(hashInput)\n  const base36Hash = bigIntToBase36(bufToBigInt(hashed))\n\n  // Drop first char of hash to avoid histogram bias, prepend random letter\n  return firstLetter + base36Hash.slice(1, length)\n}\n\n// --- Validation (type guard) ---\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length >= MIN_LENGTH && id.length <= MAX_LENGTH && CUID2_REGEX.test(id)\n}\n\n/**\n * Generate a CUID2 string.\n *\n * CUID2 is a secure, collision-resistant identifier that hashes multiple\n * entropy sources using SHA3-512. Unlike time-ordered IDs (ULID, UUID v7),\n * CUID2 prevents enumeration attacks by making IDs non-predictable.\n *\n * Note: CUID2 does not provide toBytes/fromBytes because it is a string-native\n * format with no canonical binary representation (unlike UUID's 16-byte format).\n *\n * @example\n * ```ts\n * import { cuid2 } from 'uniku/cuid2'\n *\n * const id = cuid2()\n * // => \"pfh0haxfpzowht3oi213cqos\"\n *\n * // Custom length\n * const shortId = cuid2({ length: 10 })\n * // => \"tz4a98xxat\"\n *\n * // Validation (type guard)\n * const maybeId: unknown = getUserInput()\n * if (cuid2.isValid(maybeId)) {\n *   console.log(maybeId.length) // TypeScript knows maybeId is string\n * }\n * ```\n */\nexport const cuid2: Cuid2 = Object.assign(cuid2Fn, {\n  isValid,\n})\n\nexport { InvalidInputError, UniqueIdError } from '../errors'\n"],"mappings":"iKAwBA,MASM,EAAc,mBAGd,EAAW,uCAIX,EAAc,IAAI,YAOlBA,EAA0E,CAC9E,QAAS,IAAA,GACT,YAAa,IAAA,GACd,CAKD,SAAS,GAA4B,CACnC,OAAO,GAAc,CAAI,UAK3B,SAAS,EAAY,EAAyB,CAC5C,IAAI,EAAQ,GACZ,IAAK,IAAM,KAAQ,EACjB,EAAQ,EAAQ,KAAO,OAAO,EAAK,CAErC,OAAO,EAGT,SAAS,EAAe,EAAuB,CAC7C,GAAI,IAAU,GAAI,MAAO,IACzB,IAAMC,EAAkB,EAAE,CAC1B,KAAO,EAAQ,IACb,EAAM,KAAK,EAAS,OAAO,EAAQ,IAAI,EAAE,CACzC,GAAgB,IAElB,OAAO,EAAM,SAAS,CAAC,KAAK,GAAG,CAGjC,SAAS,EAAa,EAA8B,CAClD,MAAO,6BAAgB,KAAK,MAAM,GAAQ,CAAG,GAAG,EAGlD,SAAS,EAAc,EAAgB,EAA8B,CACnE,IAAM,EAAY,MAAc,EAAO,CACvC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,IAC1B,EAAM,GAAK,EAAS,KAAK,MAAM,GAAQ,CAAG,GAAG,EAE/C,OAAO,EAAM,KAAK,GAAG,CAKvB,SAAS,EAAK,EAA2B,CACvC,OAAO,EAAS,EAAY,OAAO,EAAM,CAAC,CAO5C,SAAS,GAA4B,CAEnC,IAAM,EAAS,EAIf,OAAO,EAAe,EADP,EAFC,OAAO,KAAK,WAAW,CAAC,UAAU,CACnB,EAAc,GAAY,EAAO,CAC/B,CACQ,CAAC,CAAC,MAAM,EAAG,GAAe,CAQrE,SAAS,GAA0B,CACjC,OAAO,GAAc,CAAG,WAG1B,SAAS,EAAY,EAAmC,CACtD,GAAI,EAAQ,CACV,GAAI,EAAO,SAAW,EACpB,MAAM,IAAI,EAAkB,2BAA4B,oCAAoC,CAE9F,IAAI,EAAQ,EACZ,UAAa,CACX,IAAM,EAAQ,EAAO,EAAQ,EAAO,QAAU,IAE9C,MADA,IAAS,EACF,GAGX,OAAO,EAKT,SAAS,EAAQ,EAAgC,CAC/C,IAAM,EAAS,GAAS,QAAU,GAElC,GAAI,EAAS,GAAc,EAAS,GAClC,MAAM,IAAI,EACR,4BACA,oDAA2E,IAC5E,CAGH,IAAM,EAAS,EAAY,GAAS,OAAO,CAGvC,EAAM,UAAY,IAAA,KACpB,EAAM,QAAU,GAAmB,EAIjC,EAAM,cAAgB,IAAA,KACxB,EAAM,YAAc,GAAmB,EAGzC,IAAM,EAAc,EAAa,EAAO,CAClC,EAAO,KAAK,KAAK,CAAC,SAAS,GAAG,CACpC,EAAM,SAAW,EACjB,IAAM,EAAQ,EAAM,QAAQ,SAAS,GAAG,CAQxC,OAAO,EAHY,EAAe,EADnB,EADG,EAFL,EAAc,EAAQ,EAAO,CAEV,EAAQ,EAAM,YAChB,CACuB,CAAC,CAGtB,MAAM,EAAG,EAAO,CAKlD,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAG,QAAU,GAAc,EAAG,QAAU,IAAc,EAAY,KAAK,EAAG,CA+B7G,MAAaC,EAAe,OAAO,OAAO,EAAS,CACjD,UACD,CAAC"}

package/build/ksuid/ksuid.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ksuid.d.mts","names":["ksuid: Ksuid"],"sources":["../../src/ksuid/ksuid.ts"],"sourcesContent":[],"mappings":";;;KA4BY,YAAA;;;AAAZ;EAaA,MAAY,CAAA,EATD,UASC;EAEI;;;;;EACH,IAAA,CAAA,EAAA,MAAA;CACU;AACJ,KALP,KAAA,GAKO;EAAA,EAAA,EAAA,MAAA;EAgInB,CAAA,aAnIgB,UAmII,GAnIS,UAmIT,CAAA,CAAA,OAAA,EAnI8B,YAmI9B,GAAA,SAAA,EAAA,GAAA,EAnI6D,IAmI7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAnIqF,IAmIrF;aAlIP;uBACU;mBACJ;;;;;;;;;;;;cAgINA,OAAO"}
+{"version":3,"file":"ksuid.d.mts","names":["ksuid: Ksuid"],"sources":["../../src/ksuid/ksuid.ts"],"sourcesContent":[],"mappings":";;;KAgCY,YAAA;;;AAAZ;EAaA,MAAY,CAAA,EATD,UASC;EAEI;;;;;EACH,IAAA,CAAA,EAAA,MAAA;CACU;AACJ,KALP,KAAA,GAKO;EAAA,EAAA,EAAA,MAAA;EAuInB,CAAA,aA1IgB,UA0II,GA1IS,UA0IT,CAAA,CAAA,OAAA,EA1I8B,YA0I9B,GAAA,SAAA,EAAA,GAAA,EA1I6D,IA0I7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EA1IqF,IA0IrF;aAzIP;uBACU;mBACJ;;;;;;;;;;;;cAuINA,OAAO"}

package/build/ksuid/ksuid.mjs

@@ -1,2 +1,2 @@
-import{BufferError as e,InvalidInputError as t,ParseError as n,UniqueIdError as r}from"../errors.mjs";import{n as i}from"../bytes-BBjKLOBR.mjs";import{t as a}from"../random-DcKA4vF7.mjs";const o=`0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`,s=62n,c=new Uint8Array(128);c.fill(255);for(let e=0;e<62;e+=1)c[o.charCodeAt(e)]=e;function l(t){if(t.length<20)throw new e(`KSUID_BYTES_TOO_SHORT`,`KSUID bytes must be at least 20 bytes, got ${t.length}`);let n=0n;for(let e=0;e<20;e+=1)n=n<<8n|BigInt(t[e]);let r=``;for(;n>0n;){let e=n%s;n/=s,r=o[Number(e)]+r}return r.padStart(27,`0`)}function u(e){if(e.length!==27)throw new n(`KSUID_INVALID_LENGTH`,`KSUID string must be 27 characters, got ${e.length}`);let t=0n;for(let r=0;r<27;r+=1){let i=e.charCodeAt(r);if(i>=128)throw new n(`KSUID_INVALID_CHAR`,`Invalid KSUID character: ${e[r]}`);let a=c[i];if(a===255)throw new n(`KSUID_INVALID_CHAR`,`Invalid KSUID character: ${e[r]}`);t=t*s+BigInt(a)}let r=new Uint8Array(20);for(let e=19;e>=0;--e)r[e]=Number(t&255n),t>>=8n;return r}const d=14e8,f=/^[0-9A-Za-z]{27}$/;function p(t,n,r,a=0){if(!r)r=new Uint8Array(20),a=0;else if(a<0||a+20>r.length)throw new e(`KSUID_BUFFER_OUT_OF_BOUNDS`,`KSUID byte range ${a}:${a+20-1} is out of buffer bounds`);i(r,a,t),r.set(n.subarray(4,20),a+4);for(let e=0;e<16;e+=1)r[a+4+e]=n[e];return r}function m(e,n,r=0){if(e){if(e.random&&e.random.length<16)throw new t(`KSUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16 for KSUID`);if(e.secs&&e.secs<d)throw new t(`KSUID_TIMESTAMP_TOO_LOW`,`Timestamp must be >= KSUID epoch`);e.secs&&(e.secs-=d)}let i=e?.secs??Math.floor(Date.now()/1e3-d),o=e?.random??a();return n?(p(i,o,n,r),n):l(p(i,o))}function h(e){return u(e)}function g(e){return l(e)}function _(e){let t=u(e);return(((t[0]<<24|t[1]<<16|t[2]<<8|t[3])>>>0)+d)*1e3}function v(e){return typeof e==`string`&&e.length===27&&f.test(e)}const y=Object.assign(m,{toBytes:h,fromBytes:g,timestamp:_,isValid:v,NIL:`000000000000000000000000000`,MAX:`aWgEPTl1tmebfsQzFP4bxwgy80V`});export{e as BufferError,t as InvalidInputError,n as ParseError,r as UniqueIdError,y as ksuid};
+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}from"../bytes-NRtBOHK5.mjs";const o=`0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz`,s=62n,c=(1n<<160n)-1n,l=new Uint8Array(65536);l.fill(255);for(let e=0;e<62;e+=1)l[o.charCodeAt(e)]=e;function u(e){if(e.length<20)throw new t(`KSUID_BYTES_TOO_SHORT`,`KSUID bytes must be at least 20 bytes, got ${e.length}`);let n=0n;for(let t=0;t<20;t+=1)n=n<<8n|BigInt(e[t]);let r=``;for(;n>0n;){let e=n%s;n/=s,r=o[Number(e)]+r}return r.padStart(27,`0`)}function d(e){if(e.length!==27)throw new r(`KSUID_INVALID_LENGTH`,`KSUID string must be 27 characters, got ${e.length}`);let t=0n;for(let n=0;n<27;n+=1){let i=l[e.charCodeAt(n)];if(i===255)throw new r(`KSUID_INVALID_CHAR`,`Invalid KSUID character: ${e[n]}`);t=t*s+BigInt(i)}if(t>c)throw new r(`KSUID_OVERFLOW`,`KSUID string exceeds 160-bit range`);let n=new Uint8Array(20);for(let e=19;e>=0;--e)n[e]=Number(t&255n),t>>=8n;return n}const f=14e8;f+4294967295;const p=u(new Uint8Array(20).fill(255)),m=/^[0-9A-Za-z]{27}$/;function h(e,n,r,i=0){if(!r)r=new Uint8Array(20),i=0;else if(i<0||i+20>r.length)throw new t(`KSUID_BUFFER_OUT_OF_BOUNDS`,`KSUID byte range ${i}:${i+20-1} is out of buffer bounds`);a(r,i,e);for(let e=0;e<16;e+=1)r[i+4+e]=n[e];return r}function g(t,r,i=0){let a=t?.random;if(a&&a.length<16)throw new n(`KSUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16 for KSUID`);let o,s=t?.secs;if(s!==void 0){if(s<f)throw new n(`KSUID_TIMESTAMP_TOO_LOW`,`Timestamp must be >= KSUID epoch`);if(s>5694967295)throw new n(`KSUID_TIMESTAMP_TOO_HIGH`,`Timestamp must be <= maximum KSUID timestamp`);o=s-f}else o=Math.floor(Date.now()/1e3)-f;let c=a??e();return r?(h(o,c,r,i),r):u(h(o,c))}function _(e){return d(e)}function v(e){return u(e)}function y(e){let t=d(e);return(((t[0]<<24|t[1]<<16|t[2]<<8|t[3])>>>0)+f)*1e3}function b(e){return typeof e==`string`&&e.length===27&&m.test(e)&&e<=p}const x=Object.assign(g,{toBytes:_,fromBytes:v,timestamp:y,isValid:b,NIL:`000000000000000000000000000`,MAX:p});export{t as BufferError,n as InvalidInputError,r as ParseError,i as UniqueIdError,x as ksuid};
 //# sourceMappingURL=ksuid.mjs.map

package/build/ksuid/ksuid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ksuid.mjs","names":["KSUID_BYTES","KSUID_STRING_LEN","timestamp","ksuid: Ksuid"],"sources":["../../src/ksuid/base62.ts","../../src/ksuid/ksuid.ts"],"sourcesContent":["/**\n * Note: once ES2025 is widely adopted, we can use the built-in `Uint8Array.prototype.toHex` method.\n */\n// import { toHex } from 'hextreme'\n\nimport { BufferError, ParseError } from '../errors'\n\n/**\n * Base62 encoding/decoding for KSUID.\n * Alphabet: 0-9A-Za-z (standard Base62 ordering)\n *\n * KSUID binary format: 20 bytes (160 bits)\n * - 4 bytes: timestamp (seconds since KSUID epoch)\n * - 16 bytes: payload (cryptographically random)\n *\n * String format: 27 characters of Base62\n */\n\n// Base62 alphabet: digits (0-9), uppercase (A-Z), lowercase (a-z)\nconst BASE62_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'\nconst BASE = 62n\nconst KSUID_BYTES = 20\nconst KSUID_STRING_LEN = 27\n\n// Pre-computed decode table indexed by ASCII code (0-127)\n// Uses Uint8Array for cache-efficient lookups via charCodeAt\n// Note: Base62 is case-sensitive - 'A' (value 10) and 'a' (value 36) are different\nconst DECODING = new Uint8Array(128)\nDECODING.fill(255) // 255 = invalid marker\n\nfor (let i = 0; i < BASE62_ALPHABET.length; i += 1) {\n  DECODING[BASE62_ALPHABET.charCodeAt(i)] = i\n}\n\n/**\n * Encode a 20-byte KSUID to a 27-character Base62 string.\n *\n * Algorithm: Convert the 160-bit number to base 62 using BigInt.\n * V8 has highly optimized BigInt operations for this size.\n */\nexport function encodeBase62(bytes: Uint8Array): string {\n  if (bytes.length < KSUID_BYTES) {\n    throw new BufferError(\n      'KSUID_BYTES_TOO_SHORT',\n      `KSUID bytes must be at least ${KSUID_BYTES} bytes, got ${bytes.length}`,\n    )\n  }\n\n  // Convert bytes to BigInt (big-endian)\n  let num = 0n\n  for (let i = 0; i < KSUID_BYTES; i += 1) {\n    num = (num << 8n) | BigInt(bytes[i])\n  }\n\n  // Convert to Base62 string (build from right to left)\n  // Direct string concatenation is faster than array + join in V8\n  let encoded = ''\n  while (num > 0n) {\n    const remainder = num % BASE\n    num = num / BASE\n    encoded = BASE62_ALPHABET[Number(remainder)] + encoded\n  }\n\n  // Pad the result with the zero-character ('0') to ensure a fixed length\n  return encoded.padStart(KSUID_STRING_LEN, '0')\n}\n\n/**\n * Decode a 27-character Base62 string to a 20-byte KSUID.\n *\n * Algorithm: Convert Base62 string to BigInt, then to bytes.\n * V8 has highly optimized BigInt operations.\n */\nexport function decodeBase62(str: string): Uint8Array {\n  if (str.length !== KSUID_STRING_LEN) {\n    throw new ParseError(\n      'KSUID_INVALID_LENGTH',\n      `KSUID string must be ${KSUID_STRING_LEN} characters, got ${str.length}`,\n    )\n  }\n\n  // Convert Base62 string to BigInt\n  let num = 0n\n  for (let i = 0; i < KSUID_STRING_LEN; i += 1) {\n    const code = str.charCodeAt(i)\n    if (code >= 128) {\n      throw new ParseError('KSUID_INVALID_CHAR', `Invalid KSUID character: ${str[i]}`)\n    }\n    const value = DECODING[code]\n    if (value === 255) {\n      throw new ParseError('KSUID_INVALID_CHAR', `Invalid KSUID character: ${str[i]}`)\n    }\n    num = num * BASE + BigInt(value)\n  }\n\n  // Convert BigInt to bytes (big-endian)\n  const bytes = new Uint8Array(KSUID_BYTES)\n  for (let i = KSUID_BYTES - 1; i >= 0; i -= 1) {\n    bytes[i] = Number(num & 0xffn)\n    num = num >> 8n\n  }\n\n  return bytes\n}\n","import { writeTimestamp32 } from '../common/bytes'\nimport { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeBase62, encodeBase62 } from './base62'\n\n/**\n * KSUID (K-Sortable Unique Identifier)\n *\n * A 160-bit identifier consisting of:\n * - 4 bytes: timestamp (seconds since KSUID epoch: May 13, 2014)\n * - 16 bytes: cryptographically random payload\n *\n * Encoded as a 27-character Base62 string.\n */\n\n// KSUID epoch: May 13, 2014 00:00:00 UTC (Unix timestamp in seconds)\nconst KSUID_EPOCH = 1400000000\n\nconst KSUID_BYTES = 20\nconst KSUID_STRING_LEN = 27\nconst TIMESTAMP_BYTES = 4\nconst PAYLOAD_BYTES = 16\n\n// Validation regex: 27 alphanumeric characters\n// Note: Both cases are valid Base62 characters, but they decode to different values\n// (e.g., 'A' = 10, 'a' = 36). The regex validates format, not semantic equivalence.\nconst KSUID_REGEX = /^[0-9A-Za-z]{27}$/\n\nexport type KsuidOptions = {\n  /**\n   * 16 bytes of random data to use for KSUID payload.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in seconds since Unix epoch.\n   * Defaults to Math.floor(Date.now() / 1000).\n   * KSUID natively uses second precision.\n   */\n  secs?: number\n}\n\nexport type Ksuid = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: KsuidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: KsuidOptions, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil KSUID (all zeros) */\n  NIL: string\n  /** The max KSUID (maximum valid value) */\n  MAX: string\n}\n\n/**\n * Write KSUID bytes to a buffer.\n */\nfunction ksuidBytes(timestamp: number, payload: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (!buf) {\n    buf = new Uint8Array(KSUID_BYTES)\n    offset = 0\n  } else if (offset < 0 || offset + KSUID_BYTES > buf.length) {\n    throw new BufferError(\n      'KSUID_BUFFER_OUT_OF_BOUNDS',\n      `KSUID byte range ${offset}:${offset + KSUID_BYTES - 1} is out of buffer bounds`,\n    )\n  }\n\n  // Timestamp (32-bit big-endian seconds since KSUID epoch) -> bytes 0-3\n  writeTimestamp32(buf, offset, timestamp)\n\n  // Payload (128 bits) -> bytes 4-19\n  // copy from payload[TIMESTAMP_BYTES] into buf\n  buf.set(payload.subarray(TIMESTAMP_BYTES, TIMESTAMP_BYTES + PAYLOAD_BYTES), offset + TIMESTAMP_BYTES)\n  for (let i = 0; i < PAYLOAD_BYTES; i += 1) {\n    buf[offset + TIMESTAMP_BYTES + i] = payload[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a KSUID string.\n */\nfunction ksuidFn(options?: KsuidOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with KSUID bytes.\n */\nfunction ksuidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: KsuidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction ksuidFn<TBuf extends Uint8Array = Uint8Array>(options?: KsuidOptions, buf?: TBuf, offset = 0): string | TBuf {\n  if (options) {\n    if (options.random && options.random.length < PAYLOAD_BYTES) {\n      throw new InvalidInputError('KSUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16 for KSUID')\n    }\n\n    if (options.secs && options.secs < KSUID_EPOCH) {\n      throw new InvalidInputError('KSUID_TIMESTAMP_TOO_LOW', 'Timestamp must be >= KSUID epoch')\n    }\n\n    if (options.secs) {\n      options.secs = options.secs - KSUID_EPOCH\n    }\n  }\n\n  /**\n   * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n   * side-channel attacks. This means that Date.now() will return the same value for the entire\n   * duration of a request.\n   * Implications:\n   * - all KSUIDs generated within a single request will have the same timestamp.\n   */\n  const timestamp = options?.secs ?? Math.floor(Date.now() / 1000 - KSUID_EPOCH)\n  const payload = options?.random ?? rng()\n\n  if (buf) {\n    ksuidBytes(timestamp, payload, buf, offset)\n    return buf\n  }\n\n  const bytes = ksuidBytes(timestamp, payload)\n\n  // String mode: create bytes then encode to Base62\n  return encodeBase62(bytes)\n}\n\n/**\n * Convert a KSUID string to 20 bytes.\n *\n * Note: Base62 is case-sensitive. 'A' (value 10) and 'a' (value 36) decode\n * to different byte values. This function accepts both cases as valid input.\n */\nfunction toBytes(id: string): Uint8Array {\n  return decodeBase62(id)\n}\n\n/**\n * Convert 20 bytes to a KSUID string.\n */\nfunction fromBytes(bytes: Uint8Array): string {\n  return encodeBase62(bytes)\n}\n\n/**\n * Extract the timestamp from a KSUID string.\n * Returns Unix timestamp in milliseconds for API consistency with ulid/uuidv7.\n * Note: KSUID only has second precision, so the returned value will always end in 000.\n */\nfunction timestamp(id: string): number {\n  const bytes = decodeBase62(id)\n  // First 4 bytes are big-endian timestamp (seconds since KSUID epoch)\n  const secs = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0\n  // Add KSUID epoch and convert to milliseconds\n  return (secs + KSUID_EPOCH) * 1000\n}\n\n/**\n * Validate a KSUID string format.\n *\n * Note: Both uppercase and lowercase letters are valid Base62 characters,\n * but they represent different values (e.g., 'A' = 10, 'a' = 36).\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length === KSUID_STRING_LEN && KSUID_REGEX.test(id)\n}\n\n/**\n * Generate a KSUID string or write the bytes into a buffer.\n * Also includes helpers to convert to and from byte arrays.\n */\nexport const ksuid: Ksuid = Object.assign(ksuidFn, {\n  toBytes,\n  fromBytes,\n  timestamp,\n  isValid,\n  NIL: '000000000000000000000000000',\n  MAX: 'aWgEPTl1tmebfsQzFP4bxwgy80V',\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"ksuid.mjs","names":["KSUID_BYTES","KSUID_STRING_LEN","timestamp","timestamp: number","ksuid: Ksuid"],"sources":["../../src/ksuid/base62.ts","../../src/ksuid/ksuid.ts"],"sourcesContent":["import { BufferError, ParseError } from '../errors'\n\n/**\n * Base62 encoding/decoding for KSUID.\n * Alphabet: 0-9A-Za-z (standard Base62 ordering)\n *\n * KSUID binary format: 20 bytes (160 bits)\n * - 4 bytes: timestamp (seconds since KSUID epoch)\n * - 16 bytes: payload (cryptographically random)\n *\n * String format: 27 characters of Base62\n */\n\n// Base62 alphabet: digits (0-9), uppercase (A-Z), lowercase (a-z)\nconst BASE62_ALPHABET = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'\nconst BASE = 62n\nconst MAX_KSUID_VALUE = (1n << 160n) - 1n\nconst KSUID_BYTES = 20\nconst KSUID_STRING_LEN = 27\n\n// Pre-computed decode table covering every UTF-16 code unit charCodeAt can\n// return, so lookups never go out of bounds and a single `=== 255` check\n// rejects invalid input (including non-ASCII) without a per-character range\n// check. Costs 64 KiB once at module load; valid inputs only touch the first\n// 128 bytes, so cache behavior is unaffected.\n// Note: Base62 is case-sensitive - 'A' (value 10) and 'a' (value 36) are different\nconst DECODING = new Uint8Array(65536)\nDECODING.fill(255) // 255 = invalid marker\n\nfor (let i = 0; i < BASE62_ALPHABET.length; i += 1) {\n  DECODING[BASE62_ALPHABET.charCodeAt(i)] = i\n}\n\n/**\n * Encode a 20-byte KSUID to a 27-character Base62 string.\n *\n * Algorithm: Convert the 160-bit number to base 62 using BigInt.\n * V8 has highly optimized BigInt operations for this size.\n */\nexport function encodeBase62(bytes: Uint8Array): string {\n  if (bytes.length < KSUID_BYTES) {\n    throw new BufferError(\n      'KSUID_BYTES_TOO_SHORT',\n      `KSUID bytes must be at least ${KSUID_BYTES} bytes, got ${bytes.length}`,\n    )\n  }\n\n  // Convert bytes to BigInt (big-endian)\n  let num = 0n\n  for (let i = 0; i < KSUID_BYTES; i += 1) {\n    num = (num << 8n) | BigInt(bytes[i])\n  }\n\n  // Convert to Base62 string (build from right to left)\n  // Direct string concatenation is faster than array + join in V8\n  let encoded = ''\n  while (num > 0n) {\n    const remainder = num % BASE\n    num = num / BASE\n    encoded = BASE62_ALPHABET[Number(remainder)] + encoded\n  }\n\n  // Pad the result with the zero-character ('0') to ensure a fixed length\n  return encoded.padStart(KSUID_STRING_LEN, '0')\n}\n\n/**\n * Decode a 27-character Base62 string to a 20-byte KSUID.\n *\n * Algorithm: Convert Base62 string to BigInt, then to bytes.\n * V8 has highly optimized BigInt operations.\n */\nexport function decodeBase62(str: string): Uint8Array {\n  if (str.length !== KSUID_STRING_LEN) {\n    throw new ParseError(\n      'KSUID_INVALID_LENGTH',\n      `KSUID string must be ${KSUID_STRING_LEN} characters, got ${str.length}`,\n    )\n  }\n\n  // Convert Base62 string to BigInt\n  let num = 0n\n  for (let i = 0; i < KSUID_STRING_LEN; i += 1) {\n    const value = DECODING[str.charCodeAt(i)]\n    if (value === 255) {\n      throw new ParseError('KSUID_INVALID_CHAR', `Invalid KSUID character: ${str[i]}`)\n    }\n    num = num * BASE + BigInt(value)\n  }\n\n  if (num > MAX_KSUID_VALUE) {\n    throw new ParseError('KSUID_OVERFLOW', 'KSUID string exceeds 160-bit range')\n  }\n\n  // Convert BigInt to bytes (big-endian)\n  const bytes = new Uint8Array(KSUID_BYTES)\n  for (let i = KSUID_BYTES - 1; i >= 0; i -= 1) {\n    bytes[i] = Number(num & 0xffn)\n    num = num >> 8n\n  }\n\n  return bytes\n}\n","import { writeTimestamp32 } from '../common/bytes'\nimport { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeBase62, encodeBase62 } from './base62'\n\n/**\n * KSUID (K-Sortable Unique Identifier)\n *\n * A 160-bit identifier consisting of:\n * - 4 bytes: timestamp (seconds since KSUID epoch: May 13, 2014)\n * - 16 bytes: cryptographically random payload\n *\n * Encoded as a 27-character Base62 string.\n */\n\n// KSUID epoch: May 13, 2014 00:00:00 UTC (Unix timestamp in seconds)\nconst KSUID_EPOCH = 1400000000\n\nconst KSUID_BYTES = 20\nconst KSUID_STRING_LEN = 27\nconst TIMESTAMP_BYTES = 4\nconst PAYLOAD_BYTES = 16\nconst KSUID_MAX_SECS = KSUID_EPOCH + 0xffffffff\n// 2^160 - 1 in Base62 ('aWgEPTl1tmebfsQzFP4bxwgy80V'), derived from the\n// encoder so it cannot drift from the decoder's 160-bit overflow bound.\nconst KSUID_MAX_STRING = encodeBase62(new Uint8Array(KSUID_BYTES).fill(0xff))\n\n// Validation regex: 27 alphanumeric characters\n// Note: Both cases are valid Base62 characters, but they decode to different values\n// (e.g., 'A' = 10, 'a' = 36). The regex validates format, not semantic equivalence.\nconst KSUID_REGEX = /^[0-9A-Za-z]{27}$/\n\nexport type KsuidOptions = {\n  /**\n   * 16 bytes of random data to use for KSUID payload.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in seconds since Unix epoch.\n   * Defaults to Math.floor(Date.now() / 1000).\n   * KSUID natively uses second precision.\n   */\n  secs?: number\n}\n\nexport type Ksuid = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: KsuidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: KsuidOptions, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil KSUID (all zeros) */\n  NIL: string\n  /** The max KSUID (maximum valid value) */\n  MAX: string\n}\n\n/**\n * Write KSUID bytes to a buffer.\n */\nfunction ksuidBytes(timestamp: number, payload: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (!buf) {\n    buf = new Uint8Array(KSUID_BYTES)\n    offset = 0\n  } else if (offset < 0 || offset + KSUID_BYTES > buf.length) {\n    throw new BufferError(\n      'KSUID_BUFFER_OUT_OF_BOUNDS',\n      `KSUID byte range ${offset}:${offset + KSUID_BYTES - 1} is out of buffer bounds`,\n    )\n  }\n\n  // Timestamp (32-bit big-endian seconds since KSUID epoch) -> bytes 0-3\n  writeTimestamp32(buf, offset, timestamp)\n\n  // Payload (128 bits) -> bytes 4-19\n  for (let i = 0; i < PAYLOAD_BYTES; i += 1) {\n    buf[offset + TIMESTAMP_BYTES + i] = payload[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a KSUID string.\n */\nfunction ksuidFn(options?: KsuidOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with KSUID bytes.\n */\nfunction ksuidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: KsuidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction ksuidFn<TBuf extends Uint8Array = Uint8Array>(options?: KsuidOptions, buf?: TBuf, offset = 0): string | TBuf {\n  const random = options?.random\n  if (random && random.length < PAYLOAD_BYTES) {\n    throw new InvalidInputError('KSUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16 for KSUID')\n  }\n\n  let timestamp: number\n  const secs = options?.secs\n  if (secs !== undefined) {\n    if (secs < KSUID_EPOCH) {\n      throw new InvalidInputError('KSUID_TIMESTAMP_TOO_LOW', 'Timestamp must be >= KSUID epoch')\n    }\n\n    if (secs > KSUID_MAX_SECS) {\n      throw new InvalidInputError('KSUID_TIMESTAMP_TOO_HIGH', 'Timestamp must be <= maximum KSUID timestamp')\n    }\n\n    timestamp = secs - KSUID_EPOCH\n  } else {\n    /**\n     * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n     * side-channel attacks. This means that Date.now() will return the same value for the entire\n     * duration of a request.\n     * Implications:\n     * - all KSUIDs generated within a single request will have the same timestamp.\n     */\n    timestamp = Math.floor(Date.now() / 1000) - KSUID_EPOCH\n  }\n\n  const payload = random ?? rng()\n\n  if (buf) {\n    ksuidBytes(timestamp, payload, buf, offset)\n    return buf\n  }\n\n  const bytes = ksuidBytes(timestamp, payload)\n\n  // String mode: create bytes then encode to Base62\n  return encodeBase62(bytes)\n}\n\n/**\n * Convert a KSUID string to 20 bytes.\n *\n * Note: Base62 is case-sensitive. 'A' (value 10) and 'a' (value 36) decode\n * to different byte values. This function accepts both cases as valid input.\n */\nfunction toBytes(id: string): Uint8Array {\n  return decodeBase62(id)\n}\n\n/**\n * Convert 20 bytes to a KSUID string.\n */\nfunction fromBytes(bytes: Uint8Array): string {\n  return encodeBase62(bytes)\n}\n\n/**\n * Extract the timestamp from a KSUID string.\n * Returns Unix timestamp in milliseconds for API consistency with ulid/uuidv7.\n * Note: KSUID only has second precision, so the returned value will always end in 000.\n */\nfunction timestamp(id: string): number {\n  const bytes = decodeBase62(id)\n  // First 4 bytes are big-endian timestamp (seconds since KSUID epoch)\n  const secs = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0\n  // Add KSUID epoch and convert to milliseconds\n  return (secs + KSUID_EPOCH) * 1000\n}\n\n/**\n * Validate a KSUID string format and 160-bit numeric range.\n */\nfunction isValid(id: unknown): id is string {\n  return (\n    typeof id === 'string' &&\n    id.length === KSUID_STRING_LEN &&\n    KSUID_REGEX.test(id) &&\n    // Fixed-length Base62 strings preserve numeric order because the alphabet is ASCII-sorted.\n    id <= KSUID_MAX_STRING\n  )\n}\n\n/**\n * Generate a KSUID string or write the bytes into a buffer.\n * Also includes helpers to convert to and from byte arrays.\n */\nexport const ksuid: Ksuid = Object.assign(ksuidFn, {\n  toBytes,\n  fromBytes,\n  timestamp,\n  isValid,\n  NIL: '000000000000000000000000000',\n  MAX: KSUID_MAX_STRING,\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/nanoid/nanoid.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"nanoid.d.mts","names":["nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":[],"mappings":";;;;cAGa,YAAA;KAwBD,aAAA;EAxBZ;AAwBA;AAkBA;AAqMA;;WAjNW;;;;;;;;;;;KAYC,MAAA;;;;;;YAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+LCA,QAAQ"}
+{"version":3,"file":"nanoid.d.mts","names":["nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":[],"mappings":";;;;cAGa,YAAA;KAyBD,aAAA;EAzBZ;AAyBA;AAkBA;AAqMA;;WAjNW;;;;;;;;;;;KAYC,MAAA;;;;;;YAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+LCA,QAAQ"}

package/build/nanoid/nanoid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"nanoid.mjs","names":["pool: Uint8Array | undefined","id","randomBytes: Uint8Array | undefined","mask","bytes: Uint8Array","nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":["import { InvalidInputError } from '../errors'\n\n/** Default URL-safe alphabet (64 characters): A-Z, a-z, 0-9, underscore, hyphen */\nexport const URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-'\n\nconst DEFAULT_SIZE = 21\nconst MAX_SIZE = 2048\nconst NANOID_REGEX = /^[A-Za-z0-9_-]+$/\n\n// Simple random pool for ultra-fast path (npm nanoid style - no thread-safety overhead)\nconst POOL_SIZE_MULTIPLIER = 128\nlet pool: Uint8Array | undefined\nlet poolOffset = 0\n\nfunction fillPool(bytes: number): void {\n  const size = bytes * POOL_SIZE_MULTIPLIER\n  if (!pool || pool.length < size) {\n    pool = new Uint8Array(size)\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  } else if (poolOffset + bytes > pool.length) {\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  }\n  poolOffset += bytes\n}\n\nexport type NanoidOptions = {\n  /**\n   * Random bytes for deterministic output (testing).\n   * For power-of-2 alphabets (2, 4, 8, 16, 32, 64, 128, 256): exactly `size` bytes needed.\n   * For other alphabets: ~size * 2 bytes needed (rejection sampling).\n   */\n  random?: Uint8Array\n  /**\n   * Custom alphabet to use. Default: URL-safe A-Za-z0-9_-\n   * Must be 2-256 printable ASCII characters (32-126) with no duplicates.\n   */\n  alphabet?: string\n  /**\n   * Length of generated ID. Default: 21. Maximum: 2048.\n   */\n  size?: number\n}\n\nexport type Nanoid = {\n  /** Generate nanoid with default settings */\n  (): string\n  /** Generate nanoid with custom size */\n  (size: number): string\n  /** Generate nanoid with options */\n  (options: NanoidOptions): string\n  /**\n   * Validate a nanoid string against the default URL-safe alphabet.\n   * Note: Does not validate IDs generated with custom alphabets.\n   */\n  isValid(id: unknown): id is string\n}\n\n/**\n * Validate alphabet: 2-256 printable ASCII chars, no duplicates\n */\nfunction validateAlphabet(alphabet: string): void {\n  if (alphabet.length < 2) {\n    throw new InvalidInputError('NANOID_ALPHABET_TOO_SHORT', 'Alphabet must contain at least 2 characters')\n  }\n  if (alphabet.length > 256) {\n    throw new InvalidInputError('NANOID_ALPHABET_TOO_LONG', 'Alphabet must not exceed 256 characters')\n  }\n  const seen = new Set<string>()\n  for (const char of alphabet) {\n    const code = char.charCodeAt(0)\n    if (code < 32 || code > 126) {\n      throw new InvalidInputError(\n        'NANOID_ALPHABET_INVALID_CHAR',\n        'Alphabet must contain only printable ASCII characters (32-126)',\n      )\n    }\n    if (seen.has(char)) {\n      throw new InvalidInputError('NANOID_ALPHABET_DUPLICATE', `Duplicate character in alphabet: \"${char}\"`)\n    }\n    seen.add(char)\n  }\n}\n\n/**\n * Validate size parameter\n */\nfunction validateSize(size: number): void {\n  if (!Number.isInteger(size) || size < 0) {\n    throw new InvalidInputError('NANOID_SIZE_INVALID', 'Size must be a non-negative integer')\n  }\n  if (size > MAX_SIZE) {\n    throw new InvalidInputError('NANOID_SIZE_TOO_LARGE', `Size must not exceed ${MAX_SIZE}`)\n  }\n}\n\n// Overloads\nfunction nanoidFn(): string\nfunction nanoidFn(size: number): string\nfunction nanoidFn(options: NanoidOptions): string\nfunction nanoidFn(sizeOrOptions?: number | NanoidOptions): string {\n  // ULTRA-FAST PATH: No arguments = default nanoid\n  // Uses simple pooled random bytes (npm nanoid style) for best performance\n  if (sizeOrOptions === undefined) {\n    fillPool(DEFAULT_SIZE)\n    let id = ''\n    for (let i = poolOffset - DEFAULT_SIZE; i < poolOffset; i++) {\n      id += URL_ALPHABET[pool![i] & 63]\n    }\n    return id\n  }\n\n  let size = DEFAULT_SIZE\n  let alphabet = URL_ALPHABET\n  let randomBytes: Uint8Array | undefined\n\n  if (typeof sizeOrOptions === 'number') {\n    size = sizeOrOptions\n  } else {\n    size = sizeOrOptions.size ?? DEFAULT_SIZE\n    alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET\n    randomBytes = sizeOrOptions.random\n    if (sizeOrOptions.alphabet !== undefined) {\n      validateAlphabet(alphabet)\n    }\n  }\n\n  validateSize(size)\n\n  if (size === 0) return ''\n\n  const alphabetLen = alphabet.length\n\n  // FAST PATH: Power-of-2 alphabet (includes default 64-char)\n  // No rejection needed - each byte maps directly to a character\n  if ((alphabetLen & (alphabetLen - 1)) === 0) {\n    const mask = alphabetLen - 1\n    if (randomBytes && randomBytes.length < size) {\n      throw new InvalidInputError(\n        'NANOID_RANDOM_BYTES_INSUFFICIENT',\n        `Insufficient random bytes: need ${size}, have ${randomBytes.length}`,\n      )\n    }\n    const bytes = randomBytes?.subarray(0, size) ?? globalThis.crypto.getRandomValues(new Uint8Array(size))\n    let id = ''\n    for (let i = 0; i < size; i++) {\n      id += alphabet[bytes[i] & mask]\n    }\n    return id\n  }\n\n  // SLOW PATH: Rejection sampling for non-power-of-2 alphabets\n  // Calculate mask: smallest power-of-2 minus 1 that covers alphabet size\n  const mask = (2 << (31 - Math.clz32((alphabetLen - 1) | 1))) - 1\n  // Calculate step: random bytes per batch (1.6x accounts for rejection)\n  const step = Math.ceil((1.6 * mask * size) / alphabetLen)\n\n  let id = ''\n  let randomOffset = 0\n\n  while (id.length < size) {\n    let bytes: Uint8Array\n    if (randomBytes) {\n      if (randomBytes.length - randomOffset < step) {\n        throw new InvalidInputError(\n          'NANOID_RANDOM_BYTES_INSUFFICIENT',\n          `Insufficient random bytes: need at least ${step} more, have ${randomBytes.length - randomOffset}`,\n        )\n      }\n      bytes = randomBytes.subarray(randomOffset, randomOffset + step)\n      randomOffset += step\n    } else {\n      bytes = globalThis.crypto.getRandomValues(new Uint8Array(step))\n    }\n\n    for (let i = 0; i < bytes.length && id.length < size; i++) {\n      const index = bytes[i] & mask\n      if (index < alphabetLen) {\n        id += alphabet[index]\n      }\n      // Otherwise reject and continue (no modulo bias)\n    }\n  }\n\n  return id\n}\n\n/**\n * Validate a nanoid string against the default URL-safe alphabet.\n * Note: Does not validate IDs generated with custom alphabets.\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length > 0 && NANOID_REGEX.test(id)\n}\n\n/**\n * Generate a URL-friendly unique string ID.\n *\n * Nanoid is a tiny, secure, URL-friendly unique string ID generator.\n * It uses a URL-safe alphabet (A-Za-z0-9_-) and generates 21-character\n * IDs by default with 126 bits of entropy.\n *\n * Unlike UUID v7 or ULID, nanoid is NOT time-ordered. Use it for:\n * - URL shorteners\n * - Session tokens\n * - Invite codes\n * - Any case where you need short, random IDs\n *\n * @example Basic usage\n * ```ts\n * import { nanoid } from 'uniku/nanoid'\n *\n * const id = nanoid()\n * // => \"V1StGXR8_Z5jdHi6B-myT\"\n * ```\n *\n * @example Custom size\n * ```ts\n * const shortId = nanoid(10)\n * // => \"IRFa-VaY2b\"\n * ```\n *\n * @example Custom alphabet (hex)\n * ```ts\n * const hexId = nanoid({ alphabet: '0123456789abcdef', size: 12 })\n * // => \"4f90d13a42bc\"\n * ```\n *\n * @example Validation\n * ```ts\n * const maybeId: unknown = getUserInput()\n * if (nanoid.isValid(maybeId)) {\n *   // TypeScript knows maybeId is string\n *   console.log(maybeId.length)\n * }\n * ```\n *\n * @throws {InvalidInputError} Size must be between 0 and 2048\n * @throws {InvalidInputError} Alphabet must contain 2-256 unique printable ASCII characters\n * @throws {InvalidInputError} Insufficient random bytes for requested size\n */\nexport const nanoid: Nanoid = Object.assign(nanoidFn, {\n  isValid,\n})\n\nexport { InvalidInputError, UniqueIdError } from '../errors'\n"],"mappings":"qEAGA,MAAa,EAAe,mEAGtB,EAAW,KACX,EAAe,mBAIrB,IAAIA,EACA,EAAa,EAEjB,SAAS,EAAS,EAAqB,CACrC,IAAM,EAAO,EAAQ,IACjB,CAAC,GAAQ,EAAK,OAAS,GACzB,EAAO,IAAI,WAAW,EAAK,CAC3B,OAAO,gBAAgB,EAAK,CAC5B,EAAa,GACJ,EAAa,EAAQ,EAAK,SACnC,OAAO,gBAAgB,EAAK,CAC5B,EAAa,GAEf,GAAc,EAsChB,SAAS,EAAiB,EAAwB,CAChD,GAAI,EAAS,OAAS,EACpB,MAAM,IAAI,EAAkB,4BAA6B,8CAA8C,CAEzG,GAAI,EAAS,OAAS,IACpB,MAAM,IAAI,EAAkB,2BAA4B,0CAA0C,CAEpG,IAAM,EAAO,IAAI,IACjB,IAAK,IAAM,KAAQ,EAAU,CAC3B,IAAM,EAAO,EAAK,WAAW,EAAE,CAC/B,GAAI,EAAO,IAAM,EAAO,IACtB,MAAM,IAAI,EACR,+BACA,iEACD,CAEH,GAAI,EAAK,IAAI,EAAK,CAChB,MAAM,IAAI,EAAkB,4BAA6B,qCAAqC,EAAK,GAAG,CAExG,EAAK,IAAI,EAAK,EAOlB,SAAS,EAAa,EAAoB,CACxC,GAAI,CAAC,OAAO,UAAU,EAAK,EAAI,EAAO,EACpC,MAAM,IAAI,EAAkB,sBAAuB,sCAAsC,CAE3F,GAAI,EAAO,EACT,MAAM,IAAI,EAAkB,wBAAyB,wBAAwB,IAAW,CAQ5F,SAAS,EAAS,EAAgD,CAGhE,GAAI,IAAkB,IAAA,GAAW,CAC/B,EAAS,GAAa,CACtB,IAAIC,EAAK,GACT,IAAK,IAAI,EAAI,EAAa,GAAc,EAAI,EAAY,IACtD,GAAM,EAAa,EAAM,GAAK,IAEhC,OAAOA,EAGT,IAAI,EAAO,GACP,EAAW,EACXC,EAeJ,GAbI,OAAO,GAAkB,SAC3B,EAAO,GAEP,EAAO,EAAc,MAAQ,GAC7B,EAAW,EAAc,UAAY,EACrC,EAAc,EAAc,OACxB,EAAc,WAAa,IAAA,IAC7B,EAAiB,EAAS,EAI9B,EAAa,EAAK,CAEd,IAAS,EAAG,MAAO,GAEvB,IAAM,EAAc,EAAS,OAI7B,GAAA,EAAK,EAAe,EAAc,GAAW,CAC3C,IAAMC,EAAO,EAAc,EAC3B,GAAI,GAAe,EAAY,OAAS,EACtC,MAAM,IAAI,EACR,mCACA,mCAAmC,EAAK,SAAS,EAAY,SAC9D,CAEH,IAAM,EAAQ,GAAa,SAAS,EAAG,EAAK,EAAI,WAAW,OAAO,gBAAgB,IAAI,WAAW,EAAK,CAAC,CACnGF,EAAK,GACT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,IACxB,GAAM,EAAS,EAAM,GAAKE,GAE5B,OAAOF,EAKT,IAAM,GAAQ,GAAM,GAAK,KAAK,MAAO,EAAc,EAAK,EAAE,EAAK,EAEzD,EAAO,KAAK,KAAM,IAAM,EAAO,EAAQ,EAAY,CAErD,EAAK,GACL,EAAe,EAEnB,KAAO,EAAG,OAAS,GAAM,CACvB,IAAIG,EACJ,GAAI,EAAa,CACf,GAAI,EAAY,OAAS,EAAe,EACtC,MAAM,IAAI,EACR,mCACA,4CAA4C,EAAK,cAAc,EAAY,OAAS,IACrF,CAEH,EAAQ,EAAY,SAAS,EAAc,EAAe,EAAK,CAC/D,GAAgB,OAEhB,EAAQ,WAAW,OAAO,gBAAgB,IAAI,WAAW,EAAK,CAAC,CAGjE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,QAAU,EAAG,OAAS,EAAM,IAAK,CACzD,IAAM,EAAQ,EAAM,GAAK,EACrB,EAAQ,IACV,GAAM,EAAS,KAMrB,OAAO,EAOT,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAG,OAAS,GAAK,EAAa,KAAK,EAAG,CAiDzE,MAAaC,EAAiB,OAAO,OAAO,EAAU,CACpD,UACD,CAAC"}
+{"version":3,"file":"nanoid.mjs","names":["pool: Uint8Array | undefined","id","randomBytes: Uint8Array | undefined","mask","bytes: Uint8Array","nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":["import { InvalidInputError } from '../errors'\n\n/** Default URL-safe alphabet (64 characters): A-Z, a-z, 0-9, underscore, hyphen */\nexport const URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-'\n\nconst DEFAULT_SIZE = 21\nconst MAX_SIZE = 2048\nconst NANOID_REGEX = /^[A-Za-z0-9_-]+$/\n\n// Keep Nanoid's private pool for its default hot path. It consumes `size`\n// bytes directly without the shared helper's UUID/CUID2-oriented branches.\nconst POOL_SIZE_MULTIPLIER = 128\nlet pool: Uint8Array | undefined\nlet poolOffset = 0\n\nfunction fillPool(bytes: number): void {\n  const size = bytes * POOL_SIZE_MULTIPLIER\n  if (!pool || pool.length < size) {\n    pool = new Uint8Array(size)\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  } else if (poolOffset + bytes > pool.length) {\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  }\n  poolOffset += bytes\n}\n\nexport type NanoidOptions = {\n  /**\n   * Random bytes for deterministic output (testing).\n   * For power-of-2 alphabets (2, 4, 8, 16, 32, 64, 128, 256): exactly `size` bytes needed.\n   * For other alphabets: ~size * 2 bytes needed (rejection sampling).\n   */\n  random?: Uint8Array\n  /**\n   * Custom alphabet to use. Default: URL-safe A-Za-z0-9_-\n   * Must be 2-256 printable ASCII characters (32-126) with no duplicates.\n   */\n  alphabet?: string\n  /**\n   * Length of generated ID. Default: 21. Maximum: 2048.\n   */\n  size?: number\n}\n\nexport type Nanoid = {\n  /** Generate nanoid with default settings */\n  (): string\n  /** Generate nanoid with custom size */\n  (size: number): string\n  /** Generate nanoid with options */\n  (options: NanoidOptions): string\n  /**\n   * Validate a nanoid string against the default URL-safe alphabet.\n   * Note: Does not validate IDs generated with custom alphabets.\n   */\n  isValid(id: unknown): id is string\n}\n\n/**\n * Validate alphabet: 2-256 printable ASCII chars, no duplicates\n */\nfunction validateAlphabet(alphabet: string): void {\n  if (alphabet.length < 2) {\n    throw new InvalidInputError('NANOID_ALPHABET_TOO_SHORT', 'Alphabet must contain at least 2 characters')\n  }\n  if (alphabet.length > 256) {\n    throw new InvalidInputError('NANOID_ALPHABET_TOO_LONG', 'Alphabet must not exceed 256 characters')\n  }\n  const seen = new Set<string>()\n  for (const char of alphabet) {\n    const code = char.charCodeAt(0)\n    if (code < 32 || code > 126) {\n      throw new InvalidInputError(\n        'NANOID_ALPHABET_INVALID_CHAR',\n        'Alphabet must contain only printable ASCII characters (32-126)',\n      )\n    }\n    if (seen.has(char)) {\n      throw new InvalidInputError('NANOID_ALPHABET_DUPLICATE', `Duplicate character in alphabet: \"${char}\"`)\n    }\n    seen.add(char)\n  }\n}\n\n/**\n * Validate size parameter\n */\nfunction validateSize(size: number): void {\n  if (!Number.isInteger(size) || size < 0) {\n    throw new InvalidInputError('NANOID_SIZE_INVALID', 'Size must be a non-negative integer')\n  }\n  if (size > MAX_SIZE) {\n    throw new InvalidInputError('NANOID_SIZE_TOO_LARGE', `Size must not exceed ${MAX_SIZE}`)\n  }\n}\n\n// Overloads\nfunction nanoidFn(): string\nfunction nanoidFn(size: number): string\nfunction nanoidFn(options: NanoidOptions): string\nfunction nanoidFn(sizeOrOptions?: number | NanoidOptions): string {\n  // ULTRA-FAST PATH: No arguments = default nanoid\n  // Uses simple pooled random bytes (npm nanoid style) for best performance\n  if (sizeOrOptions === undefined) {\n    fillPool(DEFAULT_SIZE)\n    let id = ''\n    for (let i = poolOffset - DEFAULT_SIZE; i < poolOffset; i++) {\n      id += URL_ALPHABET[pool![i] & 63]\n    }\n    return id\n  }\n\n  let size = DEFAULT_SIZE\n  let alphabet = URL_ALPHABET\n  let randomBytes: Uint8Array | undefined\n\n  if (typeof sizeOrOptions === 'number') {\n    size = sizeOrOptions\n  } else {\n    size = sizeOrOptions.size ?? DEFAULT_SIZE\n    alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET\n    randomBytes = sizeOrOptions.random\n    if (sizeOrOptions.alphabet !== undefined) {\n      validateAlphabet(alphabet)\n    }\n  }\n\n  validateSize(size)\n\n  if (size === 0) return ''\n\n  const alphabetLen = alphabet.length\n\n  // FAST PATH: Power-of-2 alphabet (includes default 64-char)\n  // No rejection needed - each byte maps directly to a character\n  if ((alphabetLen & (alphabetLen - 1)) === 0) {\n    const mask = alphabetLen - 1\n    if (randomBytes && randomBytes.length < size) {\n      throw new InvalidInputError(\n        'NANOID_RANDOM_BYTES_INSUFFICIENT',\n        `Insufficient random bytes: need ${size}, have ${randomBytes.length}`,\n      )\n    }\n    const bytes = randomBytes?.subarray(0, size) ?? globalThis.crypto.getRandomValues(new Uint8Array(size))\n    let id = ''\n    for (let i = 0; i < size; i++) {\n      id += alphabet[bytes[i] & mask]\n    }\n    return id\n  }\n\n  // SLOW PATH: Rejection sampling for non-power-of-2 alphabets\n  // Calculate mask: smallest power-of-2 minus 1 that covers alphabet size\n  const mask = (2 << (31 - Math.clz32((alphabetLen - 1) | 1))) - 1\n  // Calculate step: random bytes per batch (1.6x accounts for rejection)\n  const step = Math.ceil((1.6 * mask * size) / alphabetLen)\n\n  let id = ''\n  let randomOffset = 0\n\n  while (id.length < size) {\n    let bytes: Uint8Array\n    if (randomBytes) {\n      if (randomBytes.length - randomOffset < step) {\n        throw new InvalidInputError(\n          'NANOID_RANDOM_BYTES_INSUFFICIENT',\n          `Insufficient random bytes: need at least ${step} more, have ${randomBytes.length - randomOffset}`,\n        )\n      }\n      bytes = randomBytes.subarray(randomOffset, randomOffset + step)\n      randomOffset += step\n    } else {\n      bytes = globalThis.crypto.getRandomValues(new Uint8Array(step))\n    }\n\n    for (let i = 0; i < bytes.length && id.length < size; i++) {\n      const index = bytes[i] & mask\n      if (index < alphabetLen) {\n        id += alphabet[index]\n      }\n      // Otherwise reject and continue (no modulo bias)\n    }\n  }\n\n  return id\n}\n\n/**\n * Validate a nanoid string against the default URL-safe alphabet.\n * Note: Does not validate IDs generated with custom alphabets.\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length > 0 && NANOID_REGEX.test(id)\n}\n\n/**\n * Generate a URL-friendly unique string ID.\n *\n * Nanoid is a tiny, secure, URL-friendly unique string ID generator.\n * It uses a URL-safe alphabet (A-Za-z0-9_-) and generates 21-character\n * IDs by default with 126 bits of entropy.\n *\n * Unlike UUID v7 or ULID, nanoid is NOT time-ordered. Use it for:\n * - URL shorteners\n * - Session tokens\n * - Invite codes\n * - Any case where you need short, random IDs\n *\n * @example Basic usage\n * ```ts\n * import { nanoid } from 'uniku/nanoid'\n *\n * const id = nanoid()\n * // => \"V1StGXR8_Z5jdHi6B-myT\"\n * ```\n *\n * @example Custom size\n * ```ts\n * const shortId = nanoid(10)\n * // => \"IRFa-VaY2b\"\n * ```\n *\n * @example Custom alphabet (hex)\n * ```ts\n * const hexId = nanoid({ alphabet: '0123456789abcdef', size: 12 })\n * // => \"4f90d13a42bc\"\n * ```\n *\n * @example Validation\n * ```ts\n * const maybeId: unknown = getUserInput()\n * if (nanoid.isValid(maybeId)) {\n *   // TypeScript knows maybeId is string\n *   console.log(maybeId.length)\n * }\n * ```\n *\n * @throws {InvalidInputError} Size must be between 0 and 2048\n * @throws {InvalidInputError} Alphabet must contain 2-256 unique printable ASCII characters\n * @throws {InvalidInputError} Insufficient random bytes for requested size\n */\nexport const nanoid: Nanoid = Object.assign(nanoidFn, {\n  isValid,\n})\n\nexport { InvalidInputError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/random-CWCVvNLb.mjs

@@ -0,0 +1,2 @@
+const e=globalThis.crypto.getRandomValues.bind(globalThis.crypto),t=new Uint8Array(256);let n=256;function r(){e(t),n=0}function i(){n>252&&r();let e=t[n]*16777216+t[n+1]*65536+t[n+2]*256+t[n+3]>>>0;return n+=4,e}function a(){n>240&&r();let e=n;return n+=16,t.subarray(e,n)}export{a as n,i as t};
+//# sourceMappingURL=random-CWCVvNLb.mjs.map

package/build/random-CWCVvNLb.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-CWCVvNLb.mjs","names":[],"sources":["../src/common/random.ts"],"sourcesContent":["const randomFill = /*@__PURE__*/ globalThis.crypto.getRandomValues.bind(globalThis.crypto)\n\n/**\n * Simple random byte pool for ID generation.\n *\n * Module-level state is per JavaScript isolate, so SharedArrayBuffer and Atomics\n * only add overhead here. Returned views are consumed synchronously by callers.\n */\n\nconst POOL_SIZE = 256\nconst pool = new Uint8Array(POOL_SIZE)\nlet poolOffset = POOL_SIZE\n\nfunction refillPool(): void {\n  randomFill(pool)\n  poolOffset = 0\n}\n\n/**\n * Return a view of `count` random bytes from the pool.\n */\nexport function randomBytes(count: number): Uint8Array {\n  if (count > POOL_SIZE) {\n    return randomFill(new Uint8Array(count))\n  }\n\n  if (poolOffset + count > POOL_SIZE) {\n    refillPool()\n  }\n\n  const start = poolOffset\n  poolOffset += count\n  return pool.subarray(start, poolOffset)\n}\n\n/**\n * Generate a random unsigned 32-bit integer from the shared pool.\n */\nexport function randomUint32(): number {\n  if (poolOffset > POOL_SIZE - 4) {\n    refillPool()\n  }\n\n  const value =\n    (pool[poolOffset] * 0x1000000 +\n      pool[poolOffset + 1] * 0x10000 +\n      pool[poolOffset + 2] * 0x100 +\n      pool[poolOffset + 3]) >>>\n    0\n  poolOffset += 4\n  return value\n}\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Uses a pre-filled pool to minimize crypto API calls.\n */\nexport function rng(): Uint8Array {\n  if (poolOffset > POOL_SIZE - 16) {\n    refillPool()\n  }\n\n  const start = poolOffset\n  poolOffset += 16\n  return pool.subarray(start, poolOffset)\n}\n"],"mappings":"AAAA,MAAM,EAA2B,WAAW,OAAO,gBAAgB,KAAK,WAAW,OAAO,CAUpF,EAAO,IAAI,WAAW,IAAU,CACtC,IAAI,EAAa,IAEjB,SAAS,GAAmB,CAC1B,EAAW,EAAK,CAChB,EAAa,EAuBf,SAAgB,GAAuB,CACjC,EAAa,KACf,GAAY,CAGd,IAAM,EACH,EAAK,GAAc,SAClB,EAAK,EAAa,GAAK,MACvB,EAAK,EAAa,GAAK,IACvB,EAAK,EAAa,KACpB,EAEF,MADA,IAAc,EACP,EAOT,SAAgB,GAAkB,CAC5B,EAAa,KACf,GAAY,CAGd,IAAM,EAAQ,EAEd,MADA,IAAc,GACP,EAAK,SAAS,EAAO,EAAW"}

package/build/ulid/ulid.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ulid.d.mts","names":["ulid: Ulid"],"sources":["../../src/ulid/ulid.ts"],"sourcesContent":[],"mappings":";;;KAKY,WAAA;;;AAAZ;AAaA;EAEgB,MAAA,CAAA,EAVL,UAUK;EAAa;;;;EAChB,KAAA,CAAA,EAAA,MAAA;CACU;AACJ,KALP,IAAA,GAKO;EAAA,EAAA,EAAA,MAAA;EAgJnB,CAAA,aAnJgB,UAmJG,GAnJU,UAmJV,CAAA,CAAA,OAAA,EAnJ+B,WAmJ/B,GAAA,SAAA,EAAA,GAAA,EAnJ6D,IAmJ7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAnJqF,IAmJrF;aAlJN;uBACU;mBACJ;;;;;;;;cAgJNA,MAAM"}
+{"version":3,"file":"ulid.d.mts","names":["ulid: Ulid"],"sources":["../../src/ulid/ulid.ts"],"sourcesContent":[],"mappings":";;;KAKY,WAAA;;;AAAZ;AAaA;EAEgB,MAAA,CAAA,EAVL,UAUK;EAAa;;;;EAChB,KAAA,CAAA,EAAA,MAAA;CACU;AACJ,KALP,IAAA,GAKO;EAAA,EAAA,EAAA,MAAA;EAuJnB,CAAA,aA1JgB,UA0JG,GA1JU,UA0JV,CAAA,CAAA,OAAA,EA1J+B,WA0J/B,GAAA,SAAA,EAAA,GAAA,EA1J6D,IA0J7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EA1JqF,IA0JrF;aAzJN;uBACU;mBACJ;;;;;;;;cAuJNA,MAAM"}

package/build/ulid/ulid.mjs

@@ -1,2 +1,2 @@
-import{BufferError as e,InvalidInputError as t,ParseError as n,UniqueIdError as r}from"../errors.mjs";import{r as i,t as a}from"../bytes-BBjKLOBR.mjs";import{t as o}from"../random-DcKA4vF7.mjs";const s=`0123456789ABCDEFGHJKMNPQRSTVWXYZ`,c=new Uint8Array(128);c.fill(255);for(let e=0;e<32;e+=1){let t=s.charCodeAt(e),n=s[e].toLowerCase().charCodeAt(0);c[t]=e,c[n]=e}function l(e){return s[Math.floor(e/35184372088832)&31]+s[Math.floor(e/1099511627776)&31]+s[Math.floor(e/34359738368)&31]+s[Math.floor(e/1073741824)&31]+s[Math.floor(e/33554432)&31]+s[Math.floor(e/1048576)&31]+s[Math.floor(e/32768)&31]+s[Math.floor(e/1024)&31]+s[Math.floor(e/32)&31]+s[e&31]}function u(e){return s[e[0]>>3&31]+s[(e[0]<<2|e[1]>>6)&31]+s[e[1]>>1&31]+s[(e[1]<<4|e[2]>>4)&31]+s[(e[2]<<1|e[3]>>7)&31]+s[e[3]>>2&31]+s[(e[3]<<3|e[4]>>5)&31]+s[e[4]&31]+s[e[5]>>3&31]+s[(e[5]<<2|e[6]>>6)&31]+s[e[6]>>1&31]+s[(e[6]<<4|e[7]>>4)&31]+s[(e[7]<<1|e[8]>>7)&31]+s[e[8]>>2&31]+s[(e[8]<<3|e[9]>>5)&31]+s[e[9]&31]}function d(e){let t=0;for(let r=0;r<10;r+=1){let i=c[e.charCodeAt(r)];if(i===255)throw new n(`ULID_INVALID_CHAR`,`Invalid ULID character: ${e[r]}`);t=t*32+i}return t}function f(e){if(e.length!==26)throw new n(`ULID_INVALID_LENGTH`,`ULID string must be 26 characters`);let t=new Uint8Array(16),r=c[e.charCodeAt(0)],i=c[e.charCodeAt(1)],a=c[e.charCodeAt(2)],o=c[e.charCodeAt(3)],s=c[e.charCodeAt(4)],l=c[e.charCodeAt(5)],u=c[e.charCodeAt(6)],d=c[e.charCodeAt(7)],f=c[e.charCodeAt(8)],p=c[e.charCodeAt(9)],m=c[e.charCodeAt(10)],h=c[e.charCodeAt(11)],g=c[e.charCodeAt(12)],_=c[e.charCodeAt(13)],v=c[e.charCodeAt(14)],y=c[e.charCodeAt(15)],b=c[e.charCodeAt(16)],x=c[e.charCodeAt(17)],S=c[e.charCodeAt(18)],C=c[e.charCodeAt(19)],w=c[e.charCodeAt(20)],T=c[e.charCodeAt(21)],E=c[e.charCodeAt(22)],D=c[e.charCodeAt(23)],O=c[e.charCodeAt(24)],k=c[e.charCodeAt(25)];if((r|i|a|o|s|l|u|d|f|p|m|h|g|_|v|y|b|x|S|C|w|T|E|D|O|k)&128){for(let t=0;t<26;t+=1)if(c[e.charCodeAt(t)]===255)throw new n(`ULID_INVALID_CHAR`,`Invalid ULID character: ${e[t]}`)}return t[0]=r<<5|i,t[1]=a<<3|o>>2,t[2]=o<<6|s<<1|l>>4,t[3]=l<<4|u>>1,t[4]=u<<7|d<<2|f>>3,t[5]=f<<5|p,t[6]=m<<3|h>>2,t[7]=h<<6|g<<1|_>>4,t[8]=_<<4|v>>1,t[9]=v<<7|y<<2|b>>3,t[10]=b<<5|x,t[11]=S<<3|C>>2,t[12]=C<<6|w<<1|T>>4,t[13]=T<<4|E>>1,t[14]=E<<7|D<<2|O>>3,t[15]=O<<5|k,t}function p(t){if(t.length<16)throw new e(`ULID_BYTES_TOO_SHORT`,`Byte array must be at least 16 bytes`);let n=0;for(let e=0;e<6;e+=1)n=n*256+t[e];return l(n)+u(t.subarray(6,16))}const m=/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i,h={msecs:-1/0,lastRandom:new Uint8Array(10)};function g(t,n,r,a=0){if(!r)r=new Uint8Array(16),a=0;else if(a<0||a+16>r.length)throw new e(`ULID_BUFFER_OUT_OF_BOUNDS`,`ULID byte range ${a}:${a+15} is out of buffer bounds`);i(r,a,t);for(let e=0;e<10;e+=1)r[a+6+e]=n[e];return r}function _(e,n,r=0){let i,s,c=Date.now();if(e)if(i=e.msecs??c,e.random){if(e.random.length<10)throw new t(`ULID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 10 for ULID`);s=e.random}else s=o();else i=c,i>h.msecs?(s=o(),h.msecs=i,h.lastRandom.set(s.subarray(0,10))):(a(h.lastRandom),s=h.lastRandom);return n?(g(i,s,n,r),n):l(i)+u(s)}function v(e){return typeof e==`string`&&m.test(e)}const y=Object.assign(_,{toBytes:e=>f(e),fromBytes:e=>p(e),timestamp:e=>d(e.slice(0,10)),isValid:v,NIL:`00000000000000000000000000`,MAX:`7ZZZZZZZZZZZZZZZZZZZZZZZZZ`});export{e as BufferError,t as InvalidInputError,n as ParseError,r as UniqueIdError,y as ulid};
+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{r as a,t as o}from"../bytes-NRtBOHK5.mjs";const s=`0123456789ABCDEFGHJKMNPQRSTVWXYZ`,c=new Uint8Array(65536);c.fill(255);for(let e=0;e<32;e+=1){let t=s.charCodeAt(e),n=s[e].toLowerCase().charCodeAt(0);c[t]=e,c[n]=e}function l(e,t){return new r(`ULID_INVALID_CHAR`,`Invalid ULID character: ${e[t]}`)}function u(){return new r(`ULID_TIMESTAMP_OVERFLOW`,`ULID timestamp exceeds 48 bits`)}function d(e){let t=c[e.charCodeAt(0)];if(t===255)throw l(e,0);if(t>7)throw u();let n=t;for(let t=1;t<10;t+=1){let r=c[e.charCodeAt(t)];if(r===255)throw l(e,t);n=n*32+r}return n}function f(e){return s[Math.floor(e/35184372088832)&31]+s[Math.floor(e/1099511627776)&31]+s[Math.floor(e/34359738368)&31]+s[Math.floor(e/1073741824)&31]+s[Math.floor(e/33554432)&31]+s[Math.floor(e/1048576)&31]+s[Math.floor(e/32768)&31]+s[Math.floor(e/1024)&31]+s[Math.floor(e/32)&31]+s[e&31]}function p(e){return s[e[0]>>3&31]+s[(e[0]<<2|e[1]>>6)&31]+s[e[1]>>1&31]+s[(e[1]<<4|e[2]>>4)&31]+s[(e[2]<<1|e[3]>>7)&31]+s[e[3]>>2&31]+s[(e[3]<<3|e[4]>>5)&31]+s[e[4]&31]+s[e[5]>>3&31]+s[(e[5]<<2|e[6]>>6)&31]+s[e[6]>>1&31]+s[(e[6]<<4|e[7]>>4)&31]+s[(e[7]<<1|e[8]>>7)&31]+s[e[8]>>2&31]+s[(e[8]<<3|e[9]>>5)&31]+s[e[9]&31]}function m(e){if(e.length!==26)throw new r(`ULID_INVALID_LENGTH`,`ULID string must be 26 characters`);return d(e)}function h(e){if(e.length!==26)throw new r(`ULID_INVALID_LENGTH`,`ULID string must be 26 characters`);let t=new Uint8Array(16),n=c[e.charCodeAt(0)],i=c[e.charCodeAt(1)],a=c[e.charCodeAt(2)],o=c[e.charCodeAt(3)],s=c[e.charCodeAt(4)],d=c[e.charCodeAt(5)],f=c[e.charCodeAt(6)],p=c[e.charCodeAt(7)],m=c[e.charCodeAt(8)],h=c[e.charCodeAt(9)],g=c[e.charCodeAt(10)],_=c[e.charCodeAt(11)],v=c[e.charCodeAt(12)],y=c[e.charCodeAt(13)],b=c[e.charCodeAt(14)],x=c[e.charCodeAt(15)],S=c[e.charCodeAt(16)],C=c[e.charCodeAt(17)],w=c[e.charCodeAt(18)],T=c[e.charCodeAt(19)],E=c[e.charCodeAt(20)],D=c[e.charCodeAt(21)],O=c[e.charCodeAt(22)],k=c[e.charCodeAt(23)],A=c[e.charCodeAt(24)],j=c[e.charCodeAt(25)];if((n|i|a|o|s|d|f|p|m|h|g|_|v|y|b|x|S|C|w|T|E|D|O|k|A|j)&128){for(let t=0;t<26;t+=1)if(c[e.charCodeAt(t)]===255)throw l(e,t)}if(n>7)throw u();return t[0]=n<<5|i,t[1]=a<<3|o>>2,t[2]=o<<6|s<<1|d>>4,t[3]=d<<4|f>>1,t[4]=f<<7|p<<2|m>>3,t[5]=m<<5|h,t[6]=g<<3|_>>2,t[7]=_<<6|v<<1|y>>4,t[8]=y<<4|b>>1,t[9]=b<<7|x<<2|S>>3,t[10]=S<<5|C,t[11]=w<<3|T>>2,t[12]=T<<6|E<<1|D>>4,t[13]=D<<4|O>>1,t[14]=O<<7|k<<2|A>>3,t[15]=A<<5|j,t}function g(e){if(e.length<16)throw new t(`ULID_BYTES_TOO_SHORT`,`Byte array must be at least 16 bytes`);let n=0;for(let t=0;t<6;t+=1)n=n*256+e[t];return f(n)+p(e.subarray(6,16))}const _=/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i,v={msecs:-1/0,lastRandom:new Uint8Array(10)};function y(e,n,r,i=0){if(!r)r=new Uint8Array(16),i=0;else if(i<0||i+16>r.length)throw new t(`ULID_BUFFER_OUT_OF_BOUNDS`,`ULID byte range ${i}:${i+15} is out of buffer bounds`);a(r,i,e);for(let e=0;e<10;e+=1)r[i+6+e]=n[e];return r}function b(t,r,i=0){let a,s,c=Date.now();if(t)if(a=t.msecs??c,t.random){if(t.random.length<10)throw new n(`ULID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 10 for ULID`);s=t.random}else s=e();else if(a=c,a>v.msecs)s=e(),v.msecs=a,v.lastRandom.set(s.subarray(0,10));else{if(a=v.msecs,!o(v.lastRandom))throw v.lastRandom.fill(255),new n(`ULID_RANDOM_OVERFLOW`,`ULID random component overflowed while preserving monotonic order`);s=v.lastRandom}return r?(y(a,s,r,i),r):f(a)+p(s)}function x(e){return typeof e==`string`&&_.test(e)}const S=Object.assign(b,{toBytes:e=>h(e),fromBytes:e=>g(e),timestamp:e=>m(e),isValid:x,NIL:`00000000000000000000000000`,MAX:`7ZZZZZZZZZZZZZZZZZZZZZZZZZ`});export{t as BufferError,n as InvalidInputError,r as ParseError,i as UniqueIdError,S as ulid};
 //# sourceMappingURL=ulid.mjs.map

package/build/ulid/ulid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ulid.mjs","names":["state: UlidState","time: number","random: Uint8Array","ulid: Ulid"],"sources":["../../src/ulid/crockford.ts","../../src/ulid/ulid.ts"],"sourcesContent":["/**\n * Crockford's Base32 encoding/decoding for ULID.\n * Alphabet excludes I, L, O, U to avoid confusion with similar-looking characters.\n */\n\nimport { BufferError, ParseError } from '../errors'\n\nconst ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\n// Pre-computed decoding table indexed by ASCII code (0-127)\n// Uses Uint8Array for cache-efficient lookups via charCodeAt\nconst DECODING = new Uint8Array(128)\nDECODING.fill(255) // 255 = invalid marker\nfor (let i = 0; i < ENCODING.length; i += 1) {\n  const upper = ENCODING.charCodeAt(i)\n  const lower = ENCODING[i].toLowerCase().charCodeAt(0)\n  DECODING[upper] = i\n  DECODING[lower] = i\n}\n\nconst TIME_LEN = 10\n\n/**\n * Encode a 48-bit timestamp to a 10-character Crockford Base32 string.\n * Uses unrolled division for performance.\n */\nexport function encodeTime(time: number): string {\n  // Unrolled encoding - each step divides by 32 and extracts 5 bits\n  // Powers of 32: 32^9=0x200000000000, 32^8=0x10000000000, etc.\n  return (\n    ENCODING[Math.floor(time / 0x200000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x10000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x800000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x40000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x2000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x100000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x8000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x400) & 0x1f] +\n    ENCODING[Math.floor(time / 0x20) & 0x1f] +\n    ENCODING[time & 0x1f]\n  )\n}\n\n/**\n * Encode 10 bytes (80 bits) of random data to a 16-character Crockford Base32 string.\n */\nexport function encodeRandom(bytes: Uint8Array): string {\n  // Each character encodes 5 bits. 80 bits = 16 characters.\n  // Single concatenation expression for optimal performance.\n  return (\n    ENCODING[(bytes[0] >> 3) & 0x1f] +\n    ENCODING[((bytes[0] << 2) | (bytes[1] >> 6)) & 0x1f] +\n    ENCODING[(bytes[1] >> 1) & 0x1f] +\n    ENCODING[((bytes[1] << 4) | (bytes[2] >> 4)) & 0x1f] +\n    ENCODING[((bytes[2] << 1) | (bytes[3] >> 7)) & 0x1f] +\n    ENCODING[(bytes[3] >> 2) & 0x1f] +\n    ENCODING[((bytes[3] << 3) | (bytes[4] >> 5)) & 0x1f] +\n    ENCODING[bytes[4] & 0x1f] +\n    ENCODING[(bytes[5] >> 3) & 0x1f] +\n    ENCODING[((bytes[5] << 2) | (bytes[6] >> 6)) & 0x1f] +\n    ENCODING[(bytes[6] >> 1) & 0x1f] +\n    ENCODING[((bytes[6] << 4) | (bytes[7] >> 4)) & 0x1f] +\n    ENCODING[((bytes[7] << 1) | (bytes[8] >> 7)) & 0x1f] +\n    ENCODING[(bytes[8] >> 2) & 0x1f] +\n    ENCODING[((bytes[8] << 3) | (bytes[9] >> 5)) & 0x1f] +\n    ENCODING[bytes[9] & 0x1f]\n  )\n}\n\n/**\n * Decode the first 10 characters of a ULID string to a timestamp (Unix epoch milliseconds).\n */\nexport function decodeTime(str: string): number {\n  let time = 0\n  for (let i = 0; i < TIME_LEN; i += 1) {\n    const value = DECODING[str.charCodeAt(i)]\n    if (value === 255) {\n      throw new ParseError('ULID_INVALID_CHAR', `Invalid ULID character: ${str[i]}`)\n    }\n    time = time * 32 + value\n  }\n  return time\n}\n\n/**\n * Decode a 26-character ULID string to 16 bytes.\n * Inlines all lookups to avoid intermediate array allocation.\n */\nexport function decodeToBytes(str: string): Uint8Array {\n  if (str.length !== 26) {\n    throw new ParseError('ULID_INVALID_LENGTH', 'ULID string must be 26 characters')\n  }\n\n  const bytes = new Uint8Array(16)\n\n  // Inline all 26 character lookups\n  const v0 = DECODING[str.charCodeAt(0)]\n  const v1 = DECODING[str.charCodeAt(1)]\n  const v2 = DECODING[str.charCodeAt(2)]\n  const v3 = DECODING[str.charCodeAt(3)]\n  const v4 = DECODING[str.charCodeAt(4)]\n  const v5 = DECODING[str.charCodeAt(5)]\n  const v6 = DECODING[str.charCodeAt(6)]\n  const v7 = DECODING[str.charCodeAt(7)]\n  const v8 = DECODING[str.charCodeAt(8)]\n  const v9 = DECODING[str.charCodeAt(9)]\n  const v10 = DECODING[str.charCodeAt(10)]\n  const v11 = DECODING[str.charCodeAt(11)]\n  const v12 = DECODING[str.charCodeAt(12)]\n  const v13 = DECODING[str.charCodeAt(13)]\n  const v14 = DECODING[str.charCodeAt(14)]\n  const v15 = DECODING[str.charCodeAt(15)]\n  const v16 = DECODING[str.charCodeAt(16)]\n  const v17 = DECODING[str.charCodeAt(17)]\n  const v18 = DECODING[str.charCodeAt(18)]\n  const v19 = DECODING[str.charCodeAt(19)]\n  const v20 = DECODING[str.charCodeAt(20)]\n  const v21 = DECODING[str.charCodeAt(21)]\n  const v22 = DECODING[str.charCodeAt(22)]\n  const v23 = DECODING[str.charCodeAt(23)]\n  const v24 = DECODING[str.charCodeAt(24)]\n  const v25 = DECODING[str.charCodeAt(25)]\n\n  // Validate all characters (255 = invalid marker)\n  if (\n    (v0 |\n      v1 |\n      v2 |\n      v3 |\n      v4 |\n      v5 |\n      v6 |\n      v7 |\n      v8 |\n      v9 |\n      v10 |\n      v11 |\n      v12 |\n      v13 |\n      v14 |\n      v15 |\n      v16 |\n      v17 |\n      v18 |\n      v19 |\n      v20 |\n      v21 |\n      v22 |\n      v23 |\n      v24 |\n      v25) &\n    0x80\n  ) {\n    // Find the invalid character for error message\n    for (let i = 0; i < 26; i += 1) {\n      if (DECODING[str.charCodeAt(i)] === 255) {\n        throw new ParseError('ULID_INVALID_CHAR', `Invalid ULID character: ${str[i]}`)\n      }\n    }\n  }\n\n  // Timestamp: first 10 characters -> bytes 0-5\n  bytes[0] = (v0 << 5) | v1\n  bytes[1] = (v2 << 3) | (v3 >> 2)\n  bytes[2] = (v3 << 6) | (v4 << 1) | (v5 >> 4)\n  bytes[3] = (v5 << 4) | (v6 >> 1)\n  bytes[4] = (v6 << 7) | (v7 << 2) | (v8 >> 3)\n  bytes[5] = (v8 << 5) | v9\n\n  // Random: last 16 characters -> bytes 6-15\n  bytes[6] = (v10 << 3) | (v11 >> 2)\n  bytes[7] = (v11 << 6) | (v12 << 1) | (v13 >> 4)\n  bytes[8] = (v13 << 4) | (v14 >> 1)\n  bytes[9] = (v14 << 7) | (v15 << 2) | (v16 >> 3)\n  bytes[10] = (v16 << 5) | v17\n  bytes[11] = (v18 << 3) | (v19 >> 2)\n  bytes[12] = (v19 << 6) | (v20 << 1) | (v21 >> 4)\n  bytes[13] = (v21 << 4) | (v22 >> 1)\n  bytes[14] = (v22 << 7) | (v23 << 2) | (v24 >> 3)\n  bytes[15] = (v24 << 5) | v25\n\n  return bytes\n}\n\n/**\n * Encode 16 bytes to a 26-character ULID string.\n */\nexport function bytesToUlid(bytes: Uint8Array): string {\n  if (bytes.length < 16) {\n    throw new BufferError('ULID_BYTES_TOO_SHORT', 'Byte array must be at least 16 bytes')\n  }\n\n  // Timestamp: bytes 0-5 -> 10 characters\n  let time = 0\n  for (let i = 0; i < 6; i += 1) {\n    time = time * 256 + bytes[i]\n  }\n  const timeStr = encodeTime(time)\n\n  // Random: bytes 6-15 -> 16 characters\n  const randomStr = encodeRandom(bytes.subarray(6, 16))\n\n  return timeStr + randomStr\n}\n","import { incrementBytesInPlace, writeTimestamp48 } from '../common/bytes'\nimport { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { bytesToUlid, decodeTime, decodeToBytes, encodeRandom, encodeTime } from './crockford'\n\nexport type UlidOptions = {\n  /**\n   * 16 bytes of random data to use for ULID generation.\n   * Only the first 10 bytes are used.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in milliseconds since Unix epoch.\n   * Defaults to Date.now().\n   */\n  msecs?: number\n}\n\nexport type Ulid = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: UlidOptions, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil ULID (all zeros) */\n  NIL: string\n  /** The max ULID (maximum valid value) */\n  MAX: string\n}\n\n// Validation regex: first char [0-7] to prevent overflow, rest from Crockford alphabet\nconst ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i\n\ntype UlidState = {\n  msecs: number\n  lastRandom: Uint8Array\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all ulid() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `random` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: UlidState = {\n  msecs: -Infinity,\n  lastRandom: new Uint8Array(10),\n}\n\nfunction ulidBytes(time: number, random: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (!buf) {\n    buf = new Uint8Array(16)\n    offset = 0\n  } else if (offset < 0 || offset + 16 > buf.length) {\n    throw new BufferError(\n      'ULID_BUFFER_OUT_OF_BOUNDS',\n      `ULID byte range ${offset}:${offset + 15} is out of buffer bounds`,\n    )\n  }\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch) -> bytes 0-5\n  writeTimestamp48(buf, offset, time)\n\n  // Random (80 bits) -> bytes 6-15\n  for (let i = 0; i < 10; i += 1) {\n    buf[offset + 6 + i] = random[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a ULID string.\n */\nfunction ulidFn(options?: UlidOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with ULID bytes.\n */\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: UlidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf?: TBuf, offset = 0): string | TBuf {\n  let time: number\n  let random: Uint8Array\n\n  /**\n   * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n   * side-channel attacks. This means that Date.now() will return the same value for the entire\n   * duration of a request.\n   * Implications:\n   * - all ULIDs generated within a single request will have the same timestamp.\n   * - the monotonic ordering will rely entirely on incrementing the random portion.\n   */\n  const defaultTime = Date.now()\n\n  if (options) {\n    // Explicit options provided - use them directly without monotonic state\n    time = options.msecs ?? defaultTime\n    if (options.random) {\n      if (options.random.length < 10) {\n        throw new InvalidInputError('ULID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 10 for ULID')\n      }\n      random = options.random\n    } else {\n      random = rng()\n    }\n  } else {\n    time = defaultTime\n\n    if (time > state.msecs) {\n      // New millisecond: generate fresh random\n      random = rng()\n      state.msecs = time\n      state.lastRandom.set(random.subarray(0, 10))\n    } else {\n      // Same millisecond: increment random portion for monotonic ordering\n      incrementBytesInPlace(state.lastRandom)\n      random = state.lastRandom\n    }\n  }\n\n  if (buf) {\n    ulidBytes(time, random, buf, offset)\n    return buf\n  }\n\n  // String mode: encode directly without buffer allocation\n  return encodeTime(time) + encodeRandom(random)\n}\n\n/**\n * Generate a ULID string or write the bytes into a buffer.\n *\n * ULID (Universally Unique Lexicographically Sortable Identifier) is a 128-bit\n * identifier with millisecond timestamp precision and 80 bits of randomness.\n * ULIDs are URL-safe, use Crockford's Base32 encoding, and sort lexicographically\n * by creation time.\n *\n * @example\n * ```ts\n * import { ulid } from 'uniku/ulid'\n *\n * const id = ulid()\n * // => \"01HW9T2W9W9YJ3JZ1H4P4M2T8Q\"\n *\n * // Extract timestamp\n * const ts = ulid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * ulid.isValid(id) // true\n *\n * // Convert to/from bytes (16 bytes)\n * const bytes = ulid.toBytes(id)\n * const restored = ulid.fromBytes(bytes)\n * ```\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && ULID_REGEX.test(id)\n}\n\nexport const ulid: Ulid = Object.assign(ulidFn, {\n  toBytes: (id: string) => decodeToBytes(id),\n  fromBytes: (bytes: Uint8Array) => bytesToUlid(bytes),\n  timestamp: (id: string) => decodeTime(id.slice(0, 10)),\n  isValid,\n  NIL: '00000000000000000000000000',\n  MAX: '7ZZZZZZZZZZZZZZZZZZZZZZZZZ',\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"ulid.mjs","names":["state: UlidState","time: number","random: Uint8Array","ulid: Ulid"],"sources":["../../src/ulid/crockford.ts","../../src/ulid/ulid.ts"],"sourcesContent":["/**\n * Crockford's Base32 encoding/decoding for ULID.\n * Alphabet excludes I, L, O, U to avoid confusion with similar-looking characters.\n */\n\nimport { BufferError, ParseError } from '../errors'\n\nconst ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\n// Pre-computed decoding table covering every UTF-16 code unit charCodeAt can\n// return, so lookups never go out of bounds and a single `=== 255` check\n// rejects invalid input (including non-ASCII) without a per-character range\n// check. Costs 64 KiB once at module load; valid inputs only touch the first\n// 128 bytes, so cache behavior is unaffected.\nconst DECODING = new Uint8Array(65536)\nDECODING.fill(255) // 255 = invalid marker\nfor (let i = 0; i < ENCODING.length; i += 1) {\n  const upper = ENCODING.charCodeAt(i)\n  const lower = ENCODING[i].toLowerCase().charCodeAt(0)\n  DECODING[upper] = i\n  DECODING[lower] = i\n}\n\nconst TIME_LEN = 10\nconst ULID_LEN = 26\n\nfunction invalidCharError(str: string, index: number): ParseError {\n  return new ParseError('ULID_INVALID_CHAR', `Invalid ULID character: ${str[index]}`)\n}\n\nfunction timestampOverflowError(): ParseError {\n  return new ParseError('ULID_TIMESTAMP_OVERFLOW', 'ULID timestamp exceeds 48 bits')\n}\n\nfunction decodeTimeChars(str: string): number {\n  const firstValue = DECODING[str.charCodeAt(0)]\n  if (firstValue === 255) {\n    throw invalidCharError(str, 0)\n  }\n\n  if (firstValue > 7) {\n    throw timestampOverflowError()\n  }\n\n  let time = firstValue\n  for (let i = 1; i < TIME_LEN; i += 1) {\n    const value = DECODING[str.charCodeAt(i)]\n    if (value === 255) {\n      throw invalidCharError(str, i)\n    }\n\n    time = time * 32 + value\n  }\n  return time\n}\n\n/**\n * Encode a 48-bit timestamp to a 10-character Crockford Base32 string.\n * Uses unrolled division for performance.\n */\nexport function encodeTime(time: number): string {\n  // Unrolled encoding - each step divides by 32 and extracts 5 bits\n  // Powers of 32: 32^9=0x200000000000, 32^8=0x10000000000, etc.\n  return (\n    ENCODING[Math.floor(time / 0x200000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x10000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x800000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x40000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x2000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x100000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x8000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x400) & 0x1f] +\n    ENCODING[Math.floor(time / 0x20) & 0x1f] +\n    ENCODING[time & 0x1f]\n  )\n}\n\n/**\n * Encode 10 bytes (80 bits) of random data to a 16-character Crockford Base32 string.\n */\nexport function encodeRandom(bytes: Uint8Array): string {\n  // Each character encodes 5 bits. 80 bits = 16 characters.\n  // Single concatenation expression for optimal performance.\n  return (\n    ENCODING[(bytes[0] >> 3) & 0x1f] +\n    ENCODING[((bytes[0] << 2) | (bytes[1] >> 6)) & 0x1f] +\n    ENCODING[(bytes[1] >> 1) & 0x1f] +\n    ENCODING[((bytes[1] << 4) | (bytes[2] >> 4)) & 0x1f] +\n    ENCODING[((bytes[2] << 1) | (bytes[3] >> 7)) & 0x1f] +\n    ENCODING[(bytes[3] >> 2) & 0x1f] +\n    ENCODING[((bytes[3] << 3) | (bytes[4] >> 5)) & 0x1f] +\n    ENCODING[bytes[4] & 0x1f] +\n    ENCODING[(bytes[5] >> 3) & 0x1f] +\n    ENCODING[((bytes[5] << 2) | (bytes[6] >> 6)) & 0x1f] +\n    ENCODING[(bytes[6] >> 1) & 0x1f] +\n    ENCODING[((bytes[6] << 4) | (bytes[7] >> 4)) & 0x1f] +\n    ENCODING[((bytes[7] << 1) | (bytes[8] >> 7)) & 0x1f] +\n    ENCODING[(bytes[8] >> 2) & 0x1f] +\n    ENCODING[((bytes[8] << 3) | (bytes[9] >> 5)) & 0x1f] +\n    ENCODING[bytes[9] & 0x1f]\n  )\n}\n\n/**\n * Decode a 10-character ULID timestamp string to Unix epoch milliseconds.\n */\nexport function decodeTime(str: string): number {\n  if (str.length !== TIME_LEN) {\n    throw new ParseError('ULID_INVALID_LENGTH', `ULID timestamp must be ${TIME_LEN} characters`)\n  }\n  return decodeTimeChars(str)\n}\n\n/**\n * Decode the timestamp from a full 26-character ULID string.\n */\nexport function decodeUlidTime(str: string): number {\n  if (str.length !== ULID_LEN) {\n    throw new ParseError('ULID_INVALID_LENGTH', `ULID string must be ${ULID_LEN} characters`)\n  }\n  return decodeTimeChars(str)\n}\n\n/**\n * Decode a 26-character ULID string to 16 bytes.\n * Inlines all lookups to avoid intermediate array allocation.\n */\nexport function decodeToBytes(str: string): Uint8Array {\n  if (str.length !== ULID_LEN) {\n    throw new ParseError('ULID_INVALID_LENGTH', `ULID string must be ${ULID_LEN} characters`)\n  }\n\n  const bytes = new Uint8Array(16)\n\n  // Inline all 26 character lookups\n  const v0 = DECODING[str.charCodeAt(0)]\n  const v1 = DECODING[str.charCodeAt(1)]\n  const v2 = DECODING[str.charCodeAt(2)]\n  const v3 = DECODING[str.charCodeAt(3)]\n  const v4 = DECODING[str.charCodeAt(4)]\n  const v5 = DECODING[str.charCodeAt(5)]\n  const v6 = DECODING[str.charCodeAt(6)]\n  const v7 = DECODING[str.charCodeAt(7)]\n  const v8 = DECODING[str.charCodeAt(8)]\n  const v9 = DECODING[str.charCodeAt(9)]\n  const v10 = DECODING[str.charCodeAt(10)]\n  const v11 = DECODING[str.charCodeAt(11)]\n  const v12 = DECODING[str.charCodeAt(12)]\n  const v13 = DECODING[str.charCodeAt(13)]\n  const v14 = DECODING[str.charCodeAt(14)]\n  const v15 = DECODING[str.charCodeAt(15)]\n  const v16 = DECODING[str.charCodeAt(16)]\n  const v17 = DECODING[str.charCodeAt(17)]\n  const v18 = DECODING[str.charCodeAt(18)]\n  const v19 = DECODING[str.charCodeAt(19)]\n  const v20 = DECODING[str.charCodeAt(20)]\n  const v21 = DECODING[str.charCodeAt(21)]\n  const v22 = DECODING[str.charCodeAt(22)]\n  const v23 = DECODING[str.charCodeAt(23)]\n  const v24 = DECODING[str.charCodeAt(24)]\n  const v25 = DECODING[str.charCodeAt(25)]\n\n  // Validate all characters at once (255 = invalid marker, so any invalid\n  // character sets the 0x80 bit in the OR of all values)\n  if (\n    ((v0 |\n      v1 |\n      v2 |\n      v3 |\n      v4 |\n      v5 |\n      v6 |\n      v7 |\n      v8 |\n      v9 |\n      v10 |\n      v11 |\n      v12 |\n      v13 |\n      v14 |\n      v15 |\n      v16 |\n      v17 |\n      v18 |\n      v19 |\n      v20 |\n      v21 |\n      v22 |\n      v23 |\n      v24 |\n      v25) &\n      0x80) !==\n    0\n  ) {\n    // Find the invalid character for error message\n    for (let i = 0; i < ULID_LEN; i += 1) {\n      if (DECODING[str.charCodeAt(i)] === 255) {\n        throw invalidCharError(str, i)\n      }\n    }\n  }\n\n  if (v0 > 7) {\n    throw timestampOverflowError()\n  }\n\n  // Timestamp: first 10 characters -> bytes 0-5\n  bytes[0] = (v0 << 5) | v1\n  bytes[1] = (v2 << 3) | (v3 >> 2)\n  bytes[2] = (v3 << 6) | (v4 << 1) | (v5 >> 4)\n  bytes[3] = (v5 << 4) | (v6 >> 1)\n  bytes[4] = (v6 << 7) | (v7 << 2) | (v8 >> 3)\n  bytes[5] = (v8 << 5) | v9\n\n  // Random: last 16 characters -> bytes 6-15\n  bytes[6] = (v10 << 3) | (v11 >> 2)\n  bytes[7] = (v11 << 6) | (v12 << 1) | (v13 >> 4)\n  bytes[8] = (v13 << 4) | (v14 >> 1)\n  bytes[9] = (v14 << 7) | (v15 << 2) | (v16 >> 3)\n  bytes[10] = (v16 << 5) | v17\n  bytes[11] = (v18 << 3) | (v19 >> 2)\n  bytes[12] = (v19 << 6) | (v20 << 1) | (v21 >> 4)\n  bytes[13] = (v21 << 4) | (v22 >> 1)\n  bytes[14] = (v22 << 7) | (v23 << 2) | (v24 >> 3)\n  bytes[15] = (v24 << 5) | v25\n\n  return bytes\n}\n\n/**\n * Encode 16 bytes to a 26-character ULID string.\n */\nexport function bytesToUlid(bytes: Uint8Array): string {\n  if (bytes.length < 16) {\n    throw new BufferError('ULID_BYTES_TOO_SHORT', 'Byte array must be at least 16 bytes')\n  }\n\n  // Timestamp: bytes 0-5 -> 10 characters\n  let time = 0\n  for (let i = 0; i < 6; i += 1) {\n    time = time * 256 + bytes[i]\n  }\n  const timeStr = encodeTime(time)\n\n  // Random: bytes 6-15 -> 16 characters\n  const randomStr = encodeRandom(bytes.subarray(6, 16))\n\n  return timeStr + randomStr\n}\n","import { incrementBytesInPlace, writeTimestamp48 } from '../common/bytes'\nimport { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { bytesToUlid, decodeToBytes, decodeUlidTime, encodeRandom, encodeTime } from './crockford'\n\nexport type UlidOptions = {\n  /**\n   * 16 bytes of random data to use for ULID generation.\n   * Only the first 10 bytes are used.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in milliseconds since Unix epoch.\n   * Defaults to Date.now().\n   */\n  msecs?: number\n}\n\nexport type Ulid = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: UlidOptions, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil ULID (all zeros) */\n  NIL: string\n  /** The max ULID (maximum valid value) */\n  MAX: string\n}\n\n// Validation regex: first char [0-7] to prevent overflow, rest from Crockford alphabet\nconst ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i\n\ntype UlidState = {\n  msecs: number\n  lastRandom: Uint8Array\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all ulid() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `random` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: UlidState = {\n  msecs: -Infinity,\n  lastRandom: new Uint8Array(10),\n}\n\nfunction ulidBytes(time: number, random: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (!buf) {\n    buf = new Uint8Array(16)\n    offset = 0\n  } else if (offset < 0 || offset + 16 > buf.length) {\n    throw new BufferError(\n      'ULID_BUFFER_OUT_OF_BOUNDS',\n      `ULID byte range ${offset}:${offset + 15} is out of buffer bounds`,\n    )\n  }\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch) -> bytes 0-5\n  writeTimestamp48(buf, offset, time)\n\n  // Random (80 bits) -> bytes 6-15\n  for (let i = 0; i < 10; i += 1) {\n    buf[offset + 6 + i] = random[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a ULID string.\n */\nfunction ulidFn(options?: UlidOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with ULID bytes.\n */\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: UlidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf?: TBuf, offset = 0): string | TBuf {\n  let time: number\n  let random: Uint8Array\n\n  /**\n   * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n   * side-channel attacks. This means that Date.now() will return the same value for the entire\n   * duration of a request.\n   * Implications:\n   * - all ULIDs generated within a single request will have the same timestamp.\n   * - the monotonic ordering will rely entirely on incrementing the random portion.\n   */\n  const defaultTime = Date.now()\n\n  if (options) {\n    // Explicit options provided - use them directly without monotonic state\n    time = options.msecs ?? defaultTime\n    if (options.random) {\n      if (options.random.length < 10) {\n        throw new InvalidInputError('ULID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 10 for ULID')\n      }\n      random = options.random\n    } else {\n      random = rng()\n    }\n  } else {\n    time = defaultTime\n\n    if (time > state.msecs) {\n      // New millisecond: generate fresh random\n      random = rng()\n      state.msecs = time\n      state.lastRandom.set(random.subarray(0, 10))\n    } else {\n      // Same millisecond or clock rollback: preserve last timestamp and increment random portion.\n      time = state.msecs\n      if (!incrementBytesInPlace(state.lastRandom)) {\n        state.lastRandom.fill(0xff)\n        throw new InvalidInputError(\n          'ULID_RANDOM_OVERFLOW',\n          'ULID random component overflowed while preserving monotonic order',\n        )\n      }\n      random = state.lastRandom\n    }\n  }\n\n  if (buf) {\n    ulidBytes(time, random, buf, offset)\n    return buf\n  }\n\n  // String mode: encode directly without buffer allocation\n  return encodeTime(time) + encodeRandom(random)\n}\n\n/**\n * Generate a ULID string or write the bytes into a buffer.\n *\n * ULID (Universally Unique Lexicographically Sortable Identifier) is a 128-bit\n * identifier with millisecond timestamp precision and 80 bits of randomness.\n * ULIDs are URL-safe, use Crockford's Base32 encoding, and sort lexicographically\n * by creation time.\n *\n * @example\n * ```ts\n * import { ulid } from 'uniku/ulid'\n *\n * const id = ulid()\n * // => \"01HW9T2W9W9YJ3JZ1H4P4M2T8Q\"\n *\n * // Extract timestamp\n * const ts = ulid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * ulid.isValid(id) // true\n *\n * // Convert to/from bytes (16 bytes)\n * const bytes = ulid.toBytes(id)\n * const restored = ulid.fromBytes(bytes)\n * ```\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && ULID_REGEX.test(id)\n}\n\nexport const ulid: Ulid = Object.assign(ulidFn, {\n  toBytes: (id: string) => decodeToBytes(id),\n  fromBytes: (bytes: Uint8Array) => bytesToUlid(bytes),\n  timestamp: (id: string) => decodeUlidTime(id),\n  isValid,\n  NIL: '00000000000000000000000000',\n  MAX: '7ZZZZZZZZZZZZZZZZZZZZZZZZZ',\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/uuid/v4.mjs

@@ -1,2 +1,2 @@
-import{BufferError as e,InvalidInputError as t,ParseError as n,UniqueIdError as r}from"../errors.mjs";import{t as i}from"../random-DcKA4vF7.mjs";import{n as a,t as o}from"../uuid-QysI8pWE.mjs";const s=globalThis.crypto.randomUUID.bind(globalThis.crypto),c=/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;function l(n,r,i=0){if(n.length<16)throw new t(`UUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`);if(n[6]=n[6]&15|64,n[8]=n[8]&63|128,!r)return n;if(i<0||i+16>r.length)throw new e(`UUID_BUFFER_OUT_OF_BOUNDS`,`UUID byte range ${i}:${i+15} is out of buffer bounds`);for(let e=0;e<16;e+=1)r[i+e]=n[e];return r}function u(e,t,n){return!t&&!e?s():d(e,t,n)}function d(e,t,n){let r=l(e?.random??i(),t,n);return t??o(r)}function f(e){return typeof e==`string`&&c.test(e)}const p=Object.assign(u,{toBytes:a,fromBytes:o,isValid:f,NIL:`00000000-0000-0000-0000-000000000000`,MAX:`ffffffff-ffff-ffff-ffff-ffffffffffff`});export{e as BufferError,t as InvalidInputError,n as ParseError,r as UniqueIdError,p as uuidv4};
+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=globalThis.crypto.randomUUID.bind(globalThis.crypto),c=/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;function l(e,r,i=0){if(e.length<16)throw new n(`UUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`);if(e[6]=e[6]&15|64,e[8]=e[8]&63|128,!r)return e;if(i<0||i+16>r.length)throw new t(`UUID_BUFFER_OUT_OF_BOUNDS`,`UUID byte range ${i}:${i+15} is out of buffer bounds`);for(let t=0;t<16;t+=1)r[i+t]=e[t];return r}function u(e,t,n){return!t&&!e?s():d(e,t,n)}function d(t,n,r){let i=l(t?.random??e(),n,r);return n??o(i)}function f(e){return typeof e==`string`&&c.test(e)}const p=Object.assign(u,{toBytes:a,fromBytes:o,isValid:f,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,p as uuidv4};
 //# sourceMappingURL=v4.mjs.map

package/build/uuid/v7.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"v7.d.mts","names":["uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":[],"mappings":";;;KAIY,aAAA;;;AAAZ;AAUA;EAEgB,MAAA,CAAA,EAPL,UAOK;EAAa,KAAA,CAAA,EAAA,MAAA;EAAqB,GAAA,CAAA,EAAA,MAAA;CAAgC;AAAwB,KAF9F,MAAA,GAE8F;EAC7F,EAAA,EAAA,MAAA;EACU,CAAA,aAFP,UAEO,GAFM,UAEN,CAAA,CAAA,OAAA,EAF2B,aAE3B,GAAA,SAAA,EAAA,GAAA,EAF2D,IAE3D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAFmF,IAEnF;EACJ,CAAA,OAAA,CAAA,EAFN,aAEM,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,OAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EADI,UACJ;EAwJnB,SAAaA,CAAAA,KAAQ,EAxJF,UAwJE,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAARA,QAAQ"}
+{"version":3,"file":"v7.d.mts","names":["uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":[],"mappings":";;;KAIY,aAAA;;;AAAZ;AAUA;EAEgB,MAAA,CAAA,EAPL,UAOK;EAAa,KAAA,CAAA,EAAA,MAAA;EAAqB,GAAA,CAAA,EAAA,MAAA;CAAgC;AAAwB,KAF9F,MAAA,GAE8F;EAC7F,EAAA,EAAA,MAAA;EACU,CAAA,aAFP,UAEO,GAFM,UAEN,CAAA,CAAA,OAAA,EAF2B,aAE3B,GAAA,SAAA,EAAA,GAAA,EAF2D,IAE3D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAFmF,IAEnF;EACJ,CAAA,OAAA,CAAA,EAFN,aAEM,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,OAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EADI,UACJ;EAyJnB,SAAaA,CAAAA,KAAQ,EAzJF,UAyJE,CAAA,EAAA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAARA,QAAQ"}

package/build/uuid/v7.mjs

@@ -1,2 +1,2 @@
-import{BufferError as e,InvalidInputError as t,ParseError as n,UniqueIdError as r}from"../errors.mjs";import{t as i}from"../random-DcKA4vF7.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(n,r,i,a,o=0){if(n.length<16)throw new t(`UUID_RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`);if(o<0||o+16>a.length)throw new e(`UUID_BUFFER_OUT_OF_BOUNDS`,`UUID byte range ${o}:${o+15} is out of buffer bounds`);return r??=Date.now(),i??=n[6]<<23|n[7]<<16|n[8]<<8|n[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|n[10]&3,a[o++]=n[11],a[o++]=n[12],a[o++]=n[13],a[o++]=n[14],a[o++]=n[15],a}function d(e,t,n){let r;if(e)r=u(e.random??i(),e.msecs,e.seq,t??c,t?n:0);else{let e=Date.now(),a=i();e>l.msecs?(l.seq=a[6]<<23|a[7]<<16|a[8]<<8|a[9],l.msecs=e):(l.seq=l.seq+1|0,l.seq===0&&l.msecs++),r=u(a,l.msecs,l.seq,t??c,t?n:0)}return t?r:o(r)}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{e as BufferError,t as InvalidInputError,n as ParseError,r as UniqueIdError,m as uuidv7};
+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};
 //# sourceMappingURL=v7.mjs.map

package/build/uuid/v7.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"v7.mjs","names":["state: V7State","bytes: Uint8Array","uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":["import { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type UuidV7Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Several bytes will be overwritten with timestamp, version, and variant data.\n   */\n  random?: Uint8Array\n  msecs?: number\n  seq?: number\n}\n\nexport type UuidV7 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: UuidV7Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil UUID (all zeros) */\n  NIL: string\n  /** The max UUID (all ones) */\n  MAX: string\n}\n\nconst UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n\n// Reusable buffer for string output path - avoids allocation per call.\n// Safe because bytes are consumed synchronously by formatUuid().\nconst reusableBuf = new Uint8Array(16)\n\ntype V7State = {\n  msecs: number\n  seq: number\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all uuidv7() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `seq` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: V7State = { msecs: -Infinity, seq: 0 }\n\nfunction v7Bytes(\n  rnds: Uint8Array,\n  msecs: number | undefined,\n  seq: number | undefined,\n  buf: Uint8Array,\n  offset = 0,\n): Uint8Array {\n  if (rnds.length < 16) {\n    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16')\n  }\n\n  if (offset < 0 || offset + 16 > buf.length) {\n    throw new BufferError(\n      'UUID_BUFFER_OUT_OF_BOUNDS',\n      `UUID byte range ${offset}:${offset + 15} is out of buffer bounds`,\n    )\n  }\n\n  msecs ??= Date.now()\n  // Derive a 31-bit sequence if not provided by the caller.\n  // Uses same formula as hot path (line 130) for consistency.\n  seq ??= (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch).\n  // byte 0-5: timestamp (48 bits)\n  buf[offset++] = (msecs / 0x10000000000) & 0xff\n  buf[offset++] = (msecs / 0x100000000) & 0xff\n  buf[offset++] = (msecs / 0x1000000) & 0xff\n  buf[offset++] = (msecs / 0x10000) & 0xff\n  buf[offset++] = (msecs / 0x100) & 0xff\n  buf[offset++] = msecs & 0xff\n\n  // Set version (7) and variant (10xx), then pack sequence and random tail bytes.\n  buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f)\n  buf[offset++] = (seq >>> 20) & 0xff\n  buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f)\n  buf[offset++] = (seq >>> 6) & 0xff\n  // Lower seq bits plus 2 random bits to complete the 128-bit payload.\n  buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03)\n  buf[offset++] = rnds[11]\n  buf[offset++] = rnds[12]\n  buf[offset++] = rnds[13]\n  buf[offset++] = rnds[14]\n  buf[offset++] = rnds[15]\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v7(options?: UuidV7Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v7<TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf\nfunction v7<TBuf extends Uint8Array = Uint8Array>(options?: UuidV7Options, buf?: TBuf, offset?: number): string | TBuf {\n  let bytes: Uint8Array\n\n  if (options) {\n    bytes = v7Bytes(options.random ?? rng(), options.msecs, options.seq, buf ?? reusableBuf, buf ? offset : 0)\n  } else {\n    // HOT PATH: Inline state management and byte generation for best performance\n    const now = Date.now()\n    const rnds = rng()\n\n    // Update state (inlined for performance)\n    if (now > state.msecs) {\n      state.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n      state.msecs = now\n    } else {\n      state.seq = (state.seq + 1) | 0\n      if (state.seq === 0) {\n        state.msecs++\n      }\n    }\n\n    bytes = v7Bytes(rnds, state.msecs, state.seq, buf ?? reusableBuf, buf ? offset : 0)\n  }\n\n  return buf ? (bytes as TBuf) : formatUuid(bytes)\n}\n\nfunction timestamp(id: string): number {\n  const bytes = parseUuid(id)\n  let msecs = 0\n  for (let i = 0; i < 6; i += 1) {\n    msecs = msecs * 256 + bytes[i]\n  }\n  return msecs\n}\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && UUID_V7_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v7 string or write the bytes into a buffer.\n *\n * UUID v7 is a time-ordered UUID that embeds a Unix timestamp in milliseconds,\n * making IDs naturally sortable by creation time. Ideal for database primary keys\n * where chronological ordering improves index performance.\n *\n * @example\n * ```ts\n * import { uuidv7 } from 'uniku/uuid/v7'\n *\n * const id = uuidv7()\n * // => \"018e5e5c-7c8a-7000-8000-000000000000\"\n *\n * // Extract timestamp\n * const ts = uuidv7.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * uuidv7.isValid(id) // true\n *\n * // Convert to/from bytes\n * const bytes = uuidv7.toBytes(id)\n * const restored = uuidv7.fromBytes(bytes)\n * ```\n */\nexport const uuidv7: UuidV7 = Object.assign(v7, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\n  timestamp,\n  isValid,\n  NIL: '00000000-0000-0000-0000-000000000000',\n  MAX: 'ffffffff-ffff-ffff-ffff-ffffffffffff',\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"iMA4BA,MAAM,EAAgB,yEAIhB,EAAc,IAAI,WAAW,GAAG,CAehCA,EAAiB,CAAE,MAAO,KAAW,IAAK,EAAG,CAEnD,SAAS,EACP,EACA,EACA,EACA,EACA,EAAS,EACG,CACZ,GAAI,EAAK,OAAS,GAChB,MAAM,IAAI,EAAkB,8BAA+B,oCAAoC,CAGjG,GAAI,EAAS,GAAK,EAAS,GAAK,EAAI,OAClC,MAAM,IAAI,EACR,4BACA,mBAAmB,EAAO,GAAG,EAAS,GAAG,0BAC1C,CA8BH,MA3BA,KAAU,KAAK,KAAK,CAGpB,IAAS,EAAK,IAAM,GAAO,EAAK,IAAM,GAAO,EAAK,IAAM,EAAK,EAAK,GAIlE,EAAI,KAAa,EAAQ,cAAiB,IAC1C,EAAI,KAAa,EAAQ,WAAe,IACxC,EAAI,KAAa,EAAQ,SAAa,IACtC,EAAI,KAAa,EAAQ,MAAW,IACpC,EAAI,KAAa,EAAQ,IAAS,IAClC,EAAI,KAAY,EAAQ,IAGxB,EAAI,KAAY,IAAS,IAAQ,GAAM,GACvC,EAAI,KAAa,IAAQ,GAAM,IAC/B,EAAI,KAAY,IAAS,IAAQ,GAAM,GACvC,EAAI,KAAa,IAAQ,EAAK,IAE9B,EAAI,KAAc,GAAO,EAAK,IAAS,EAAK,IAAM,EAClD,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IAEd,EAWT,SAAS,EAAyC,EAAyB,EAAY,EAAgC,CACrH,IAAIC,EAEJ,GAAI,EACF,EAAQ,EAAQ,EAAQ,QAAU,GAAK,CAAE,EAAQ,MAAO,EAAQ,IAAK,GAAO,EAAa,EAAM,EAAS,EAAE,KACrG,CAEL,IAAM,EAAM,KAAK,KAAK,CAChB,EAAO,GAAK,CAGd,EAAM,EAAM,OACd,EAAM,IAAO,EAAK,IAAM,GAAO,EAAK,IAAM,GAAO,EAAK,IAAM,EAAK,EAAK,GACtE,EAAM,MAAQ,IAEd,EAAM,IAAO,EAAM,IAAM,EAAK,EAC1B,EAAM,MAAQ,GAChB,EAAM,SAIV,EAAQ,EAAQ,EAAM,EAAM,MAAO,EAAM,IAAK,GAAO,EAAa,EAAM,EAAS,EAAE,CAGrF,OAAO,EAAO,EAAiB,EAAW,EAAM,CAGlD,SAAS,EAAU,EAAoB,CACrC,IAAM,EAAQ,EAAU,EAAG,CACvB,EAAQ,EACZ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,GAAK,EAC1B,EAAQ,EAAQ,IAAM,EAAM,GAE9B,OAAO,EAGT,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAc,KAAK,EAAG,CA6BzD,MAAaC,EAAiB,OAAO,OAAO,EAAI,CAC9C,QAAS,EACT,UAAW,EACX,YACA,UACA,IAAK,uCACL,IAAK,uCACN,CAAC"}
+{"version":3,"file":"v7.mjs","names":["state: V7State","bytes: Uint8Array","uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":["import { rng } from '../common/random'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type UuidV7Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Several bytes will be overwritten with timestamp, version, and variant data.\n   */\n  random?: Uint8Array\n  msecs?: number\n  seq?: number\n}\n\nexport type UuidV7 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: UuidV7Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: unknown): id is string\n  /** The nil UUID (all zeros) */\n  NIL: string\n  /** The max UUID (all ones) */\n  MAX: string\n}\n\nconst UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n\n// Reusable buffer for string output path - avoids allocation per call.\n// Safe because bytes are consumed synchronously by formatUuid().\nconst reusableBuf = new Uint8Array(16)\n\ntype V7State = {\n  msecs: number\n  seq: number\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all uuidv7() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `seq` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: V7State = { msecs: -Infinity, seq: 0 }\n\nfunction v7Bytes(\n  rnds: Uint8Array,\n  msecs: number | undefined,\n  seq: number | undefined,\n  buf: Uint8Array,\n  offset = 0,\n): Uint8Array {\n  if (rnds.length < 16) {\n    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', 'Random bytes length must be >= 16')\n  }\n\n  if (offset < 0 || offset + 16 > buf.length) {\n    throw new BufferError(\n      'UUID_BUFFER_OUT_OF_BOUNDS',\n      `UUID byte range ${offset}:${offset + 15} is out of buffer bounds`,\n    )\n  }\n\n  msecs ??= Date.now()\n  // Derive a 31-bit sequence if not provided by the caller.\n  // Uses the same formula as the hot path for consistency.\n  seq ??= (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n\n  // Keep this inline on the UUID v7 hot path. Using writeTimestamp48() here\n  // benchmarked slower than the direct byte writes.\n  buf[offset++] = (msecs / 0x10000000000) & 0xff\n  buf[offset++] = (msecs / 0x100000000) & 0xff\n  buf[offset++] = (msecs / 0x1000000) & 0xff\n  buf[offset++] = (msecs / 0x10000) & 0xff\n  buf[offset++] = (msecs / 0x100) & 0xff\n  buf[offset++] = msecs & 0xff\n\n  // Set version (7) and variant (10xx), then pack sequence and random tail bytes.\n  buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f)\n  buf[offset++] = (seq >>> 20) & 0xff\n  buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f)\n  buf[offset++] = (seq >>> 6) & 0xff\n  // Lower seq bits plus 2 random bits to complete the 128-bit payload.\n  buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03)\n  buf[offset++] = rnds[11]\n  buf[offset++] = rnds[12]\n  buf[offset++] = rnds[13]\n  buf[offset++] = rnds[14]\n  buf[offset++] = rnds[15]\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v7(options?: UuidV7Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v7<TBuf extends Uint8Array = Uint8Array>(options: UuidV7Options | undefined, buf: TBuf, offset?: number): TBuf\nfunction v7<TBuf extends Uint8Array = Uint8Array>(options?: UuidV7Options, buf?: TBuf, offset?: number): string | TBuf {\n  let bytes: Uint8Array\n\n  if (options) {\n    bytes = v7Bytes(options.random ?? rng(), options.msecs, options.seq, buf ?? reusableBuf, buf ? offset : 0)\n  } else {\n    // HOT PATH: Inline state management and byte generation for best performance\n    const now = Date.now()\n    const rnds = rng()\n\n    // Update state (inlined for performance)\n    if (now > state.msecs) {\n      state.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n      state.msecs = now\n    } else {\n      state.seq = (state.seq + 1) | 0\n      if (state.seq < 0) {\n        state.seq = 0\n        state.msecs++\n      }\n    }\n\n    bytes = v7Bytes(rnds, state.msecs, state.seq, buf ?? reusableBuf, buf ? offset : 0)\n  }\n\n  return buf ? (bytes as TBuf) : formatUuid(bytes)\n}\n\nfunction timestamp(id: string): number {\n  const bytes = parseUuid(id)\n  let msecs = 0\n  for (let i = 0; i < 6; i += 1) {\n    msecs = msecs * 256 + bytes[i]\n  }\n  return msecs\n}\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && UUID_V7_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v7 string or write the bytes into a buffer.\n *\n * UUID v7 is a time-ordered UUID that embeds a Unix timestamp in milliseconds,\n * making IDs naturally sortable by creation time. Ideal for database primary keys\n * where chronological ordering improves index performance.\n *\n * @example\n * ```ts\n * import { uuidv7 } from 'uniku/uuid/v7'\n *\n * const id = uuidv7()\n * // => \"018e5e5c-7c8a-7000-8000-000000000000\"\n *\n * // Extract timestamp\n * const ts = uuidv7.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * uuidv7.isValid(id) // true\n *\n * // Convert to/from bytes\n * const bytes = uuidv7.toBytes(id)\n * const restored = uuidv7.fromBytes(bytes)\n * ```\n */\nexport const uuidv7: UuidV7 = Object.assign(v7, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\n  timestamp,\n  isValid,\n  NIL: '00000000-0000-0000-0000-000000000000',\n  MAX: 'ffffffff-ffff-ffff-ffff-ffffffffffff',\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"iMA4BA,MAAM,EAAgB,yEAIhB,EAAc,IAAI,WAAW,GAAG,CAehCA,EAAiB,CAAE,MAAO,KAAW,IAAK,EAAG,CAEnD,SAAS,EACP,EACA,EACA,EACA,EACA,EAAS,EACG,CACZ,GAAI,EAAK,OAAS,GAChB,MAAM,IAAI,EAAkB,8BAA+B,oCAAoC,CAGjG,GAAI,EAAS,GAAK,EAAS,GAAK,EAAI,OAClC,MAAM,IAAI,EACR,4BACA,mBAAmB,EAAO,GAAG,EAAS,GAAG,0BAC1C,CA8BH,MA3BA,KAAU,KAAK,KAAK,CAGpB,IAAS,EAAK,IAAM,GAAO,EAAK,IAAM,GAAO,EAAK,IAAM,EAAK,EAAK,GAIlE,EAAI,KAAa,EAAQ,cAAiB,IAC1C,EAAI,KAAa,EAAQ,WAAe,IACxC,EAAI,KAAa,EAAQ,SAAa,IACtC,EAAI,KAAa,EAAQ,MAAW,IACpC,EAAI,KAAa,EAAQ,IAAS,IAClC,EAAI,KAAY,EAAQ,IAGxB,EAAI,KAAY,IAAS,IAAQ,GAAM,GACvC,EAAI,KAAa,IAAQ,GAAM,IAC/B,EAAI,KAAY,IAAS,IAAQ,GAAM,GACvC,EAAI,KAAa,IAAQ,EAAK,IAE9B,EAAI,KAAc,GAAO,EAAK,IAAS,EAAK,IAAM,EAClD,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IACrB,EAAI,KAAY,EAAK,IAEd,EAWT,SAAS,EAAyC,EAAyB,EAAY,EAAgC,CACrH,IAAIC,EAEJ,GAAI,EACF,EAAQ,EAAQ,EAAQ,QAAU,GAAK,CAAE,EAAQ,MAAO,EAAQ,IAAK,GAAO,EAAa,EAAM,EAAS,EAAE,KACrG,CAEL,IAAM,EAAM,KAAK,KAAK,CAChB,EAAO,GAAK,CAGd,EAAM,EAAM,OACd,EAAM,IAAO,EAAK,IAAM,GAAO,EAAK,IAAM,GAAO,EAAK,IAAM,EAAK,EAAK,GACtE,EAAM,MAAQ,IAEd,EAAM,IAAO,EAAM,IAAM,EAAK,EAC1B,EAAM,IAAM,IACd,EAAM,IAAM,EACZ,EAAM,UAIV,EAAQ,EAAQ,EAAM,EAAM,MAAO,EAAM,IAAK,GAAO,EAAa,EAAM,EAAS,EAAE,CAGrF,OAAO,EAAO,EAAiB,EAAW,EAAM,CAGlD,SAAS,EAAU,EAAoB,CACrC,IAAM,EAAQ,EAAU,EAAG,CACvB,EAAQ,EACZ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,GAAK,EAC1B,EAAQ,EAAQ,IAAM,EAAM,GAE9B,OAAO,EAGT,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAc,KAAK,EAAG,CA6BzD,MAAaC,EAAiB,OAAO,OAAO,EAAI,CAC9C,QAAS,EACT,UAAW,EACX,YACA,UACA,IAAK,uCACL,IAAK,uCACN,CAAC"}