{"version":3,"file":"uuid.cjs","names":["randomUint8Array","encodeBase62","decodeBase62","encodeBase32","decodeBase32","toHex","fromHex","getTimestamp","toUint8Array","Uint8ArrayToString"],"sources":["../../src/common/uuid.ts"],"sourcesContent":["import { randomUint8Array } from './crypto'\nimport { decodeBase32, decodeBase62, encodeBase32, encodeBase62 } from './data/basex'\nimport { fromHex, toHex, toUint8Array, Uint8ArrayToString } from './data/bin'\nimport { getTimestamp } from './time'\n\n// 128 bit UUID\n\nconst uuidBytesLength = 16\n\n/**\n * Generate raw UUID bytes (128 bits / 16 bytes).\n *\n * Uses a cryptographically secure random source provided by\n * `randomUint8Array`.\n *\n * @returns Uint8Array of length 16 with random bytes\n */\nexport function uuidBytes(): Uint8Array {\n  return randomUint8Array(uuidBytesLength)\n}\n\n// Base62\n\n/**\n * Create a Base62-encoded UUID string from the provided bytes or a newly\n * generated random UUID. The result is a compact, URL-safe identifier.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base62 string representation (22 characters)\n */\nexport function uuidB62(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Encode raw UUID bytes to a Base62 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base62-encoded string\n */\nexport function uuidEncodeB62(bytes: Uint8Array): string {\n  return encodeBase62(bytes, 22)\n}\n\n/**\n * Decode a Base62-encoded UUID string into raw bytes.\n *\n * @param uuid - Base62 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB62(uuid: string): Uint8Array {\n  return decodeBase62(uuid, uuidBytesLength)\n}\n\n// Base32\n\n/**\n * Create a Base32-encoded UUID string from bytes or a new random UUID.\n *\n * @param bytes - optional 16-byte Uint8Array; if omitted a new random UUID is generated\n * @returns Base32 string representation (26 characters)\n */\nexport function uuidB32(bytes: Uint8Array = uuidBytes()): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Encode raw UUID bytes to a Base32 string.\n *\n * @param bytes - 16-byte UUID as Uint8Array\n * @returns Base32-encoded string\n */\nexport function uuidEncodeB32(bytes: Uint8Array): string {\n  return encodeBase32(bytes, 26)\n}\n\n/**\n * Decode a Base32-encoded UUID string into raw bytes.\n *\n * @param uuid - Base32 string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeB32(uuid: string): Uint8Array {\n  return decodeBase32(uuid, uuidBytesLength)\n}\n\n// UUIDv4\n\n// https://stackoverflow.com/a/2117523/140927\nconst pattern = '10000000-1000-4000-8000-100000000000' // String([1e7] + -1e3 + -4e3 + -8e3 + -1e11)\n\n/**\n * Generate a UUID v4 string.\n *\n * Uses the native `crypto.randomUUID()` if available; otherwise falls back to\n * a random-based implementation using `randomUint8Array`.\n *\n * @returns UUID v4 string in standard 8-4-4-4-12 hex format\n */\nexport function uuidv4(): string {\n  if (typeof crypto !== 'undefined' && crypto.randomUUID != null)\n    return crypto.randomUUID() // native!\n\n  // Fallback: generate 16 random bytes, set version and variant bits per RFC-4122\n  const bytes = randomUint8Array(16)\n  bytes[6] = (bytes[6] & 0x0F) | 0x40 // version 4\n  bytes[8] = (bytes[8] & 0x3F) | 0x80 // variant\n  return uuidEncodeV4(bytes)\n}\n\n/**\n * Encode 16 raw bytes as a UUID v4 formatted string (hex with dashes).\n *\n * @param bytes - 16-byte Uint8Array\n * @returns UUID string (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)\n */\nexport function uuidEncodeV4(bytes: Uint8Array): string {\n  const id = toHex(bytes)\n  return `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}` // 10000000 - 1000 - 4000 - 8000 - 100000000000\n}\n\n/**\n * Decode a UUID v4 string (hex with dashes) into raw bytes.\n *\n * @param uuid - UUID string\n * @returns 16-byte Uint8Array\n */\nexport function uuidDecodeV4(uuid: string): Uint8Array {\n  return fromHex(uuid.replace(/-/g, ''))\n}\n\n// Sortable UID\n\n// https://github.com/segmentio/ksuid\n// https://pkg.go.dev/github.com/rsms/go-uuid\n\n/**\n * Sortable unique ID\n * Inspired by https://github.com/rsms/go-uuid\n *\n * Bytes 0-5:  Current time in miliseconds from 2021-06-01T00:00:00Z\n * Bytes 6-15: Random\n */\n\n// 1622505600000 //  new Date('2021-06-01T00:00:00Z').getTime()\nconst ReferenceDateInMS = 1600000000000\n\n// 6 bytes will stay valid until end of time: new Date(1622505600000 + 0xffffffffffff) === Date Sun Jan 01 10941 06:31:50 GMT+0100 (Central European Standard Time)\n\nfunction longToByteArray(long: number) {\n  const byteArray = new Uint8Array(6)\n  for (let i = 5; i >= 0; i--) {\n    byteArray[i] = long & 0xFF\n    long = Math.floor(long / 256)\n  }\n  return byteArray\n}\n\n// function byteArrayToLong(byteArray: number[]): number {\n//   var value = 0\n//   for (var i = byteArray.length - 1; i >= 0; i--) {\n//     value = value * 256 + byteArray[i]\n//   }\n//   return value\n// }\n\n/**\n * Create a sortable unique identifier (SUID) as raw bytes.\n *\n * The first 6 bytes encode a millisecond timestamp offset from an internal\n * reference date to allow lexicographic sorting by creation time. The\n * remaining 10 bytes are random.\n *\n * @returns 16-byte Uint8Array where bytes 0-5 are timestamp and 6-15 are random\n */\nexport function suidBytes(): Uint8Array {\n  const ms = getTimestamp() - ReferenceDateInMS\n  const out = new Uint8Array(16)\n  out.set(longToByteArray(ms), 0)\n  out.set(randomUint8Array(10), 6)\n  return out\n}\n\n/**\n * Create a sortable unique identifier (SUID) and return it encoded using the\n * currently configured UUID encoding.\n *\n * @returns encoded SUID string\n */\nexport function suid(): string {\n  return uuidEncode(suidBytes())\n}\n\n/**\n * Extract the creation Date from an encoded SUID string.\n *\n * @param id - encoded SUID\n * @returns Date corresponding to the timestamp component of the SUID\n */\nexport function suidDate(id: string): Date {\n  return suidBytesDate(uuidDecode(id))\n}\n\n/**\n * Extract the creation Date from raw SUID bytes.\n *\n * @param id - 16-byte SUID as Uint8Array\n * @returns Date corresponding to the timestamp encoded in bytes 0-5\n */\nexport function suidBytesDate(id: Uint8Array): Date {\n  return new Date(\n    ReferenceDateInMS + id.slice(0, 6).reduce((acc, byte) => acc * 256 + byte, 0),\n  )\n}\n\n// 32 bit UUID\n\n/**\n * Generate a 32-bit unsigned integer from 4 random bytes.\n *\n * @returns a random 32-bit unsigned integer\n */\nexport function uuid32bit(): number {\n  const bytes = randomUint8Array(4)\n  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n  return view.getUint32(0, false)\n}\n\n// Global Settings\n\nconst mapModes = {\n  base62: {\n    uuid: uuidB62,\n    uuidDecode: uuidDecodeB62,\n    uuidEncode: uuidEncodeB62,\n  },\n  base32: {\n    uuid: uuidB32,\n    uuidDecode: uuidDecodeB32,\n    uuidEncode: uuidEncodeB32,\n  },\n  uuidv4: {\n    uuid: uuidv4,\n    uuidDecode: uuidDecodeV4,\n    uuidEncode: uuidEncodeV4,\n  },\n  test: {\n    uuid: (): string => uname('test'),\n    uuidDecode: (id: string): Uint8Array => toUint8Array(id),\n    uuidEncode: (bin: Uint8Array): string => Uint8ArrayToString(bin),\n  },\n}\n\nlet _mode: keyof typeof mapModes = 'base62'\nlet _sorted = false\n\n/**\n * Configure the default encoding and whether generated IDs should be\n * lexicographically sortable.\n *\n * @param mode - encoding mode ('base62' | 'base32' | 'uuidv4' | 'test')\n * @param sorted - when true, `uuid()` will prefer sortable SUIDs\n */\nexport function setUuidDefaultEncoding(mode?: keyof typeof mapModes, sorted = false) {\n  if (mode === 'test')\n    unameReset('test')\n\n  _mode = mode ?? 'base62'\n  _sorted = sorted\n}\n\n/**\n * Generate an identifier using the current encoding mode.\n *\n * If the default encoding is configured with `sorted=true`, this returns a\n * sortable SUID; otherwise a random UUID is returned.\n *\n * @returns encoded identifier string\n */\nexport function uuid(): string {\n  return mapModes[_mode].uuid(_sorted ? suidBytes() : uuidBytes())\n}\n\n/**\n * Decode an encoded identifier according to the current encoding mode into\n * raw bytes.\n *\n * @param uuid - encoded identifier string\n * @returns raw 16-byte Uint8Array\n */\nexport function uuidDecode(uuid: string): Uint8Array {\n  return mapModes[_mode].uuidDecode(uuid)\n}\n\n/**\n * Encode raw UUID bytes using the current encoding mode.\n *\n * @param bytes - 16-byte Uint8Array\n * @returns encoded identifier string\n */\nexport function uuidEncode(bytes: Uint8Array): string {\n  return mapModes[_mode].uuidEncode(bytes)\n}\n\n/**\n * Validate an encoded identifier by attempting to decode it and checking\n * for the expected byte length.\n *\n * @param uuid - encoded identifier string\n * @returns true when valid and decodes to 16 bytes\n */\nexport function uuidIsValid(uuid: string): boolean {\n  try {\n    const bin = uuidDecode(uuid)\n    return bin.length === uuidBytesLength\n  }\n  catch (err) {\n    // log.warn('Invalid ID:', uuid)\n  }\n  return false\n}\n\n// Simple Counters\n\nconst _unameCounters: Record<string, number> = {}\n\n/**\n * Simple counter-based unique name generator.\n *\n * Returns strings like 'name-0', 'name-1', ... and increments an internal\n * counter per `name`.\n *\n * @param name - base name for the counter (default: 'id')\n * @returns generated unique name\n */\nexport function uname(name = 'id'): string {\n  _unameCounters[name] ??= 0\n\n  return `${name}-${_unameCounters[name]++}`\n}\n\n/** Reset the counter used by `uname` for the given name. */\nexport function unameReset(name = 'id') {\n  _unameCounters[name] = 0\n}\n\nlet _qid = 0\n\n/**\n * Quick global incremental id generator.\n *\n * Returns strings like 'id-0', 'id-1', ... using a single global counter.\n */\nexport function qid(): string {\n  return `id-${_qid++}`\n}\n"],"mappings":"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"}