{"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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"}