uniku 0.4.3 → 0.5.0

package/build/objectid/objectid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"objectid.mjs","names":["OBJECTID_BYTES"],"sources":["../../src/objectid/hex.ts","../../src/objectid/objectid.ts"],"sourcesContent":["import { BufferError, ParseError } from '../errors'\n\n/**\n * Hex encoding/decoding for ObjectID.\n * Alphabet: 0-9a-f (lowercase on encode, case-insensitive on decode)\n *\n * ObjectID binary format: 12 bytes (96 bits)\n * - 4 bytes: big-endian Unix timestamp in seconds\n * - 5 bytes: per-process random value\n * - 3 bytes: big-endian counter\n *\n * String format: 24 characters of hex\n */\n\nconst HEX_CHARS = '0123456789abcdef'\nconst OBJECTID_BYTES = 12\nconst OBJECTID_STRING_LEN = 24\n\n// Pre-computed encode table: byte value (0-255) -> 2-char lowercase hex string.\nconst ENCODE_TABLE: string[] = Array.from(\n  { length: 256 },\n  (_, byte) => HEX_CHARS[(byte >> 4) & 0xf] + HEX_CHARS[byte & 0xf],\n)\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 128 KiB once at module load; valid inputs only touch the first\n// 128 bytes, so cache behavior is unaffected.\n// Note: unlike Base62, hex decoding is case-insensitive - 'a' and 'A' both decode to 10.\nconst DECODING = new Uint8Array(65536)\nDECODING.fill(255) // 255 = invalid marker\n\nfor (let i = 0; i <= 9; i += 1) {\n  DECODING['0'.charCodeAt(0) + i] = i\n}\nfor (let i = 0; i < 6; i += 1) {\n  DECODING['a'.charCodeAt(0) + i] = 10 + i\n  DECODING['A'.charCodeAt(0) + i] = 10 + i\n}\n\n/**\n * Encode 12 ObjectID bytes to a 24-character lowercase hex string.\n */\nexport function encodeObjectIdHex(bytes: Uint8Array): string {\n  if (bytes.length < OBJECTID_BYTES) {\n    throw new BufferError(\n      'OBJECTID_BYTES_TOO_SHORT',\n      `ObjectID bytes must be at least ${OBJECTID_BYTES} bytes, got ${bytes.length}`,\n    )\n  }\n\n  let encoded = ''\n  for (let i = 0; i < OBJECTID_BYTES; i += 1) {\n    encoded += ENCODE_TABLE[bytes[i]]\n  }\n  return encoded\n}\n\n/**\n * Decode a 24-character hex string to 12 ObjectID bytes.\n */\nexport function decodeObjectIdHex(str: string): Uint8Array {\n  if (str.length !== OBJECTID_STRING_LEN) {\n    throw new ParseError(\n      'OBJECTID_INVALID_LENGTH',\n      `ObjectID string must be ${OBJECTID_STRING_LEN} characters, got ${str.length}`,\n    )\n  }\n\n  const bytes = new Uint8Array(OBJECTID_BYTES)\n  for (let i = 0; i < OBJECTID_BYTES; i += 1) {\n    const hiIndex = i * 2\n    const loIndex = hiIndex + 1\n    const hi = DECODING[str.charCodeAt(hiIndex)]\n    const lo = DECODING[str.charCodeAt(loIndex)]\n\n    if (hi === 255) {\n      throw new ParseError('OBJECTID_INVALID_CHAR', `Invalid ObjectID character: ${str[hiIndex]}`)\n    }\n    if (lo === 255) {\n      throw new ParseError('OBJECTID_INVALID_CHAR', `Invalid ObjectID character: ${str[loIndex]}`)\n    }\n\n    bytes[i] = (hi << 4) | lo\n  }\n\n  return bytes\n}\n","import { writeTimestamp32 } from '../common/bytes'\nimport { randomBytes, randomUint32 } from '../common/random'\nimport { isIntegerInRange, isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeObjectIdHex, encodeObjectIdHex } from './hex'\n\n/**\n * MongoDB ObjectID\n *\n * A 96-bit (12-byte) identifier consisting of:\n * - 4 bytes: big-endian Unix timestamp in seconds\n * - 5 bytes: per-process random value\n * - 3 bytes: big-endian counter, always incrementing (wraps at 0xFFFFFF back to 0)\n *\n * Encoded as a 24-character lowercase hex string.\n */\n\nconst OBJECTID_BYTES = 12\nconst TIMESTAMP_BYTES = 4\nconst RANDOM_BYTES = 5\nconst COUNTER_BYTES = 3\nconst MAX_SECS = 0xffffffff\nconst MAX_COUNTER = 0xffffff\n\n// Validation regex: case-insensitive per KTD7, matching bson's ObjectId.isValid()\nconst OBJECTID_REGEX = /^[0-9a-f]{24}$/i\n\nexport type ObjectIdOptions = {\n  /**\n   * 5 bytes of random data to use for the ObjectID's random field.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in seconds since Unix epoch.\n   * Defaults to Math.floor(Date.now() / 1000).\n   */\n  secs?: number\n  /**\n   * 24-bit counter value (0 to 0xFFFFFF).\n   */\n  counter?: number\n}\n\nexport type ObjectId = {\n  /** Generate a MongoDB-compatible ObjectID string. */\n  (): string\n  /** Generate an ObjectID with explicit options or write its 12 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: ObjectIdOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate an ObjectID string with optional timestamp, random field, or counter. */\n  (options?: ObjectIdOptions, buf?: undefined, offset?: number): string\n  /** Convert an ObjectID string to its canonical 12-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 12 canonical ObjectID bytes to an ObjectID string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Read the embedded Unix timestamp in milliseconds. */\n  timestamp(id: string): number\n  /** Return whether a value is a syntactically valid ObjectID string. */\n  isValid(id: unknown): id is string\n  /** The nil ObjectID (all zeros) */\n  NIL: string\n  /** The max ObjectID (all 0xff) */\n  MAX: string\n}\n\ntype ObjectIdState = {\n  random: Uint8Array | undefined\n  counter: number | undefined\n}\n\n/**\n * Module-level state for the per-process random value and the always-incrementing counter.\n *\n * IMPORTANT: This state persists across all objectid() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n *   Unlike ULID/UUIDv7's per-timestamp sequence reset, the counter continuing to climb\n *   across warm starts is exactly the anti-collision behavior the ObjectID spec intends.\n * - For isolated state, pass explicit `random`, `secs`, or `counter` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: ObjectIdState = {\n  random: undefined,\n  counter: undefined,\n}\n\n/**\n * Draw 5 fresh random bytes into a newly-owned buffer, copying immediately so the\n * result is unaffected by any later pool refill triggered by other random draws\n * (e.g. the counter's `randomUint32()` call) before these bytes are consumed.\n */\nfunction freshRandom(): Uint8Array {\n  const bytes = new Uint8Array(RANDOM_BYTES)\n  bytes.set(randomBytes(RANDOM_BYTES))\n  return bytes\n}\n\nfunction writeObjectIdBytesUnchecked(\n  secs: number,\n  random: Uint8Array,\n  counter: number,\n  buf: Uint8Array,\n  offset: number,\n): void {\n  // Timestamp (32-bit big-endian seconds since Unix epoch) -> bytes 0-3\n  writeTimestamp32(buf, offset, secs)\n\n  // Random (5 bytes) -> bytes 4-8\n  for (let i = 0; i < RANDOM_BYTES; i += 1) {\n    buf[offset + TIMESTAMP_BYTES + i] = random[i]\n  }\n\n  // Counter (24-bit big-endian) -> bytes 9-11\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES] = (counter >>> 16) & 0xff\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + 1] = (counter >>> 8) & 0xff\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + COUNTER_BYTES - 1] = counter & 0xff\n}\n\n/*\n * Overload: no buffer => return an ObjectID string.\n */\nfunction objectIdFn(options?: ObjectIdOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with ObjectID bytes.\n */\nfunction objectIdFn<TBuf extends Uint8Array = Uint8Array>(\n  options: ObjectIdOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction objectIdFn<TBuf extends Uint8Array = Uint8Array>(\n  options?: ObjectIdOptions,\n  buf?: TBuf,\n  offset = 0,\n): string | TBuf {\n  let secs: number\n  let random: Uint8Array\n  let counter: number\n\n  if (options) {\n    const optRandom = options.random\n    if (optRandom && optRandom.length < RANDOM_BYTES) {\n      throw new InvalidInputError(\n        'OBJECTID_RANDOM_BYTES_TOO_SHORT',\n        `Random bytes length must be >= ${RANDOM_BYTES} for ObjectID`,\n      )\n    }\n\n    const optSecs = options.secs\n    if (optSecs !== undefined && !isIntegerInRange(optSecs, 0, MAX_SECS)) {\n      throw new InvalidInputError('OBJECTID_TIMESTAMP_OUT_OF_RANGE', `Timestamp must be between 0 and ${MAX_SECS}`)\n    }\n\n    const optCounter = options.counter\n    if (optCounter !== undefined && !isIntegerInRange(optCounter, 0, MAX_COUNTER)) {\n      throw new InvalidInputError('OBJECTID_COUNTER_OUT_OF_RANGE', `Counter must be between 0 and ${MAX_COUNTER}`)\n    }\n\n    // Options bypass persistent state entirely: every field is sourced fresh (given\n    // value, or an independently-defaulted one), never read from or written to\n    // `state` (see KTD2). This is what makes options-based generation deterministic\n    // when all three fields are supplied.\n    secs = optSecs ?? Math.floor(Date.now() / 1000)\n    random = optRandom ?? freshRandom()\n    counter = optCounter ?? randomUint32() & MAX_COUNTER\n  } else {\n    // Lazily initialize persistent state on first no-option call.\n    if (state.random === undefined) {\n      state.random = freshRandom()\n    }\n    if (state.counter === undefined) {\n      state.counter = randomUint32() & MAX_COUNTER\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 ObjectIDs generated within a single request will share the same timestamp.\n     * - monotonic ordering relies entirely on the ever-incrementing counter.\n     */\n    secs = Math.floor(Date.now() / 1000)\n    random = state.random\n    state.counter = (state.counter + 1) & MAX_COUNTER\n    counter = state.counter\n  }\n\n  if (buf) {\n    if (!isWritableRange(buf, offset, OBJECTID_BYTES)) {\n      throw new BufferError(\n        'OBJECTID_BUFFER_OUT_OF_BOUNDS',\n        `ObjectID byte range ${offset}:${offset + OBJECTID_BYTES - 1} is out of buffer bounds`,\n      )\n    }\n    writeObjectIdBytesUnchecked(secs, random, counter, buf, offset)\n    return buf\n  }\n\n  const bytes = new Uint8Array(OBJECTID_BYTES)\n  writeObjectIdBytesUnchecked(secs, random, counter, bytes, 0)\n  return encodeObjectIdHex(bytes)\n}\n\n/**\n * Convert an ObjectID hex string to 12 bytes.\n */\nfunction toBytes(id: string): Uint8Array {\n  return decodeObjectIdHex(id)\n}\n\n/**\n * Convert 12 bytes to an ObjectID hex string.\n */\nfunction fromBytes(bytes: Uint8Array): string {\n  if (bytes.length !== OBJECTID_BYTES) {\n    throw new BufferError(\n      'OBJECTID_BYTES_INVALID_LENGTH',\n      `ObjectID bytes must be exactly ${OBJECTID_BYTES} bytes, got ${bytes.length}`,\n    )\n  }\n  return encodeObjectIdHex(bytes)\n}\n\n/**\n * Extract the timestamp from an ObjectID string.\n * Returns Unix timestamp in milliseconds for API consistency with ulid/uuidv7/ksuid.\n * Note: ObjectID only has second precision, so the returned value will always end in 000.\n */\nfunction timestamp(id: string): number {\n  const bytes = decodeObjectIdHex(id)\n  // First 4 bytes are big-endian timestamp (seconds since Unix epoch)\n  const secs = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0\n  return secs * 1000\n}\n\n/**\n * Validate an ObjectID string format.\n * Case-insensitive (KTD7), matching bson's ObjectId.isValid() and this repo's existing\n * convention (ulid, ksuid) of accepting mixed-case input for parsing, even though\n * generation always emits lowercase (matching MongoDB driver output).\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && OBJECTID_REGEX.test(id)\n}\n\n/**\n * Generate a MongoDB ObjectID string or write the bytes into a buffer.\n *\n * ObjectID is a 12-byte identifier consisting of a 4-byte timestamp, a 5-byte\n * per-process random value, and a 3-byte always-incrementing counter, encoded\n * as a 24-character lowercase hex string. It is time-ordered and compatible\n * with MongoDB's own ObjectID implementation.\n *\n * @example\n * ```ts\n * import { objectid } from 'uniku/objectid'\n *\n * const id = objectid()\n * // => \"667c3f2a1e2b3c4d5e6f7081\"\n *\n * // Extract timestamp\n * const ts = objectid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * objectid.isValid(id) // true\n *\n * // Convert to/from bytes (12 bytes)\n * const bytes = objectid.toBytes(id)\n * const restored = objectid.fromBytes(bytes)\n * ```\n */\nexport const objectid: ObjectId = Object.assign(objectIdFn, {\n  toBytes,\n  fromBytes,\n  timestamp,\n  isValid,\n  NIL: '0'.repeat(24),\n  MAX: 'f'.repeat(24),\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"objectid.mjs","names":["OBJECTID_BYTES"],"sources":["../../src/objectid/hex.ts","../../src/objectid/objectid.ts"],"sourcesContent":["import { BufferError, ParseError } from '../errors'\n\n/**\n * Hex encoding/decoding for ObjectID.\n * Alphabet: 0-9a-f (lowercase on encode, case-insensitive on decode)\n *\n * ObjectID binary format: 12 bytes (96 bits)\n * - 4 bytes: big-endian Unix timestamp in seconds\n * - 5 bytes: per-process random value\n * - 3 bytes: big-endian counter\n *\n * String format: 24 characters of hex\n */\n\nconst HEX_CHARS = '0123456789abcdef'\nconst OBJECTID_BYTES = 12\nconst OBJECTID_STRING_LEN = 24\n\n// Pre-computed encode table: byte value (0-255) -> 2-char lowercase hex string.\nconst ENCODE_TABLE: string[] = Array.from(\n  { length: 256 },\n  (_, byte) => HEX_CHARS[(byte >> 4) & 0xf] + HEX_CHARS[byte & 0xf],\n)\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 128 KiB once at module load; valid inputs only touch the first\n// 128 bytes, so cache behavior is unaffected.\n// Note: unlike Base62, hex decoding is case-insensitive - 'a' and 'A' both decode to 10.\nconst DECODING = new Uint8Array(65536)\nDECODING.fill(255) // 255 = invalid marker\n\nfor (let i = 0; i <= 9; i += 1) {\n  DECODING['0'.charCodeAt(0) + i] = i\n}\nfor (let i = 0; i < 6; i += 1) {\n  DECODING['a'.charCodeAt(0) + i] = 10 + i\n  DECODING['A'.charCodeAt(0) + i] = 10 + i\n}\n\n/**\n * Encode 12 ObjectID bytes to a 24-character lowercase hex string.\n */\nexport function encodeObjectIdHex(bytes: Uint8Array): string {\n  if (bytes.length < OBJECTID_BYTES) {\n    throw new BufferError(\n      'BYTES_INVALID_LENGTH',\n      `ObjectID bytes must be at least ${OBJECTID_BYTES} bytes, got ${bytes.length}`,\n      { strategy: 'objectid' },\n    )\n  }\n\n  let encoded = ''\n  for (let i = 0; i < OBJECTID_BYTES; i += 1) {\n    encoded += ENCODE_TABLE[bytes[i]]\n  }\n  return encoded\n}\n\n/**\n * Decode a 24-character hex string to 12 ObjectID bytes.\n */\nexport function decodeObjectIdHex(str: string): Uint8Array {\n  if (str.length !== OBJECTID_STRING_LEN) {\n    throw new ParseError(\n      'INVALID_LENGTH',\n      `ObjectID string must be ${OBJECTID_STRING_LEN} characters, got ${str.length}`,\n      { strategy: 'objectid' },\n    )\n  }\n\n  const bytes = new Uint8Array(OBJECTID_BYTES)\n  for (let i = 0; i < OBJECTID_BYTES; i += 1) {\n    const hiIndex = i * 2\n    const loIndex = hiIndex + 1\n    const hi = DECODING[str.charCodeAt(hiIndex)]\n    const lo = DECODING[str.charCodeAt(loIndex)]\n\n    if (hi === 255) {\n      throw new ParseError('INVALID_CHAR', `Invalid ObjectID character: ${str[hiIndex]}`, { strategy: 'objectid' })\n    }\n    if (lo === 255) {\n      throw new ParseError('INVALID_CHAR', `Invalid ObjectID character: ${str[loIndex]}`, { strategy: 'objectid' })\n    }\n\n    bytes[i] = (hi << 4) | lo\n  }\n\n  return bytes\n}\n","import { writeTimestamp32 } from '../common/bytes'\nimport { randomBytes, randomUint32 } from '../common/random'\nimport { resolveTimestampSecs } from '../common/timestamp'\nimport { isIntegerInRange, isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeObjectIdHex, encodeObjectIdHex } from './hex'\n\n/**\n * MongoDB ObjectID\n *\n * A 96-bit (12-byte) identifier consisting of:\n * - 4 bytes: big-endian Unix timestamp in seconds\n * - 5 bytes: per-process random value\n * - 3 bytes: big-endian counter, always incrementing (wraps at 0xFFFFFF back to 0)\n *\n * Encoded as a 24-character lowercase hex string.\n */\n\nconst OBJECTID_BYTES = 12\nconst TIMESTAMP_BYTES = 4\nconst RANDOM_BYTES = 5\nconst COUNTER_BYTES = 3\nconst MAX_SECS = 0xffffffff\nconst MAX_COUNTER = 0xffffff\n\n// Validation regex: case-insensitive per KTD7, matching bson's ObjectId.isValid()\nconst OBJECTID_REGEX = /^[0-9a-f]{24}$/i\n\nexport type ObjectIdOptions = {\n  /**\n   * 5 bytes of random data to use for the ObjectID's random field.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in milliseconds since the Unix epoch.\n   * Defaults to Date.now().\n   * ObjectID stores whole seconds, so sub-second precision is truncated.\n   */\n  msecs?: number\n  /**\n   * Timestamp in seconds since the Unix epoch.\n   *\n   * @deprecated Use `msecs` instead. Will be removed at v1-rc.\n   */\n  // TODO(v1-rc): remove this alias (tracked in docs/STABILITY.md).\n  secs?: number\n  /**\n   * 24-bit counter value (0 to 0xFFFFFF).\n   */\n  counter?: number\n}\n\nexport type ObjectId = {\n  /** Generate a MongoDB-compatible ObjectID string. */\n  (): string\n  /** Generate an ObjectID with explicit options or write its 12 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: ObjectIdOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate an ObjectID string with optional timestamp, random field, or counter. */\n  (options?: ObjectIdOptions, buf?: undefined, offset?: number): string\n  /** Convert an ObjectID string to its canonical 12-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 12 canonical ObjectID bytes to an ObjectID string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Read the embedded Unix timestamp in milliseconds. */\n  timestamp(id: string): number\n  /** Return whether a value is a syntactically valid ObjectID string. */\n  isValid(id: unknown): id is string\n  /** The nil ObjectID (all zeros) */\n  NIL: string\n  /** The max ObjectID (all 0xff) */\n  MAX: string\n}\n\ntype ObjectIdState = {\n  random: Uint8Array | undefined\n  counter: number | undefined\n}\n\n/**\n * Module-level state for the per-process random value and the always-incrementing counter.\n *\n * IMPORTANT: This state persists across all objectid() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n *   Unlike ULID/UUIDv7's per-timestamp sequence reset, the counter continuing to climb\n *   across warm starts is exactly the anti-collision behavior the ObjectID spec intends.\n * - For isolated state, pass explicit `random`, `msecs`, or `counter` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: ObjectIdState = {\n  random: undefined,\n  counter: undefined,\n}\n\n/**\n * Draw 5 fresh random bytes into a newly-owned buffer, copying immediately so the\n * result is unaffected by any later pool refill triggered by other random draws\n * (e.g. the counter's `randomUint32()` call) before these bytes are consumed.\n */\nfunction freshRandom(): Uint8Array {\n  const bytes = new Uint8Array(RANDOM_BYTES)\n  bytes.set(randomBytes(RANDOM_BYTES))\n  return bytes\n}\n\nfunction writeObjectIdBytesUnchecked(\n  secs: number,\n  random: Uint8Array,\n  counter: number,\n  buf: Uint8Array,\n  offset: number,\n): void {\n  // Timestamp (32-bit big-endian seconds since Unix epoch) -> bytes 0-3\n  writeTimestamp32(buf, offset, secs)\n\n  // Random (5 bytes) -> bytes 4-8\n  for (let i = 0; i < RANDOM_BYTES; i += 1) {\n    buf[offset + TIMESTAMP_BYTES + i] = random[i]\n  }\n\n  // Counter (24-bit big-endian) -> bytes 9-11\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES] = (counter >>> 16) & 0xff\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + 1] = (counter >>> 8) & 0xff\n  buf[offset + TIMESTAMP_BYTES + RANDOM_BYTES + COUNTER_BYTES - 1] = counter & 0xff\n}\n\n/*\n * Overload: no buffer => return an ObjectID string.\n */\nfunction objectIdFn(options?: ObjectIdOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with ObjectID bytes.\n */\nfunction objectIdFn<TBuf extends Uint8Array = Uint8Array>(\n  options: ObjectIdOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction objectIdFn<TBuf extends Uint8Array = Uint8Array>(\n  options?: ObjectIdOptions,\n  buf?: TBuf,\n  offset = 0,\n): string | TBuf {\n  let secs: number\n  let random: Uint8Array\n  let counter: number\n\n  if (options) {\n    const optRandom = options.random\n    if (optRandom && optRandom.length < RANDOM_BYTES) {\n      throw new InvalidInputError(\n        'RANDOM_BYTES_TOO_SHORT',\n        `Random bytes length must be >= ${RANDOM_BYTES} for ObjectID`,\n        {\n          strategy: 'objectid',\n        },\n      )\n    }\n\n    const optSecs = resolveTimestampSecs(options, 0, MAX_SECS, 'objectid')\n\n    const optCounter = options.counter\n    if (optCounter !== undefined && !isIntegerInRange(optCounter, 0, MAX_COUNTER)) {\n      throw new InvalidInputError('COUNTER_OUT_OF_RANGE', `Counter must be between 0 and ${MAX_COUNTER}`, {\n        strategy: 'objectid',\n      })\n    }\n\n    // Options bypass persistent state entirely: every field is sourced fresh (given\n    // value, or an independently-defaulted one), never read from or written to\n    // `state` (see KTD2). This is what makes options-based generation deterministic\n    // when all three fields are supplied.\n    secs = optSecs ?? Math.floor(Date.now() / 1000)\n    random = optRandom ?? freshRandom()\n    counter = optCounter ?? randomUint32() & MAX_COUNTER\n  } else {\n    // Lazily initialize persistent state on first no-option call.\n    if (state.random === undefined) {\n      state.random = freshRandom()\n    }\n    if (state.counter === undefined) {\n      state.counter = randomUint32() & MAX_COUNTER\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 ObjectIDs generated within a single request will share the same timestamp.\n     * - monotonic ordering relies entirely on the ever-incrementing counter.\n     */\n    secs = Math.floor(Date.now() / 1000)\n    random = state.random\n    state.counter = (state.counter + 1) & MAX_COUNTER\n    counter = state.counter\n  }\n\n  if (buf) {\n    if (!isWritableRange(buf, offset, OBJECTID_BYTES)) {\n      throw new BufferError(\n        'BUFFER_OUT_OF_BOUNDS',\n        `ObjectID byte range ${offset}:${offset + OBJECTID_BYTES - 1} is out of buffer bounds`,\n        { strategy: 'objectid' },\n      )\n    }\n    writeObjectIdBytesUnchecked(secs, random, counter, buf, offset)\n    return buf\n  }\n\n  const bytes = new Uint8Array(OBJECTID_BYTES)\n  writeObjectIdBytesUnchecked(secs, random, counter, bytes, 0)\n  return encodeObjectIdHex(bytes)\n}\n\n/**\n * Convert an ObjectID hex string to 12 bytes.\n */\nfunction toBytes(id: string): Uint8Array {\n  return decodeObjectIdHex(id)\n}\n\n/**\n * Convert 12 bytes to an ObjectID hex string.\n */\nfunction fromBytes(bytes: Uint8Array): string {\n  if (bytes.length !== OBJECTID_BYTES) {\n    throw new BufferError(\n      'BYTES_INVALID_LENGTH',\n      `ObjectID bytes must be exactly ${OBJECTID_BYTES} bytes, got ${bytes.length}`,\n      { strategy: 'objectid' },\n    )\n  }\n  return encodeObjectIdHex(bytes)\n}\n\n/**\n * Extract the timestamp from an ObjectID string.\n * Returns Unix timestamp in milliseconds for API consistency with ulid/uuidv7/ksuid.\n * Note: ObjectID only has second precision, so the returned value will always end in 000.\n */\nfunction timestamp(id: string): number {\n  const bytes = decodeObjectIdHex(id)\n  // First 4 bytes are big-endian timestamp (seconds since Unix epoch)\n  const secs = ((bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3]) >>> 0\n  return secs * 1000\n}\n\n/**\n * Validate an ObjectID string format.\n * Case-insensitive (KTD7), matching bson's ObjectId.isValid() and this repo's existing\n * convention (ulid, ksuid) of accepting mixed-case input for parsing, even though\n * generation always emits lowercase (matching MongoDB driver output).\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && OBJECTID_REGEX.test(id)\n}\n\n/**\n * Generate a MongoDB ObjectID string or write the bytes into a buffer.\n *\n * ObjectID is a 12-byte identifier consisting of a 4-byte timestamp, a 5-byte\n * per-process random value, and a 3-byte always-incrementing counter, encoded\n * as a 24-character lowercase hex string. It is time-ordered and compatible\n * with MongoDB's own ObjectID implementation.\n *\n * @example\n * ```ts\n * import { objectid } from 'uniku/objectid'\n *\n * const id = objectid()\n * // => \"667c3f2a1e2b3c4d5e6f7081\"\n *\n * // Extract timestamp\n * const ts = objectid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * objectid.isValid(id) // true\n *\n * // Convert to/from bytes (12 bytes)\n * const bytes = objectid.toBytes(id)\n * const restored = objectid.fromBytes(bytes)\n * ```\n */\nexport const objectid: ObjectId = Object.assign(objectIdFn, {\n  toBytes,\n  fromBytes,\n  timestamp,\n  isValid,\n  NIL: '0'.repeat(24),\n  MAX: 'f'.repeat(24),\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/timestamp-ChrSuQCR.mjs

@@ -0,0 +1,2 @@
+import{t as e}from"./validation-CTNpXm94.mjs";import{InvalidInputError as t}from"./errors.mjs";function n(n,r,i,a){let{msecs:o,secs:s}=n;if(o!==void 0&&s!==void 0)throw new t(`CONFLICTING_OPTIONS`,"Pass only one of `msecs` or `secs`, not both",{strategy:a});if(o!==void 0){let n=r*1e3,s=i*1e3+999;if(!e(o,n,s))throw new t(`TIMESTAMP_OUT_OF_RANGE`,`Timestamp must be an integer between ${n} and ${s} milliseconds`,{strategy:a});return Math.floor(o/1e3)}if(s!==void 0){if(!e(s,r,i))throw new t(`TIMESTAMP_OUT_OF_RANGE`,`Timestamp must be an integer between ${r} and ${i} seconds`,{strategy:a});return s}}export{n as t};
+//# sourceMappingURL=timestamp-ChrSuQCR.mjs.map

package/build/timestamp-ChrSuQCR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"timestamp-ChrSuQCR.mjs","names":[],"sources":["../src/common/timestamp.ts"],"sourcesContent":["import { InvalidInputError } from '../errors'\nimport type { IdGenerator } from '../generators'\nimport { isIntegerInRange } from './validation'\n\n/**\n * Timestamp options accepted by second-precision generators (ksuid, objectid,\n * xid) during the pre-v1 transition to unified millisecond inputs.\n */\nexport type TimestampSecsOptions = {\n  /**\n   * Timestamp in milliseconds since the Unix epoch.\n   * The generator stores whole seconds, so sub-second precision is truncated.\n   */\n  msecs?: number\n  /**\n   * Timestamp in seconds since the Unix epoch.\n   *\n   * @deprecated Use `msecs` instead. Will be removed at v1-rc.\n   */\n  // TODO(v1-rc): remove this alias (tracked in docs/STABILITY.md).\n  secs?: number\n}\n\n/**\n * Resolve caller-provided timestamp options to whole seconds since the Unix\n * epoch, or `undefined` when neither option was supplied.\n *\n * `msecs` is the unified input and is truncated to whole seconds; `secs` is\n * the deprecated pre-v1 alias. Passing both is an error.\n *\n * TODO(v1-rc): drop the `secs` branch once the alias is removed.\n */\nexport function resolveTimestampSecs(\n  options: TimestampSecsOptions,\n  minSecs: number,\n  maxSecs: number,\n  strategy: IdGenerator,\n): number | undefined {\n  const { msecs, secs } = options\n\n  if (msecs !== undefined && secs !== undefined) {\n    throw new InvalidInputError('CONFLICTING_OPTIONS', 'Pass only one of `msecs` or `secs`, not both', { strategy })\n  }\n\n  if (msecs !== undefined) {\n    const minMsecs = minSecs * 1000\n    const maxMsecs = maxSecs * 1000 + 999\n    if (!isIntegerInRange(msecs, minMsecs, maxMsecs)) {\n      throw new InvalidInputError(\n        'TIMESTAMP_OUT_OF_RANGE',\n        `Timestamp must be an integer between ${minMsecs} and ${maxMsecs} milliseconds`,\n        { strategy },\n      )\n    }\n    return Math.floor(msecs / 1000)\n  }\n\n  if (secs !== undefined) {\n    if (!isIntegerInRange(secs, minSecs, maxSecs)) {\n      throw new InvalidInputError(\n        'TIMESTAMP_OUT_OF_RANGE',\n        `Timestamp must be an integer between ${minSecs} and ${maxSecs} seconds`,\n        { strategy },\n      )\n    }\n    return secs\n  }\n\n  return undefined\n}\n"],"mappings":"+FAgCA,SAAgB,EACd,EACA,EACA,EACA,EACoB,CACpB,GAAM,CAAE,QAAO,QAAS,EAExB,GAAI,IAAU,IAAA,IAAa,IAAS,IAAA,GAClC,MAAM,IAAI,EAAkB,sBAAuB,+CAAgD,CAAE,UAAS,CAAC,EAGjH,GAAI,IAAU,IAAA,GAAW,CACvB,IAAM,EAAW,EAAU,IACrB,EAAW,EAAU,IAAO,IAClC,GAAI,CAAC,EAAiB,EAAO,EAAU,CAAQ,EAC7C,MAAM,IAAI,EACR,yBACA,wCAAwC,EAAS,OAAO,EAAS,eACjE,CAAE,UAAS,CACb,EAEF,OAAO,KAAK,MAAM,EAAQ,GAAI,CAChC,CAEA,GAAI,IAAS,IAAA,GAAW,CACtB,GAAI,CAAC,EAAiB,EAAM,EAAS,CAAO,EAC1C,MAAM,IAAI,EACR,yBACA,wCAAwC,EAAQ,OAAO,EAAQ,UAC/D,CAAE,UAAS,CACb,EAEF,OAAO,CACT,CAGF"}

package/build/tsid/tsid.d.mts

@@ -1,4 +1,4 @@
-import { i as UniqueIdError, n as InvalidInputError, r as ParseError, t as BufferError } from "../errors-Dgoyi-ci.mjs";
+import { a as ParseError, i as InvalidInputError, o as UniqueIdError, t as BufferError } from "../errors-Da-8dh4J.mjs";
 
 //#region src/tsid/tsid.d.ts
 type TsidOptions = {

package/build/tsid/tsid.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"tsid.d.mts","names":[],"sources":["../../src/tsid/tsid.ts"],"mappings":";;;KAiCY,WAAA;;;AAAZ;;EAKE,KAAA;EALU;;;;EAUV,KAAA;;;AAiBA;AAGF;EAfE,IAAA;;;;;;EAMA,QAAA;;;;;;EAMA,OAAA;AAAA;AAAA,KAGU,IAAA;;gBAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,WAAA,cAAyB,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAErG,OAAA,GAAU,WAAA,EAAa,GAAA,cAAiB,MAAA;EAEzC,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA;EAEjB,QAAA,CAAS,EAAA;EAET,UAAA,CAAW,GAAA;EAEX,SAAA,CAAU,EAAA,UAAY,KAAA;EAEtB,OAAA,CAAQ,EAAA,YAAc,EAAA;EAEtB,GAAA;EAEA,GAAA;AAAA;;;;;;;AAAA;AA4PF;;;;AAAmB;;;;;;;;;;;;;;;;;;;;;;cAAN,IAAA,EAAM,IAAA"}
+{"version":3,"file":"tsid.d.mts","names":[],"sources":["../../src/tsid/tsid.ts"],"mappings":";;;KAiCY,WAAA;;;AAAZ;;EAKE,KAAA;EALU;;;;EAUV,KAAA;;;AAiBA;AAGF;EAfE,IAAA;;;;;;EAMA,QAAA;;;;;;EAMA,OAAA;AAAA;AAAA,KAGU,IAAA;;gBAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,WAAA,cAAyB,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAErG,OAAA,GAAU,WAAA,EAAa,GAAA,cAAiB,MAAA;EAEzC,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA;EAEjB,QAAA,CAAS,EAAA;EAET,UAAA,CAAW,GAAA;EAEX,SAAA,CAAU,EAAA,UAAY,KAAA;EAEtB,OAAA,CAAQ,EAAA,YAAc,EAAA;EAEtB,GAAA;EAEA,GAAA;AAAA;;;;;;;AAAA;AAmQF;;;;AAAmB;;;;;;;;;;;;;;;;;;;;;;cAAN,IAAA,EAAM,IAAA"}

package/build/tsid/tsid.mjs

@@ -1,2 +1,2 @@
-import{n as e}from"../random-Chp-Nkzi.mjs";import{n as t,t as n}from"../validation-CTNpXm94.mjs";import{BufferError as r,InvalidInputError as i,ParseError as a,UniqueIdError as o}from"../errors.mjs";const s=`0123456789ABCDEFGHJKMNPQRSTVWXYZ`,c=new Uint8Array(128).fill(255);for(let e=0;e<32;e+=1){let t=s[e],n=s.charCodeAt(e);c[n]=e,t>=`A`&&t<=`Z`&&(c[n+32]=e)}function l(e){let t=``;for(let n=0;n<13;n+=1){let r=BigInt(60-n*5),i=Number(e>>r&31n);t+=s[i]}return t}function u(e){if(e.length!==13)throw new a(`TSID_INVALID_LENGTH`,`TSID string must be 13 characters, got ${e.length}`);let t=0n;for(let n=0;n<13;n+=1){let r=e.charCodeAt(n),i=r<128?c[r]:255;if(i===255)throw new a(`TSID_INVALID_CHAR`,`Invalid TSID character: ${e[n]}`);if(n===0&&i>15)throw new a(`TSID_LEADING_CHAR_OUT_OF_RANGE`,`TSID leading character must be one of 0-9, A-F, got: ${e[n]}`);t=t<<5n|BigInt(i)}return t}const d=15778368e5,f=4095,p=(1n<<42n)-1n,m={node:void 0,msecs:-1/0,counter:0};function h(e,t,n,r){return e<<BigInt(22)|BigInt(t)<<BigInt(n)|BigInt(r)}function g(e,t,n){for(let r=0;r<8;r+=1)t[n+r]=Number(e>>BigInt((7-r)*8)&255n)}function _(t){let r=t.nodeBits??10;if(!n(r,0,20))throw new i(`TSID_NODE_BITS_OUT_OF_RANGE`,`nodeBits must be between 0 and 20`);let a=22-r,o=(1<<r)-1,s=(1<<a)-1,c=t.node;if(c!==void 0&&!n(c,0,o))throw new i(`TSID_NODE_OUT_OF_RANGE`,`node must be between 0 and ${o}`);let l=t.counter;if(l!==void 0&&!n(l,0,s))throw new i(`TSID_COUNTER_OUT_OF_RANGE`,`counter must be between 0 and ${s}`);let u=t.epoch??d;if(!Number.isInteger(u))throw new i(`TSID_EPOCH_INVALID`,`epoch must be a finite integer`);let f=t.msecs??Date.now();if(!Number.isInteger(f))throw new i(`TSID_TIMESTAMP_INVALID`,`msecs must be a finite integer`);let m=BigInt(f)-BigInt(u);if(m<0n||m>p)throw new i(`TSID_TIMESTAMP_OUT_OF_RANGE`,`msecs - epoch must be between 0 and ${p}`);return{msecsDiff:m,node:c??e()&o,counterBits:a,counter:l??e()&s}}function v(n,i,a=0){let o,s,c,l;if(n){let e=_(n);o=e.msecsDiff,s=e.node,c=e.counterBits,l=e.counter}else{m.node===void 0&&(m.node=e()&1023),s=m.node,c=12;let t=Date.now();t>m.msecs?(m.msecs=t,m.counter=e()&f):(m.counter+=1,m.counter>f&&(m.msecs+=1,m.counter=0)),l=m.counter,o=BigInt(m.msecs)-BigInt(d)}let u=h(o,s,c,l);if(i){if(!t(i,a,8))throw new r(`TSID_BUFFER_OUT_OF_BOUNDS`,`TSID byte range ${a}:${a+8-1} is out of buffer bounds`);return g(u,i,a),i}return u}function y(e){T(e);let t=new Uint8Array(8);return g(e,t,0),t}function b(e){if(e.length!==8)throw new r(`TSID_BYTES_INVALID_LENGTH`,`TSID bytes must be exactly 8 bytes, got ${e.length}`);let t=0n;for(let n=0;n<8;n+=1)t=t<<8n|BigInt(e[n]);return t}function x(e,t=d){if(T(e),!Number.isInteger(t))throw new i(`TSID_EPOCH_INVALID`,`epoch must be a finite integer`);return t+Number(e>>BigInt(22))}function S(e){return typeof e==`bigint`&&e>=0n&&e<=w}const C=0n,w=(1n<<64n)-1n;function T(e){if(e<C||e>w)throw new i(`TSID_VALUE_OUT_OF_RANGE`,`TSID value must be between ${C} and ${w}`)}function E(e){return T(e),l(e)}const D=Object.assign(v,{toBytes:y,fromBytes:b,toString:E,fromString:u,timestamp:x,isValid:S,NIL:C,MAX:w});export{r as BufferError,i as InvalidInputError,a as ParseError,o as UniqueIdError,D as tsid};
+import{n as e}from"../random-Chp-Nkzi.mjs";import{n as t,t as n}from"../validation-CTNpXm94.mjs";import{BufferError as r,InvalidInputError as i,ParseError as a,UniqueIdError as o}from"../errors.mjs";const s=`0123456789ABCDEFGHJKMNPQRSTVWXYZ`,c=new Uint8Array(128).fill(255);for(let e=0;e<32;e+=1){let t=s[e],n=s.charCodeAt(e);c[n]=e,t>=`A`&&t<=`Z`&&(c[n+32]=e)}function l(e){let t=``;for(let n=0;n<13;n+=1){let r=BigInt(60-n*5),i=Number(e>>r&31n);t+=s[i]}return t}function u(e){if(e.length!==13)throw new a(`INVALID_LENGTH`,`TSID string must be 13 characters, got ${e.length}`,{strategy:`tsid`});let t=0n;for(let n=0;n<13;n+=1){let r=e.charCodeAt(n),i=r<128?c[r]:255;if(i===255)throw new a(`INVALID_CHAR`,`Invalid TSID character: ${e[n]}`,{strategy:`tsid`});if(n===0&&i>15)throw new a(`VALUE_OUT_OF_RANGE`,`TSID leading character must be one of 0-9, A-F, got: ${e[n]}`,{strategy:`tsid`});t=t<<5n|BigInt(i)}return t}const d=15778368e5,f=4095,p=(1n<<42n)-1n,m={node:void 0,msecs:-1/0,counter:0};function h(e,t,n,r){return e<<BigInt(22)|BigInt(t)<<BigInt(n)|BigInt(r)}function g(e,t,n){for(let r=0;r<8;r+=1)t[n+r]=Number(e>>BigInt((7-r)*8)&255n)}function _(t){let r=t.nodeBits??10;if(!n(r,0,20))throw new i(`NODE_BITS_OUT_OF_RANGE`,`nodeBits must be between 0 and 20`,{strategy:`tsid`});let a=22-r,o=(1<<r)-1,s=(1<<a)-1,c=t.node;if(c!==void 0&&!n(c,0,o))throw new i(`NODE_OUT_OF_RANGE`,`node must be between 0 and ${o}`,{strategy:`tsid`});let l=t.counter;if(l!==void 0&&!n(l,0,s))throw new i(`COUNTER_OUT_OF_RANGE`,`counter must be between 0 and ${s}`,{strategy:`tsid`});let u=t.epoch??d;if(!Number.isInteger(u))throw new i(`EPOCH_INVALID`,`epoch must be a finite integer`,{strategy:`tsid`});let f=t.msecs??Date.now();if(!Number.isInteger(f))throw new i(`TIMESTAMP_OUT_OF_RANGE`,`msecs must be a finite integer`,{strategy:`tsid`});let m=BigInt(f)-BigInt(u);if(m<0n||m>p)throw new i(`TIMESTAMP_OUT_OF_RANGE`,`msecs - epoch must be between 0 and ${p}`,{strategy:`tsid`});return{msecsDiff:m,node:c??e()&o,counterBits:a,counter:l??e()&s}}function v(n,i,a=0){let o,s,c,l;if(n){let e=_(n);o=e.msecsDiff,s=e.node,c=e.counterBits,l=e.counter}else{m.node===void 0&&(m.node=e()&1023),s=m.node,c=12;let t=Date.now();t>m.msecs?(m.msecs=t,m.counter=e()&f):(m.counter+=1,m.counter>f&&(m.msecs+=1,m.counter=0)),l=m.counter,o=BigInt(m.msecs)-BigInt(d)}let u=h(o,s,c,l);if(i){if(!t(i,a,8))throw new r(`BUFFER_OUT_OF_BOUNDS`,`TSID byte range ${a}:${a+8-1} is out of buffer bounds`,{strategy:`tsid`});return g(u,i,a),i}return u}function y(e){T(e);let t=new Uint8Array(8);return g(e,t,0),t}function b(e){if(e.length!==8)throw new r(`BYTES_INVALID_LENGTH`,`TSID bytes must be exactly 8 bytes, got ${e.length}`,{strategy:`tsid`});let t=0n;for(let n=0;n<8;n+=1)t=t<<8n|BigInt(e[n]);return t}function x(e,t=d){if(T(e),!Number.isInteger(t))throw new i(`EPOCH_INVALID`,`epoch must be a finite integer`,{strategy:`tsid`});return t+Number(e>>BigInt(22))}function S(e){return typeof e==`bigint`&&e>=0n&&e<=w}const C=0n,w=(1n<<64n)-1n;function T(e){if(e<C||e>w)throw new i(`VALUE_OUT_OF_RANGE`,`TSID value must be between ${C} and ${w}`,{strategy:`tsid`})}function E(e){return T(e),l(e)}const D=Object.assign(v,{toBytes:y,fromBytes:b,toString:E,fromString:u,timestamp:x,isValid:S,NIL:C,MAX:w});export{r as BufferError,i as InvalidInputError,a as ParseError,o as UniqueIdError,D as tsid};
 //# sourceMappingURL=tsid.mjs.map

package/build/tsid/tsid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tsid.mjs","names":[],"sources":["../../src/tsid/crockford64.ts","../../src/tsid/tsid.ts"],"sourcesContent":["import { ParseError } from '../errors'\n\n/**\n * Crockford Base32 codec for TSID, operating directly on the primary `bigint`\n * value rather than an intermediate byte array (unlike ulid/crockford.ts) -\n * tsid's primary type never routes through a `Uint8Array` during string\n * conversion.\n *\n * TSID binary format: 64 bits (8 bytes), encoded as 13 Crockford Base32 characters.\n * 13 chars * 5 bits = 65 bits of capacity for a 64-bit value, leaving exactly 1 bit\n * of headroom on the leading character. That headroom bit is always 0, so the\n * leading character only carries 4 significant real bits (values 0-15, i.e. the\n * alphabet's first 16 symbols \"0\"-\"9\"/\"A\"-\"F\") rather than the full 32-symbol\n * range - the same overflow-prevention technique ULID uses for its own leading\n * `[0-7]` restriction (2 headroom bits there vs 1 here). Confirmed against\n * `tsid-ts`'s own `toCanonicalString`: `(number >> BigInt(60 - i * 5)) & 0x1f`.\n */\n\nconst TSID_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\nconst TSID_STRING_LEN = 13\nconst TSID_LEADING_MAX = 15 // 4 significant bits on the leading character (see above)\n\n// Pre-computed decode table (case-insensitive) covering ASCII, so lookups never\n// go out of bounds and a single `=== 255` check rejects invalid input.\nconst DECODING = new Uint8Array(128).fill(255)\nfor (let i = 0; i < TSID_ALPHABET.length; i += 1) {\n  const char = TSID_ALPHABET[i]\n  const upperCode = TSID_ALPHABET.charCodeAt(i)\n  DECODING[upperCode] = i\n  // Only letters have a lowercase counterpart - applying +32 to digit codes\n  // would land on unrelated uppercase letters (e.g. '5' + 32 -> 'U', which is\n  // excluded from this alphabet and would never get overwritten back to 255).\n  if (char >= 'A' && char <= 'Z') {\n    DECODING[upperCode + 32] = i\n  }\n}\n\n/**\n * Encode a TSID `bigint` value to its 13-character canonical Crockford Base32 string.\n */\nexport function encodeTsidString(value: bigint): string {\n  let result = ''\n  for (let i = 0; i < TSID_STRING_LEN; i += 1) {\n    const shift = BigInt(60 - i * 5)\n    const group = Number((value >> shift) & 0x1fn)\n    result += TSID_ALPHABET[group]\n  }\n  return result\n}\n\n/**\n * Decode a 13-character canonical Crockford Base32 string to a TSID `bigint` value.\n */\nexport function decodeTsidString(str: string): bigint {\n  if (str.length !== TSID_STRING_LEN) {\n    throw new ParseError('TSID_INVALID_LENGTH', `TSID string must be ${TSID_STRING_LEN} characters, got ${str.length}`)\n  }\n\n  let value = 0n\n  for (let i = 0; i < TSID_STRING_LEN; i += 1) {\n    const code = str.charCodeAt(i)\n    const group = code < 128 ? DECODING[code] : 255\n    if (group === 255) {\n      throw new ParseError('TSID_INVALID_CHAR', `Invalid TSID character: ${str[i]}`)\n    }\n    if (i === 0 && group > TSID_LEADING_MAX) {\n      throw new ParseError(\n        'TSID_LEADING_CHAR_OUT_OF_RANGE',\n        `TSID leading character must be one of 0-9, A-F, got: ${str[i]}`,\n      )\n    }\n    value = (value << 5n) | BigInt(group)\n  }\n  return value\n}\n","import { randomUint32 } from '../common/random'\nimport { isIntegerInRange, isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeTsidString, encodeTsidString } from './crockford64'\n\n/**\n * TSID (Time-Sorted Unique Identifier)\n *\n * A 64-bit Snowflake-style identifier consisting of:\n * - 42 bits: millisecond timestamp relative to a custom epoch (default 2020-01-01T00:00:00.000Z)\n * - 10 bits: node ID (default; configurable via `nodeBits`)\n * - 12 bits: per-millisecond counter (default; `22 - nodeBits`)\n *\n * Unlike every other uniku generator, `tsid()` returns a `bigint` by default -\n * this is a deliberate design decision reflecting that TSID's value proposition\n * is native numeric storage (e.g. a database BIGINT primary key), not a\n * string-first identifier that happens to have a byte encoding. `toString`/\n * `fromString` are the boundary conversions to/from the 13-character canonical\n * Crockford Base32 string.\n *\n * Encoded as 8 big-endian bytes in buffer mode.\n */\n\nconst TSID_EPOCH = 1577836800000 // 2020-01-01T00:00:00.000Z\nconst TSID_BYTES = 8\nconst RANDOM_BITS = 22 // combined node + counter bits\nconst DEFAULT_NODE_BITS = 10\nconst DEFAULT_COUNTER_BITS = RANDOM_BITS - DEFAULT_NODE_BITS\nconst DEFAULT_NODE_MASK = (1 << DEFAULT_NODE_BITS) - 1\nconst DEFAULT_COUNTER_MASK = (1 << DEFAULT_COUNTER_BITS) - 1\nconst MAX_NODE_BITS = 20\nconst MAX_TIMESTAMP_DIFF = (1n << 42n) - 1n\n\nexport type TsidOptions = {\n  /**\n   * Timestamp in milliseconds since Unix epoch.\n   * Defaults to Date.now().\n   */\n  msecs?: number\n  /**\n   * Custom epoch in milliseconds since Unix epoch.\n   * Defaults to 1577836800000 (2020-01-01T00:00:00.000Z).\n   */\n  epoch?: number\n  /**\n   * Node ID (0 to 2^nodeBits - 1).\n   * Defaults to a lazily-initialized, persistent random value.\n   */\n  node?: number\n  /**\n   * Number of bits allocated to the node ID (0-20).\n   * The remaining bits (22 - nodeBits) are allocated to the counter.\n   * Defaults to 10.\n   */\n  nodeBits?: number\n  /**\n   * Per-millisecond counter (0 to 2^(22 - nodeBits) - 1).\n   * Defaults to a fresh random value on a new millisecond, or the previous\n   * value incremented by 1 within the same millisecond.\n   */\n  counter?: number\n}\n\nexport type Tsid = {\n  /** Generate a time-sorted TSID bigint. */\n  (): bigint\n  /** Generate a TSID with explicit options or write its 8 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: TsidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a TSID bigint with optional timestamp, epoch, node, or counter controls. */\n  (options?: TsidOptions, buf?: undefined, offset?: number): bigint\n  /** Convert a TSID bigint to its canonical 8-byte representation. */\n  toBytes(id: bigint): Uint8Array\n  /** Convert 8 canonical TSID bytes to a TSID bigint. */\n  fromBytes(bytes: Uint8Array): bigint\n  /** Convert a TSID bigint to its canonical 13-character string. */\n  toString(id: bigint): string\n  /** Convert a canonical TSID string to a bigint. */\n  fromString(str: string): bigint\n  /** Read a TSID timestamp in milliseconds, using the supplied or default epoch. */\n  timestamp(id: bigint, epoch?: number): number\n  /** Return whether a value is a valid 64-bit TSID bigint. */\n  isValid(id: unknown): id is bigint\n  /** The nil TSID (all zeros) */\n  NIL: bigint\n  /** The max TSID (maximum valid 64-bit value) */\n  MAX: bigint\n}\n\ntype TsidState = {\n  node: number | undefined\n  msecs: number\n  counter: number\n}\n\n/**\n * Module-level state for the lazily-initialized persistent node ID and the\n * per-millisecond-reset counter.\n *\n * IMPORTANT: This state persists across all tsid() 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`, `epoch`, `node`, `nodeBits`, or\n *   `counter` via options - doing so bypasses `state` entirely.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: TsidState = {\n  node: undefined,\n  msecs: -Infinity,\n  counter: 0,\n}\n\nfunction pack(msecsDiff: bigint, node: number, counterBits: number, counter: number): bigint {\n  return (msecsDiff << BigInt(RANDOM_BITS)) | (BigInt(node) << BigInt(counterBits)) | BigInt(counter)\n}\n\nfunction writeTsidBytesUnchecked(value: bigint, buf: Uint8Array, offset: number): void {\n  for (let i = 0; i < TSID_BYTES; i += 1) {\n    buf[offset + i] = Number((value >> BigInt((TSID_BYTES - 1 - i) * 8)) & 0xffn)\n  }\n}\n\ntype ResolvedTsidOptions = {\n  msecsDiff: bigint\n  node: number\n  counterBits: number\n  counter: number\n}\n\nfunction resolveTsidOptions(options: TsidOptions): ResolvedTsidOptions {\n  const nodeBits = options.nodeBits ?? DEFAULT_NODE_BITS\n  if (!isIntegerInRange(nodeBits, 0, MAX_NODE_BITS)) {\n    throw new InvalidInputError('TSID_NODE_BITS_OUT_OF_RANGE', `nodeBits must be between 0 and ${MAX_NODE_BITS}`)\n  }\n\n  const counterBits = RANDOM_BITS - nodeBits\n  const nodeMask = (1 << nodeBits) - 1\n  const counterMask = (1 << counterBits) - 1\n  const optNode = options.node\n  if (optNode !== undefined && !isIntegerInRange(optNode, 0, nodeMask)) {\n    throw new InvalidInputError('TSID_NODE_OUT_OF_RANGE', `node must be between 0 and ${nodeMask}`)\n  }\n\n  const optCounter = options.counter\n  if (optCounter !== undefined && !isIntegerInRange(optCounter, 0, counterMask)) {\n    throw new InvalidInputError('TSID_COUNTER_OUT_OF_RANGE', `counter must be between 0 and ${counterMask}`)\n  }\n\n  const epoch = options.epoch ?? TSID_EPOCH\n  if (!Number.isInteger(epoch)) {\n    throw new InvalidInputError('TSID_EPOCH_INVALID', 'epoch must be a finite integer')\n  }\n  const msecs = options.msecs ?? Date.now()\n  if (!Number.isInteger(msecs)) {\n    throw new InvalidInputError('TSID_TIMESTAMP_INVALID', 'msecs must be a finite integer')\n  }\n  const msecsDiff = BigInt(msecs) - BigInt(epoch)\n  if (msecsDiff < 0n || msecsDiff > MAX_TIMESTAMP_DIFF) {\n    throw new InvalidInputError(\n      'TSID_TIMESTAMP_OUT_OF_RANGE',\n      `msecs - epoch must be between 0 and ${MAX_TIMESTAMP_DIFF}`,\n    )\n  }\n\n  return {\n    msecsDiff,\n    node: optNode ?? randomUint32() & nodeMask,\n    counterBits,\n    counter: optCounter ?? randomUint32() & counterMask,\n  }\n}\n\n/*\n * Overload: no buffer => return a TSID bigint.\n */\nfunction tsidFn(options?: TsidOptions, buf?: undefined, offset?: number): bigint\n/*\n * Overload: caller provides a buffer slice to fill with TSID bytes.\n */\nfunction tsidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: TsidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction tsidFn<TBuf extends Uint8Array = Uint8Array>(options?: TsidOptions, buf?: TBuf, offset = 0): bigint | TBuf {\n  let msecsDiff: bigint\n  let node: number\n  let counterBits: number\n  let counter: number\n\n  if (options) {\n    const resolved = resolveTsidOptions(options)\n    msecsDiff = resolved.msecsDiff\n    node = resolved.node\n    counterBits = resolved.counterBits\n    counter = resolved.counter\n  } else {\n    // Lazily initialize the persistent node ID on first no-option call.\n    if (state.node === undefined) {\n      state.node = randomUint32() & DEFAULT_NODE_MASK\n    }\n    node = state.node\n    counterBits = DEFAULT_COUNTER_BITS\n\n    /**\n     * Note: by default, Cloudflare Workers \"freezes\" time during request handling\n     * to prevent side-channel attacks, so Date.now() returns the same value for\n     * the entire duration of a request. Monotonic ordering within such a request\n     * relies entirely on the counter (and its clock-drift-ahead overflow below).\n     */\n    const now = Date.now()\n    if (now > state.msecs) {\n      state.msecs = now\n      state.counter = randomUint32() & DEFAULT_COUNTER_MASK\n    } else {\n      state.counter += 1\n      if (state.counter > DEFAULT_COUNTER_MASK) {\n        // Counter overflowed within this real millisecond: advance the internal\n        // virtual timestamp ahead of wall-clock time rather than throwing. A\n        // 12-bit counter (4096 values/ms) is a realistic throughput ceiling.\n        state.msecs += 1\n        state.counter = 0\n      }\n    }\n    counter = state.counter\n    msecsDiff = BigInt(state.msecs) - BigInt(TSID_EPOCH)\n  }\n\n  const packed = pack(msecsDiff, node, counterBits, counter)\n\n  if (buf) {\n    if (!isWritableRange(buf, offset, TSID_BYTES)) {\n      throw new BufferError(\n        'TSID_BUFFER_OUT_OF_BOUNDS',\n        `TSID byte range ${offset}:${offset + TSID_BYTES - 1} is out of buffer bounds`,\n      )\n    }\n    writeTsidBytesUnchecked(packed, buf, offset)\n    return buf\n  }\n\n  return packed\n}\n\n/**\n * Convert a TSID bigint to 8 bytes.\n */\nfunction toBytes(id: bigint): Uint8Array {\n  assertValidTsid(id)\n  const bytes = new Uint8Array(TSID_BYTES)\n  writeTsidBytesUnchecked(id, bytes, 0)\n  return bytes\n}\n\n/**\n * Convert 8 bytes to a TSID bigint.\n */\nfunction fromBytes(bytes: Uint8Array): bigint {\n  if (bytes.length !== TSID_BYTES) {\n    throw new BufferError(\n      'TSID_BYTES_INVALID_LENGTH',\n      `TSID bytes must be exactly ${TSID_BYTES} bytes, got ${bytes.length}`,\n    )\n  }\n\n  let value = 0n\n  for (let i = 0; i < TSID_BYTES; i += 1) {\n    value = (value << 8n) | BigInt(bytes[i])\n  }\n  return value\n}\n\n/**\n * Extract the timestamp (milliseconds since Unix epoch) from a TSID.\n * The epoch is not self-describing in the packed value - pass the same\n * `epoch` used at generation time if it was overridden from the default.\n */\nfunction timestamp(id: bigint, epoch: number = TSID_EPOCH): number {\n  assertValidTsid(id)\n  if (!Number.isInteger(epoch)) {\n    throw new InvalidInputError('TSID_EPOCH_INVALID', 'epoch must be a finite integer')\n  }\n  return epoch + Number(id >> BigInt(RANDOM_BITS))\n}\n\n/**\n * Validate that a value is a TSID bigint within the 64-bit range.\n */\nfunction isValid(id: unknown): id is bigint {\n  return typeof id === 'bigint' && id >= 0n && id <= MAX\n}\n\nconst NIL = 0n\nconst MAX = (1n << 64n) - 1n\n\nfunction assertValidTsid(id: bigint): void {\n  if (id < NIL || id > MAX) {\n    throw new InvalidInputError('TSID_VALUE_OUT_OF_RANGE', `TSID value must be between ${NIL} and ${MAX}`)\n  }\n}\n\nfunction toString(id: bigint): string {\n  assertValidTsid(id)\n  return encodeTsidString(id)\n}\n\n/**\n * Generate a TSID bigint or write the bytes into a buffer.\n *\n * TSID (Time-Sorted Unique Identifier) is a 64-bit Snowflake-style identifier\n * combining a millisecond timestamp, a node ID, and a per-millisecond counter.\n * Unlike every other uniku generator, it returns a `bigint` by default, since\n * TSID's entire value proposition is native numeric storage (e.g. a database\n * BIGINT primary key).\n *\n * @example\n * ```ts\n * import { tsid } from 'uniku/tsid'\n *\n * const id = tsid()\n * // => 862301223059968074n\n *\n * // Canonical string form\n * const str = tsid.toString(id)\n * // => \"0QXW2CK4XZM2A\"\n * tsid.fromString(str) === id // true\n *\n * // Extract timestamp\n * const ts = tsid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * tsid.isValid(id) // true\n *\n * // Convert to/from bytes (8 bytes)\n * const bytes = tsid.toBytes(id)\n * const restored = tsid.fromBytes(bytes)\n * ```\n */\nexport const tsid: Tsid = Object.assign(tsidFn, {\n  toBytes,\n  fromBytes,\n  toString,\n  fromString: decodeTsidString,\n  timestamp,\n  isValid,\n  NIL,\n  MAX,\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"tsid.mjs","names":[],"sources":["../../src/tsid/crockford64.ts","../../src/tsid/tsid.ts"],"sourcesContent":["import { ParseError } from '../errors'\n\n/**\n * Crockford Base32 codec for TSID, operating directly on the primary `bigint`\n * value rather than an intermediate byte array (unlike ulid/crockford.ts) -\n * tsid's primary type never routes through a `Uint8Array` during string\n * conversion.\n *\n * TSID binary format: 64 bits (8 bytes), encoded as 13 Crockford Base32 characters.\n * 13 chars * 5 bits = 65 bits of capacity for a 64-bit value, leaving exactly 1 bit\n * of headroom on the leading character. That headroom bit is always 0, so the\n * leading character only carries 4 significant real bits (values 0-15, i.e. the\n * alphabet's first 16 symbols \"0\"-\"9\"/\"A\"-\"F\") rather than the full 32-symbol\n * range - the same overflow-prevention technique ULID uses for its own leading\n * `[0-7]` restriction (2 headroom bits there vs 1 here). Confirmed against\n * `tsid-ts`'s own `toCanonicalString`: `(number >> BigInt(60 - i * 5)) & 0x1f`.\n */\n\nconst TSID_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\nconst TSID_STRING_LEN = 13\nconst TSID_LEADING_MAX = 15 // 4 significant bits on the leading character (see above)\n\n// Pre-computed decode table (case-insensitive) covering ASCII, so lookups never\n// go out of bounds and a single `=== 255` check rejects invalid input.\nconst DECODING = new Uint8Array(128).fill(255)\nfor (let i = 0; i < TSID_ALPHABET.length; i += 1) {\n  const char = TSID_ALPHABET[i]\n  const upperCode = TSID_ALPHABET.charCodeAt(i)\n  DECODING[upperCode] = i\n  // Only letters have a lowercase counterpart - applying +32 to digit codes\n  // would land on unrelated uppercase letters (e.g. '5' + 32 -> 'U', which is\n  // excluded from this alphabet and would never get overwritten back to 255).\n  if (char >= 'A' && char <= 'Z') {\n    DECODING[upperCode + 32] = i\n  }\n}\n\n/**\n * Encode a TSID `bigint` value to its 13-character canonical Crockford Base32 string.\n */\nexport function encodeTsidString(value: bigint): string {\n  let result = ''\n  for (let i = 0; i < TSID_STRING_LEN; i += 1) {\n    const shift = BigInt(60 - i * 5)\n    const group = Number((value >> shift) & 0x1fn)\n    result += TSID_ALPHABET[group]\n  }\n  return result\n}\n\n/**\n * Decode a 13-character canonical Crockford Base32 string to a TSID `bigint` value.\n */\nexport function decodeTsidString(str: string): bigint {\n  if (str.length !== TSID_STRING_LEN) {\n    throw new ParseError('INVALID_LENGTH', `TSID string must be ${TSID_STRING_LEN} characters, got ${str.length}`, {\n      strategy: 'tsid',\n    })\n  }\n\n  let value = 0n\n  for (let i = 0; i < TSID_STRING_LEN; i += 1) {\n    const code = str.charCodeAt(i)\n    const group = code < 128 ? DECODING[code] : 255\n    if (group === 255) {\n      throw new ParseError('INVALID_CHAR', `Invalid TSID character: ${str[i]}`, { strategy: 'tsid' })\n    }\n    if (i === 0 && group > TSID_LEADING_MAX) {\n      throw new ParseError('VALUE_OUT_OF_RANGE', `TSID leading character must be one of 0-9, A-F, got: ${str[i]}`, {\n        strategy: 'tsid',\n      })\n    }\n    value = (value << 5n) | BigInt(group)\n  }\n  return value\n}\n","import { randomUint32 } from '../common/random'\nimport { isIntegerInRange, isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { decodeTsidString, encodeTsidString } from './crockford64'\n\n/**\n * TSID (Time-Sorted Unique Identifier)\n *\n * A 64-bit Snowflake-style identifier consisting of:\n * - 42 bits: millisecond timestamp relative to a custom epoch (default 2020-01-01T00:00:00.000Z)\n * - 10 bits: node ID (default; configurable via `nodeBits`)\n * - 12 bits: per-millisecond counter (default; `22 - nodeBits`)\n *\n * Unlike every other uniku generator, `tsid()` returns a `bigint` by default -\n * this is a deliberate design decision reflecting that TSID's value proposition\n * is native numeric storage (e.g. a database BIGINT primary key), not a\n * string-first identifier that happens to have a byte encoding. `toString`/\n * `fromString` are the boundary conversions to/from the 13-character canonical\n * Crockford Base32 string.\n *\n * Encoded as 8 big-endian bytes in buffer mode.\n */\n\nconst TSID_EPOCH = 1577836800000 // 2020-01-01T00:00:00.000Z\nconst TSID_BYTES = 8\nconst RANDOM_BITS = 22 // combined node + counter bits\nconst DEFAULT_NODE_BITS = 10\nconst DEFAULT_COUNTER_BITS = RANDOM_BITS - DEFAULT_NODE_BITS\nconst DEFAULT_NODE_MASK = (1 << DEFAULT_NODE_BITS) - 1\nconst DEFAULT_COUNTER_MASK = (1 << DEFAULT_COUNTER_BITS) - 1\nconst MAX_NODE_BITS = 20\nconst MAX_TIMESTAMP_DIFF = (1n << 42n) - 1n\n\nexport type TsidOptions = {\n  /**\n   * Timestamp in milliseconds since Unix epoch.\n   * Defaults to Date.now().\n   */\n  msecs?: number\n  /**\n   * Custom epoch in milliseconds since Unix epoch.\n   * Defaults to 1577836800000 (2020-01-01T00:00:00.000Z).\n   */\n  epoch?: number\n  /**\n   * Node ID (0 to 2^nodeBits - 1).\n   * Defaults to a lazily-initialized, persistent random value.\n   */\n  node?: number\n  /**\n   * Number of bits allocated to the node ID (0-20).\n   * The remaining bits (22 - nodeBits) are allocated to the counter.\n   * Defaults to 10.\n   */\n  nodeBits?: number\n  /**\n   * Per-millisecond counter (0 to 2^(22 - nodeBits) - 1).\n   * Defaults to a fresh random value on a new millisecond, or the previous\n   * value incremented by 1 within the same millisecond.\n   */\n  counter?: number\n}\n\nexport type Tsid = {\n  /** Generate a time-sorted TSID bigint. */\n  (): bigint\n  /** Generate a TSID with explicit options or write its 8 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: TsidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a TSID bigint with optional timestamp, epoch, node, or counter controls. */\n  (options?: TsidOptions, buf?: undefined, offset?: number): bigint\n  /** Convert a TSID bigint to its canonical 8-byte representation. */\n  toBytes(id: bigint): Uint8Array\n  /** Convert 8 canonical TSID bytes to a TSID bigint. */\n  fromBytes(bytes: Uint8Array): bigint\n  /** Convert a TSID bigint to its canonical 13-character string. */\n  toString(id: bigint): string\n  /** Convert a canonical TSID string to a bigint. */\n  fromString(str: string): bigint\n  /** Read a TSID timestamp in milliseconds, using the supplied or default epoch. */\n  timestamp(id: bigint, epoch?: number): number\n  /** Return whether a value is a valid 64-bit TSID bigint. */\n  isValid(id: unknown): id is bigint\n  /** The nil TSID (all zeros) */\n  NIL: bigint\n  /** The max TSID (maximum valid 64-bit value) */\n  MAX: bigint\n}\n\ntype TsidState = {\n  node: number | undefined\n  msecs: number\n  counter: number\n}\n\n/**\n * Module-level state for the lazily-initialized persistent node ID and the\n * per-millisecond-reset counter.\n *\n * IMPORTANT: This state persists across all tsid() 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`, `epoch`, `node`, `nodeBits`, or\n *   `counter` via options - doing so bypasses `state` entirely.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: TsidState = {\n  node: undefined,\n  msecs: -Infinity,\n  counter: 0,\n}\n\nfunction pack(msecsDiff: bigint, node: number, counterBits: number, counter: number): bigint {\n  return (msecsDiff << BigInt(RANDOM_BITS)) | (BigInt(node) << BigInt(counterBits)) | BigInt(counter)\n}\n\nfunction writeTsidBytesUnchecked(value: bigint, buf: Uint8Array, offset: number): void {\n  for (let i = 0; i < TSID_BYTES; i += 1) {\n    buf[offset + i] = Number((value >> BigInt((TSID_BYTES - 1 - i) * 8)) & 0xffn)\n  }\n}\n\ntype ResolvedTsidOptions = {\n  msecsDiff: bigint\n  node: number\n  counterBits: number\n  counter: number\n}\n\nfunction resolveTsidOptions(options: TsidOptions): ResolvedTsidOptions {\n  const nodeBits = options.nodeBits ?? DEFAULT_NODE_BITS\n  if (!isIntegerInRange(nodeBits, 0, MAX_NODE_BITS)) {\n    throw new InvalidInputError('NODE_BITS_OUT_OF_RANGE', `nodeBits must be between 0 and ${MAX_NODE_BITS}`, {\n      strategy: 'tsid',\n    })\n  }\n\n  const counterBits = RANDOM_BITS - nodeBits\n  const nodeMask = (1 << nodeBits) - 1\n  const counterMask = (1 << counterBits) - 1\n  const optNode = options.node\n  if (optNode !== undefined && !isIntegerInRange(optNode, 0, nodeMask)) {\n    throw new InvalidInputError('NODE_OUT_OF_RANGE', `node must be between 0 and ${nodeMask}`, { strategy: 'tsid' })\n  }\n\n  const optCounter = options.counter\n  if (optCounter !== undefined && !isIntegerInRange(optCounter, 0, counterMask)) {\n    throw new InvalidInputError('COUNTER_OUT_OF_RANGE', `counter must be between 0 and ${counterMask}`, {\n      strategy: 'tsid',\n    })\n  }\n\n  const epoch = options.epoch ?? TSID_EPOCH\n  if (!Number.isInteger(epoch)) {\n    throw new InvalidInputError('EPOCH_INVALID', 'epoch must be a finite integer', { strategy: 'tsid' })\n  }\n  const msecs = options.msecs ?? Date.now()\n  if (!Number.isInteger(msecs)) {\n    throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', 'msecs must be a finite integer', { strategy: 'tsid' })\n  }\n  const msecsDiff = BigInt(msecs) - BigInt(epoch)\n  if (msecsDiff < 0n || msecsDiff > MAX_TIMESTAMP_DIFF) {\n    throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', `msecs - epoch must be between 0 and ${MAX_TIMESTAMP_DIFF}`, {\n      strategy: 'tsid',\n    })\n  }\n\n  return {\n    msecsDiff,\n    node: optNode ?? randomUint32() & nodeMask,\n    counterBits,\n    counter: optCounter ?? randomUint32() & counterMask,\n  }\n}\n\n/*\n * Overload: no buffer => return a TSID bigint.\n */\nfunction tsidFn(options?: TsidOptions, buf?: undefined, offset?: number): bigint\n/*\n * Overload: caller provides a buffer slice to fill with TSID bytes.\n */\nfunction tsidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: TsidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction tsidFn<TBuf extends Uint8Array = Uint8Array>(options?: TsidOptions, buf?: TBuf, offset = 0): bigint | TBuf {\n  let msecsDiff: bigint\n  let node: number\n  let counterBits: number\n  let counter: number\n\n  if (options) {\n    const resolved = resolveTsidOptions(options)\n    msecsDiff = resolved.msecsDiff\n    node = resolved.node\n    counterBits = resolved.counterBits\n    counter = resolved.counter\n  } else {\n    // Lazily initialize the persistent node ID on first no-option call.\n    if (state.node === undefined) {\n      state.node = randomUint32() & DEFAULT_NODE_MASK\n    }\n    node = state.node\n    counterBits = DEFAULT_COUNTER_BITS\n\n    /**\n     * Note: by default, Cloudflare Workers \"freezes\" time during request handling\n     * to prevent side-channel attacks, so Date.now() returns the same value for\n     * the entire duration of a request. Monotonic ordering within such a request\n     * relies entirely on the counter (and its clock-drift-ahead overflow below).\n     */\n    const now = Date.now()\n    if (now > state.msecs) {\n      state.msecs = now\n      state.counter = randomUint32() & DEFAULT_COUNTER_MASK\n    } else {\n      state.counter += 1\n      if (state.counter > DEFAULT_COUNTER_MASK) {\n        // Counter overflowed within this real millisecond: advance the internal\n        // virtual timestamp ahead of wall-clock time rather than throwing. A\n        // 12-bit counter (4096 values/ms) is a realistic throughput ceiling.\n        state.msecs += 1\n        state.counter = 0\n      }\n    }\n    counter = state.counter\n    msecsDiff = BigInt(state.msecs) - BigInt(TSID_EPOCH)\n  }\n\n  const packed = pack(msecsDiff, node, counterBits, counter)\n\n  if (buf) {\n    if (!isWritableRange(buf, offset, TSID_BYTES)) {\n      throw new BufferError(\n        'BUFFER_OUT_OF_BOUNDS',\n        `TSID byte range ${offset}:${offset + TSID_BYTES - 1} is out of buffer bounds`,\n        { strategy: 'tsid' },\n      )\n    }\n    writeTsidBytesUnchecked(packed, buf, offset)\n    return buf\n  }\n\n  return packed\n}\n\n/**\n * Convert a TSID bigint to 8 bytes.\n */\nfunction toBytes(id: bigint): Uint8Array {\n  assertValidTsid(id)\n  const bytes = new Uint8Array(TSID_BYTES)\n  writeTsidBytesUnchecked(id, bytes, 0)\n  return bytes\n}\n\n/**\n * Convert 8 bytes to a TSID bigint.\n */\nfunction fromBytes(bytes: Uint8Array): bigint {\n  if (bytes.length !== TSID_BYTES) {\n    throw new BufferError(\n      'BYTES_INVALID_LENGTH',\n      `TSID bytes must be exactly ${TSID_BYTES} bytes, got ${bytes.length}`,\n      { strategy: 'tsid' },\n    )\n  }\n\n  let value = 0n\n  for (let i = 0; i < TSID_BYTES; i += 1) {\n    value = (value << 8n) | BigInt(bytes[i])\n  }\n  return value\n}\n\n/**\n * Extract the timestamp (milliseconds since Unix epoch) from a TSID.\n * The epoch is not self-describing in the packed value - pass the same\n * `epoch` used at generation time if it was overridden from the default.\n */\nfunction timestamp(id: bigint, epoch: number = TSID_EPOCH): number {\n  assertValidTsid(id)\n  if (!Number.isInteger(epoch)) {\n    throw new InvalidInputError('EPOCH_INVALID', 'epoch must be a finite integer', { strategy: 'tsid' })\n  }\n  return epoch + Number(id >> BigInt(RANDOM_BITS))\n}\n\n/**\n * Validate that a value is a TSID bigint within the 64-bit range.\n */\nfunction isValid(id: unknown): id is bigint {\n  return typeof id === 'bigint' && id >= 0n && id <= MAX\n}\n\nconst NIL = 0n\nconst MAX = (1n << 64n) - 1n\n\nfunction assertValidTsid(id: bigint): void {\n  if (id < NIL || id > MAX) {\n    throw new InvalidInputError('VALUE_OUT_OF_RANGE', `TSID value must be between ${NIL} and ${MAX}`, {\n      strategy: 'tsid',\n    })\n  }\n}\n\nfunction toString(id: bigint): string {\n  assertValidTsid(id)\n  return encodeTsidString(id)\n}\n\n/**\n * Generate a TSID bigint or write the bytes into a buffer.\n *\n * TSID (Time-Sorted Unique Identifier) is a 64-bit Snowflake-style identifier\n * combining a millisecond timestamp, a node ID, and a per-millisecond counter.\n * Unlike every other uniku generator, it returns a `bigint` by default, since\n * TSID's entire value proposition is native numeric storage (e.g. a database\n * BIGINT primary key).\n *\n * @example\n * ```ts\n * import { tsid } from 'uniku/tsid'\n *\n * const id = tsid()\n * // => 862301223059968074n\n *\n * // Canonical string form\n * const str = tsid.toString(id)\n * // => \"0QXW2CK4XZM2A\"\n * tsid.fromString(str) === id // true\n *\n * // Extract timestamp\n * const ts = tsid.timestamp(id)\n * console.log(new Date(ts))\n *\n * // Validate\n * tsid.isValid(id) // true\n *\n * // Convert to/from bytes (8 bytes)\n * const bytes = tsid.toBytes(id)\n * const restored = tsid.fromBytes(bytes)\n * ```\n */\nexport const tsid: Tsid = Object.assign(tsidFn, {\n  toBytes,\n  fromBytes,\n  toString,\n  fromString: decodeTsidString,\n  timestamp,\n  isValid,\n  NIL,\n  MAX,\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/typeid/typeid.d.mts

@@ -1,10 +1,12 @@
-import { i as UniqueIdError, n as InvalidInputError, r as ParseError, t as BufferError } from "../errors-Dgoyi-ci.mjs";
+import { a as ParseError, i as InvalidInputError, o as UniqueIdError, t as BufferError } from "../errors-Da-8dh4J.mjs";
 import { UuidV7Options } from "../uuid/v7.mjs";
 
 //#region src/typeid/typeid.d.ts
 type TypeidOptions = UuidV7Options;
 type Typeid = {
-  /** Generate a TypeID from a lowercase entity prefix and a UUID v7 suffix. */(prefix: string, options?: TypeidOptions): string; /** Convert a TypeID's UUID v7 suffix to its canonical 16-byte representation. */
+  /** Generate a TypeID from a lowercase entity prefix and a UUID v7 suffix. */(prefix: string, options?: TypeidOptions): string; /** Generate a TypeID with explicit options or write its 16 canonical UUID v7 bytes into a caller-owned buffer. */
+  <TBuf extends Uint8Array = Uint8Array>(prefix: string, options: TypeidOptions | undefined, buf: TBuf, offset?: number): TBuf; /** Generate a TypeID string with optional timestamp, counter, or random bytes. */
+  (prefix: string, options?: TypeidOptions, buf?: undefined, offset?: number): string; /** Convert a TypeID's UUID v7 suffix to its canonical 16-byte representation. */
   toBytes(id: string): Uint8Array; /** Build a TypeID from a prefix and canonical UUID v7 bytes. */
   fromBytes(prefix: string, bytes: Uint8Array): string; /** Convert a TypeID to its UUID v7 string. */
   toUuid(id: string): string; /** Build a TypeID from a prefix and UUID v7 string. */

package/build/typeid/typeid.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"typeid.d.mts","names":[],"sources":["../../src/typeid/typeid.ts"],"mappings":";;;;KAIY,aAAA,GAAgB,aAAA;AAAA,KAEhB,MAAA;gFAET,MAAA,UAAgB,OAAA,GAAU,aAAA,WAJjB;EAMV,OAAA,CAAQ,EAAA,WAAa,UAAA,EANK;EAQ1B,SAAA,CAAU,MAAA,UAAgB,KAAA,EAAO,UAAA,WANnC;EAQE,MAAA,CAAO,EAAA;EAEP,QAAA,CAAS,MAAA,UAAgB,IAAA;EAEzB,SAAA,CAAU,EAAA,mBANuB;EAQjC,MAAA,CAAO,EAAA;EAEP,MAAA,CAAO,EAAA;EAEP,OAAA,CAAQ,EAAA,YAAc,EAAA;AAAA;;;;;;;;;;;;;;;;;;;cAgQX,MAAA,EAAQ,MAAA"}
+{"version":3,"file":"typeid.d.mts","names":[],"sources":["../../src/typeid/typeid.ts"],"mappings":";;;;KAKY,aAAA,GAAgB,aAAA;AAAA,KAEhB,MAAA;gFAET,MAAA,UAAgB,OAAA,GAAU,aAAA,WAJjB;EAAA,cAMI,UAAA,GAAa,UAAA,EACzB,MAAA,UACA,OAAA,EAAS,aAAA,cACT,GAAA,EAAK,IAAA,EACL,MAAA,YACC,IAAA,EAXuB;EAAA,CAazB,MAAA,UAAgB,OAAA,GAAU,aAAA,EAAe,GAAA,cAAiB,MAAA,oBAX7D;EAaE,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,MAAA,UAAgB,KAAA,EAAO,UAAA;EAEjC,MAAA,CAAO,EAAA;EAEP,QAAA,CAAS,MAAA,UAAgB,IAAA;EAEzB,SAAA,CAAU,EAAA;EAEV,MAAA,CAAO,EAAA,mBAR0B;EAUjC,MAAA,CAAO,EAAA;EAEP,OAAA,CAAQ,EAAA,YAAc,EAAA;AAAA;;;;;;;;;;;;;;;;;;;cAgVX,MAAA,EAAQ,MAAA"}

package/build/typeid/typeid.mjs

@@ -1,2 +1,2 @@
-import{BufferError as e,InvalidInputError as t,ParseError as n,UniqueIdError as r}from"../errors.mjs";import{uuidv7 as i}from"../uuid/v7.mjs";const a=`0123456789abcdefghjkmnpqrstvwxyz`,o=Array.from({length:128},()=>-1);for(let e=0;e<32;e+=1)o[a.charCodeAt(e)]=e;function s(e){if(e.length!==0){if(e.length>63)throw new t(`TYPEID_PREFIX_TOO_LONG`,`TypeID prefix must be at most 63 characters`);for(let n=0;n<e.length;n+=1){let r=e.charCodeAt(n),i=r>=97&&r<=122;if(!i&&r!==95)throw new t(`TYPEID_PREFIX_INVALID_CHARACTER`,`TypeID prefix must contain only lowercase ASCII letters and underscores`);if((n===0||n===e.length-1)&&!i)throw new t(`TYPEID_PREFIX_INVALID_BOUNDARY`,`TypeID prefix must start and end with a-z`)}}}function c(e,t){let r=e.charCodeAt(t),i=r<o.length?o[r]:-1;if(i===-1)throw new n(`TYPEID_SUFFIX_INVALID_CHARACTER`,`TypeID suffix contains invalid character at position ${t}`);return i}function l(e){if(e.length!==26)throw new n(`TYPEID_SUFFIX_INVALID_LENGTH`,`TypeID suffix must be 26 characters, got ${e.length}`);if(e[0]>`7`)throw new n(`TYPEID_SUFFIX_OVERFLOW`,`TypeID suffix must encode a 128-bit value`)}function u(e){if(e.length!==16)throw new t(`TYPEID_UUID_BYTES_INVALID_LENGTH`,`UUID bytes must be 16 bytes, got ${e.length}`);return a[(e[0]&224)>>5]+a[e[0]&31]+a[(e[1]&248)>>3]+a[(e[1]&7)<<2|(e[2]&192)>>6]+a[(e[2]&62)>>1]+a[(e[2]&1)<<4|(e[3]&240)>>4]+a[(e[3]&15)<<1|(e[4]&128)>>7]+a[(e[4]&124)>>2]+a[(e[4]&3)<<3|(e[5]&224)>>5]+a[e[5]&31]+a[(e[6]&248)>>3]+a[(e[6]&7)<<2|(e[7]&192)>>6]+a[(e[7]&62)>>1]+a[(e[7]&1)<<4|(e[8]&240)>>4]+a[(e[8]&15)<<1|(e[9]&128)>>7]+a[(e[9]&124)>>2]+a[(e[9]&3)<<3|(e[10]&224)>>5]+a[e[10]&31]+a[(e[11]&248)>>3]+a[(e[11]&7)<<2|(e[12]&192)>>6]+a[(e[12]&62)>>1]+a[(e[12]&1)<<4|(e[13]&240)>>4]+a[(e[13]&15)<<1|(e[14]&128)>>7]+a[(e[14]&124)>>2]+a[(e[14]&3)<<3|(e[15]&224)>>5]+a[e[15]&31]}function d(e){l(e);let t=Array(26);for(let n=0;n<26;n+=1)t[n]=c(e,n);let n=new Uint8Array(16);return n[0]=t[0]<<5|t[1],n[1]=t[2]<<3|t[3]>>2,n[2]=(t[3]&3)<<6|t[4]<<1|t[5]>>4,n[3]=(t[5]&15)<<4|t[6]>>1,n[4]=(t[6]&1)<<7|t[7]<<2|t[8]>>3,n[5]=(t[8]&7)<<5|t[9],n[6]=t[10]<<3|t[11]>>2,n[7]=(t[11]&3)<<6|t[12]<<1|t[13]>>4,n[8]=(t[13]&15)<<4|t[14]>>1,n[9]=(t[14]&1)<<7|t[15]<<2|t[16]>>3,n[10]=(t[16]&7)<<5|t[17],n[11]=t[18]<<3|t[19]>>2,n[12]=(t[19]&3)<<6|t[20]<<1|t[21]>>4,n[13]=(t[21]&15)<<4|t[22]>>1,n[14]=(t[22]&1)<<7|t[23]<<2|t[24]>>3,n[15]=(t[24]&7)<<5|t[25],n}function f(e){if(e.length!==16)throw new t(`TYPEID_UUID_BYTES_INVALID_LENGTH`,`UUID bytes must be 16 bytes, got ${e.length}`);if(e[6]>>4!=7||(e[8]&192)!=128)throw new t(`TYPEID_UUID_NOT_V7`,`TypeID UUID bytes must encode a UUID v7 value`)}function p(e){let t=d(e);return f(t),t}function m(e){if(!i.isValid(e))throw new t(`TYPEID_UUID_NOT_V7`,`TypeID can only wrap UUID v7 values`);return i.toBytes(e)}function h(e){let t=e.lastIndexOf(`_`);if(t===0)throw new n(`TYPEID_INVALID_FORMAT`,`TypeID must not start with "_"`);let r=t===-1?``:e.slice(0,t),i=t===-1?e:e.slice(t+1);return s(r),{prefix:r,suffix:i,bytes:p(i)}}function g(e,t){return e===``?t:`${e}_${t}`}function _(e,t){return s(e),f(t),g(e,u(t))}function v(e){let t=0;for(let n=0;n<6;n+=1)t=t*256+e[n];return t}function y(e,t){return _(e,i(t,new Uint8Array(16)))}function b(e){return h(e).bytes}function x(e,t){return _(e,t)}function S(e){return i.fromBytes(b(e))}function C(e,t){return _(e,m(t))}function w(e){return v(h(e).bytes)}function T(e){return h(e).prefix}function E(e){return h(e).suffix}function D(e){if(typeof e!=`string`)return!1;try{h(e)}catch{return!1}return!0}const O=Object.assign(y,{toBytes:b,fromBytes:x,toUuid:S,fromUuid:C,timestamp:w,prefix:T,suffix:E,isValid:D});export{e as BufferError,t as InvalidInputError,n as ParseError,r as UniqueIdError,O as typeid};
+import{n as e,t}from"../validation-CTNpXm94.mjs";import{BufferError as n,InvalidInputError as r,ParseError as i,UniqueIdError as a}from"../errors.mjs";import{uuidv7 as o}from"../uuid/v7.mjs";const s=0xffffffffffff,c=4294967295,l=`0123456789abcdefghjkmnpqrstvwxyz`,u=Array.from({length:128},()=>-1);for(let e=0;e<32;e+=1)u[l.charCodeAt(e)]=e;function d(e){if(e.length!==0){if(e.length>63)throw new r(`PREFIX_TOO_LONG`,`TypeID prefix must be at most 63 characters`,{strategy:`typeid`});for(let t=0;t<e.length;t+=1){let n=e.charCodeAt(t),i=n>=97&&n<=122;if(!i&&n!==95)throw new r(`PREFIX_INVALID_CHAR`,`TypeID prefix must contain only lowercase ASCII letters and underscores`,{strategy:`typeid`});if((t===0||t===e.length-1)&&!i)throw new r(`PREFIX_INVALID_BOUNDARY`,`TypeID prefix must start and end with a-z`,{strategy:`typeid`})}}}function f(e,t){let n=e.charCodeAt(t),r=n<u.length?u[n]:-1;if(r===-1)throw new i(`INVALID_CHAR`,`TypeID suffix contains invalid character at position ${t}`,{strategy:`typeid`});return r}function p(e){if(e.length!==26)throw new i(`INVALID_LENGTH`,`TypeID suffix must be 26 characters, got ${e.length}`,{strategy:`typeid`});if(e[0]>`7`)throw new i(`VALUE_OUT_OF_RANGE`,`TypeID suffix must encode a 128-bit value`,{strategy:`typeid`})}function m(e){if(e.length!==16)throw new r(`BYTES_INVALID_LENGTH`,`UUID bytes must be 16 bytes, got ${e.length}`,{strategy:`typeid`});return l[(e[0]&224)>>5]+l[e[0]&31]+l[(e[1]&248)>>3]+l[(e[1]&7)<<2|(e[2]&192)>>6]+l[(e[2]&62)>>1]+l[(e[2]&1)<<4|(e[3]&240)>>4]+l[(e[3]&15)<<1|(e[4]&128)>>7]+l[(e[4]&124)>>2]+l[(e[4]&3)<<3|(e[5]&224)>>5]+l[e[5]&31]+l[(e[6]&248)>>3]+l[(e[6]&7)<<2|(e[7]&192)>>6]+l[(e[7]&62)>>1]+l[(e[7]&1)<<4|(e[8]&240)>>4]+l[(e[8]&15)<<1|(e[9]&128)>>7]+l[(e[9]&124)>>2]+l[(e[9]&3)<<3|(e[10]&224)>>5]+l[e[10]&31]+l[(e[11]&248)>>3]+l[(e[11]&7)<<2|(e[12]&192)>>6]+l[(e[12]&62)>>1]+l[(e[12]&1)<<4|(e[13]&240)>>4]+l[(e[13]&15)<<1|(e[14]&128)>>7]+l[(e[14]&124)>>2]+l[(e[14]&3)<<3|(e[15]&224)>>5]+l[e[15]&31]}function h(e){p(e);let t=Array(26);for(let n=0;n<26;n+=1)t[n]=f(e,n);let n=new Uint8Array(16);return n[0]=t[0]<<5|t[1],n[1]=t[2]<<3|t[3]>>2,n[2]=(t[3]&3)<<6|t[4]<<1|t[5]>>4,n[3]=(t[5]&15)<<4|t[6]>>1,n[4]=(t[6]&1)<<7|t[7]<<2|t[8]>>3,n[5]=(t[8]&7)<<5|t[9],n[6]=t[10]<<3|t[11]>>2,n[7]=(t[11]&3)<<6|t[12]<<1|t[13]>>4,n[8]=(t[13]&15)<<4|t[14]>>1,n[9]=(t[14]&1)<<7|t[15]<<2|t[16]>>3,n[10]=(t[16]&7)<<5|t[17],n[11]=t[18]<<3|t[19]>>2,n[12]=(t[19]&3)<<6|t[20]<<1|t[21]>>4,n[13]=(t[21]&15)<<4|t[22]>>1,n[14]=(t[22]&1)<<7|t[23]<<2|t[24]>>3,n[15]=(t[24]&7)<<5|t[25],n}function g(e){if(e.length!==16)throw new r(`BYTES_INVALID_LENGTH`,`UUID bytes must be 16 bytes, got ${e.length}`,{strategy:`typeid`});if(e[6]>>4!=7||(e[8]&192)!=128)throw new r(`UUID_NOT_V7`,`TypeID UUID bytes must encode a UUID v7 value`,{strategy:`typeid`})}function _(e){let t=h(e);return g(t),t}function v(e){if(!o.isValid(e))throw new r(`UUID_NOT_V7`,`TypeID can only wrap UUID v7 values`,{strategy:`typeid`});return o.toBytes(e)}function y(e){let t=e.lastIndexOf(`_`);if(t===0)throw new i(`INVALID_FORMAT`,`TypeID must not start with "_"`,{strategy:`typeid`});let n=t===-1?``:e.slice(0,t),r=t===-1?e:e.slice(t+1);return d(n),{prefix:n,suffix:r,bytes:_(r)}}function b(e,t){return e===``?t:`${e}_${t}`}function x(e,t){return d(e),g(t),b(e,m(t))}function S(e){let t=0;for(let n=0;n<6;n+=1)t=t*256+e[n];return t}function C(e){let n=e.msecs;if(n!==void 0&&!t(n,0,s))throw new r(`TIMESTAMP_OUT_OF_RANGE`,`Timestamp must be an integer between 0 and ${s}`,{strategy:`typeid`});if(e.counter!==void 0&&e.seq!==void 0)throw new r(`CONFLICTING_OPTIONS`,"Pass only one of `counter` or `seq`, not both",{strategy:`typeid`});let i=e.counter??e.seq;if(i!==void 0&&!t(i,0,c))throw new r(`COUNTER_OUT_OF_RANGE`,`Counter must be an integer between 0 and ${c}`,{strategy:`typeid`});let a=e.random;if(a&&a.length<16)throw new r(`RANDOM_BYTES_TOO_SHORT`,`Random bytes length must be >= 16`,{strategy:`typeid`})}function w(t,r,i,a=0){if(r!==void 0&&C(r),i){if(!e(i,a,16))throw new n(`BUFFER_OUT_OF_BOUNDS`,`TypeID byte range ${a}:${a+16-1} is out of buffer bounds`,{strategy:`typeid`});return d(t),o(r,i,a)}return x(t,o(r,new Uint8Array(16)))}function T(e){return y(e).bytes}function E(e,t){return x(e,t)}function D(e){return o.fromBytes(T(e))}function O(e,t){return x(e,v(t))}function k(e){return S(y(e).bytes)}function A(e){return y(e).prefix}function j(e){return y(e).suffix}function M(e){if(typeof e!=`string`)return!1;try{y(e)}catch{return!1}return!0}const N=Object.assign(w,{toBytes:T,fromBytes:E,toUuid:D,fromUuid:O,timestamp:k,prefix:A,suffix:j,isValid:M});export{n as BufferError,r as InvalidInputError,i as ParseError,a as UniqueIdError,N as typeid};
 //# sourceMappingURL=typeid.mjs.map

package/build/typeid/typeid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"typeid.mjs","names":[],"sources":["../../src/typeid/typeid.ts"],"sourcesContent":["import { InvalidInputError, ParseError } from '../errors'\nimport type { UuidV7Options } from '../uuid/v7'\nimport { uuidv7 } from '../uuid/v7'\n\nexport type TypeidOptions = UuidV7Options\n\nexport type Typeid = {\n  /** Generate a TypeID from a lowercase entity prefix and a UUID v7 suffix. */\n  (prefix: string, options?: TypeidOptions): string\n  /** Convert a TypeID's UUID v7 suffix to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Build a TypeID from a prefix and canonical UUID v7 bytes. */\n  fromBytes(prefix: string, bytes: Uint8Array): string\n  /** Convert a TypeID to its UUID v7 string. */\n  toUuid(id: string): string\n  /** Build a TypeID from a prefix and UUID v7 string. */\n  fromUuid(prefix: string, uuid: string): string\n  /** Read the UUID v7 timestamp embedded in a TypeID, in milliseconds. */\n  timestamp(id: string): number\n  /** Read a TypeID's entity prefix. */\n  prefix(id: string): string\n  /** Read a TypeID's UUID v7 suffix. */\n  suffix(id: string): string\n  /** Return whether a value is a syntactically valid TypeID. */\n  isValid(id: unknown): id is string\n}\n\nconst TYPEID_SUFFIX_LENGTH = 26\nconst TYPEID_UUID_BYTE_LENGTH = 16\nconst TYPEID_ALPHABET = '0123456789abcdefghjkmnpqrstvwxyz'\n\nconst BASE32_DECODE: number[] = Array.from({ length: 128 }, () => -1)\nfor (let i = 0; i < TYPEID_ALPHABET.length; i += 1) {\n  BASE32_DECODE[TYPEID_ALPHABET.charCodeAt(i)] = i\n}\n\ntype ParsedTypeid = {\n  prefix: string\n  suffix: string\n  bytes: Uint8Array\n}\n\nfunction assertValidPrefix(prefix: string): void {\n  if (prefix.length === 0) {\n    return\n  }\n\n  if (prefix.length > 63) {\n    throw new InvalidInputError('TYPEID_PREFIX_TOO_LONG', 'TypeID prefix must be at most 63 characters')\n  }\n\n  for (let i = 0; i < prefix.length; i += 1) {\n    const code = prefix.charCodeAt(i)\n    const isLowercaseLetter = code >= 97 && code <= 122\n    const isUnderscore = code === 95\n\n    if (!isLowercaseLetter && !isUnderscore) {\n      throw new InvalidInputError(\n        'TYPEID_PREFIX_INVALID_CHARACTER',\n        'TypeID prefix must contain only lowercase ASCII letters and underscores',\n      )\n    }\n\n    if ((i === 0 || i === prefix.length - 1) && !isLowercaseLetter) {\n      throw new InvalidInputError('TYPEID_PREFIX_INVALID_BOUNDARY', 'TypeID prefix must start and end with a-z')\n    }\n  }\n}\n\nfunction decodeSuffixValue(suffix: string, index: number): number {\n  const code = suffix.charCodeAt(index)\n  const value = code < BASE32_DECODE.length ? BASE32_DECODE[code] : -1\n\n  if (value === -1) {\n    throw new ParseError(\n      'TYPEID_SUFFIX_INVALID_CHARACTER',\n      `TypeID suffix contains invalid character at position ${index}`,\n    )\n  }\n\n  return value\n}\n\nfunction assertValidSuffixShape(suffix: string): void {\n  if (suffix.length !== TYPEID_SUFFIX_LENGTH) {\n    throw new ParseError('TYPEID_SUFFIX_INVALID_LENGTH', `TypeID suffix must be 26 characters, got ${suffix.length}`)\n  }\n\n  if (suffix[0] > '7') {\n    throw new ParseError('TYPEID_SUFFIX_OVERFLOW', 'TypeID suffix must encode a 128-bit value')\n  }\n}\n\nfunction encodeBytesToSuffix(bytes: Uint8Array): string {\n  if (bytes.length !== TYPEID_UUID_BYTE_LENGTH) {\n    throw new InvalidInputError('TYPEID_UUID_BYTES_INVALID_LENGTH', `UUID bytes must be 16 bytes, got ${bytes.length}`)\n  }\n\n  return (\n    TYPEID_ALPHABET[(bytes[0] & 0xe0) >> 5] +\n    TYPEID_ALPHABET[bytes[0] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[1] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[1] & 0x07) << 2) | ((bytes[2] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[2] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[2] & 0x01) << 4) | ((bytes[3] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[3] & 0x0f) << 1) | ((bytes[4] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[4] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[4] & 0x03) << 3) | ((bytes[5] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[5] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[6] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[6] & 0x07) << 2) | ((bytes[7] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[7] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[7] & 0x01) << 4) | ((bytes[8] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[8] & 0x0f) << 1) | ((bytes[9] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[9] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[9] & 0x03) << 3) | ((bytes[10] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[10] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[11] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[11] & 0x07) << 2) | ((bytes[12] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[12] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[12] & 0x01) << 4) | ((bytes[13] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[13] & 0x0f) << 1) | ((bytes[14] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[14] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[14] & 0x03) << 3) | ((bytes[15] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[15] & 0x1f]\n  )\n}\n\nfunction decodeSuffixToBytes(suffix: string): Uint8Array {\n  assertValidSuffixShape(suffix)\n\n  const values = new Array<number>(TYPEID_SUFFIX_LENGTH)\n  for (let i = 0; i < TYPEID_SUFFIX_LENGTH; i += 1) {\n    values[i] = decodeSuffixValue(suffix, i)\n  }\n\n  const bytes = new Uint8Array(TYPEID_UUID_BYTE_LENGTH)\n  bytes[0] = (values[0] << 5) | values[1]\n  bytes[1] = (values[2] << 3) | (values[3] >> 2)\n  bytes[2] = ((values[3] & 0x03) << 6) | (values[4] << 1) | (values[5] >> 4)\n  bytes[3] = ((values[5] & 0x0f) << 4) | (values[6] >> 1)\n  bytes[4] = ((values[6] & 0x01) << 7) | (values[7] << 2) | (values[8] >> 3)\n  bytes[5] = ((values[8] & 0x07) << 5) | values[9]\n  bytes[6] = (values[10] << 3) | (values[11] >> 2)\n  bytes[7] = ((values[11] & 0x03) << 6) | (values[12] << 1) | (values[13] >> 4)\n  bytes[8] = ((values[13] & 0x0f) << 4) | (values[14] >> 1)\n  bytes[9] = ((values[14] & 0x01) << 7) | (values[15] << 2) | (values[16] >> 3)\n  bytes[10] = ((values[16] & 0x07) << 5) | values[17]\n  bytes[11] = (values[18] << 3) | (values[19] >> 2)\n  bytes[12] = ((values[19] & 0x03) << 6) | (values[20] << 1) | (values[21] >> 4)\n  bytes[13] = ((values[21] & 0x0f) << 4) | (values[22] >> 1)\n  bytes[14] = ((values[22] & 0x01) << 7) | (values[23] << 2) | (values[24] >> 3)\n  bytes[15] = ((values[24] & 0x07) << 5) | values[25]\n\n  return bytes\n}\n\nfunction assertUuidV7Bytes(bytes: Uint8Array): void {\n  if (bytes.length !== TYPEID_UUID_BYTE_LENGTH) {\n    throw new InvalidInputError('TYPEID_UUID_BYTES_INVALID_LENGTH', `UUID bytes must be 16 bytes, got ${bytes.length}`)\n  }\n\n  if (bytes[6] >> 4 !== 7 || (bytes[8] & 0xc0) !== 0x80) {\n    throw new InvalidInputError('TYPEID_UUID_NOT_V7', 'TypeID UUID bytes must encode a UUID v7 value')\n  }\n}\n\nfunction uuidV7BytesFromSuffix(suffix: string): Uint8Array {\n  const bytes = decodeSuffixToBytes(suffix)\n  assertUuidV7Bytes(bytes)\n  return bytes\n}\n\nfunction uuidV7BytesFromUuid(uuid: string): Uint8Array {\n  if (!uuidv7.isValid(uuid)) {\n    throw new InvalidInputError('TYPEID_UUID_NOT_V7', 'TypeID can only wrap UUID v7 values')\n  }\n\n  return uuidv7.toBytes(uuid)\n}\n\nfunction parseTypeid(id: string): ParsedTypeid {\n  const separatorIndex = id.lastIndexOf('_')\n\n  if (separatorIndex === 0) {\n    throw new ParseError('TYPEID_INVALID_FORMAT', 'TypeID must not start with \"_\"')\n  }\n\n  const prefix = separatorIndex === -1 ? '' : id.slice(0, separatorIndex)\n  const suffix = separatorIndex === -1 ? id : id.slice(separatorIndex + 1)\n\n  assertValidPrefix(prefix)\n  const bytes = uuidV7BytesFromSuffix(suffix)\n\n  return { prefix, suffix, bytes }\n}\n\nfunction joinPrefixAndSuffix(prefix: string, suffix: string): string {\n  return prefix === '' ? suffix : `${prefix}_${suffix}`\n}\n\nfunction formatTypeidFromUuidV7Bytes(prefix: string, bytes: Uint8Array): string {\n  assertValidPrefix(prefix)\n  assertUuidV7Bytes(bytes)\n  return joinPrefixAndSuffix(prefix, encodeBytesToSuffix(bytes))\n}\n\nfunction timestampFromUuidV7Bytes(bytes: Uint8Array): number {\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 typeidFn(prefix: string, options?: TypeidOptions): string {\n  const bytes = uuidv7(options, new Uint8Array(TYPEID_UUID_BYTE_LENGTH))\n  return formatTypeidFromUuidV7Bytes(prefix, bytes)\n}\n\nfunction typeidToBytes(id: string): Uint8Array {\n  return parseTypeid(id).bytes\n}\n\nfunction typeidFromBytes(prefix: string, bytes: Uint8Array): string {\n  return formatTypeidFromUuidV7Bytes(prefix, bytes)\n}\n\nfunction typeidToUuid(id: string): string {\n  return uuidv7.fromBytes(typeidToBytes(id))\n}\n\nfunction typeidFromUuid(prefix: string, uuid: string): string {\n  return formatTypeidFromUuidV7Bytes(prefix, uuidV7BytesFromUuid(uuid))\n}\n\nfunction timestamp(id: string): number {\n  return timestampFromUuidV7Bytes(parseTypeid(id).bytes)\n}\n\nfunction prefix(id: string): string {\n  return parseTypeid(id).prefix\n}\n\nfunction suffix(id: string): string {\n  return parseTypeid(id).suffix\n}\n\nfunction isValid(id: unknown): id is string {\n  if (typeof id !== 'string') {\n    return false\n  }\n\n  try {\n    parseTypeid(id)\n  } catch {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Generate a TypeID string backed by UUID v7.\n *\n * TypeID combines a lowercase snake_case type prefix with a 26-character\n * modified base32 encoding of a UUID v7, producing sortable domain identifiers\n * such as `user_01h2xcejqtf2nbrexx3vqjhp41`.\n *\n * @example\n * ```ts\n * import { typeid } from 'uniku/typeid'\n *\n * const id = typeid('user')\n * // => \"user_01h2xcejqtf2nbrexx3vqjhp41\"\n *\n * const uuid = typeid.toUuid(id)\n * const restored = typeid.fromUuid('user', uuid)\n * ```\n */\nexport const typeid: Typeid = Object.assign(typeidFn, {\n  toBytes: typeidToBytes,\n  fromBytes: typeidFromBytes,\n  toUuid: typeidToUuid,\n  fromUuid: typeidFromUuid,\n  timestamp,\n  prefix,\n  suffix,\n  isValid,\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}
+{"version":3,"file":"typeid.mjs","names":[],"sources":["../../src/typeid/typeid.ts"],"sourcesContent":["import { isIntegerInRange, isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError, ParseError } from '../errors'\nimport type { UuidV7Options } from '../uuid/v7'\nimport { uuidv7 } from '../uuid/v7'\n\nexport type TypeidOptions = UuidV7Options\n\nexport type Typeid = {\n  /** Generate a TypeID from a lowercase entity prefix and a UUID v7 suffix. */\n  (prefix: string, options?: TypeidOptions): string\n  /** Generate a TypeID with explicit options or write its 16 canonical UUID v7 bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(\n    prefix: string,\n    options: TypeidOptions | undefined,\n    buf: TBuf,\n    offset?: number,\n  ): TBuf\n  /** Generate a TypeID string with optional timestamp, counter, or random bytes. */\n  (prefix: string, options?: TypeidOptions, buf?: undefined, offset?: number): string\n  /** Convert a TypeID's UUID v7 suffix to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Build a TypeID from a prefix and canonical UUID v7 bytes. */\n  fromBytes(prefix: string, bytes: Uint8Array): string\n  /** Convert a TypeID to its UUID v7 string. */\n  toUuid(id: string): string\n  /** Build a TypeID from a prefix and UUID v7 string. */\n  fromUuid(prefix: string, uuid: string): string\n  /** Read the UUID v7 timestamp embedded in a TypeID, in milliseconds. */\n  timestamp(id: string): number\n  /** Read a TypeID's entity prefix. */\n  prefix(id: string): string\n  /** Read a TypeID's UUID v7 suffix. */\n  suffix(id: string): string\n  /** Return whether a value is a syntactically valid TypeID. */\n  isValid(id: unknown): id is string\n}\n\nconst TYPEID_SUFFIX_LENGTH = 26\nconst TYPEID_UUID_BYTE_LENGTH = 16\n// 48-bit UUID v7 timestamp capacity, mirrored from uuid/v7 alongside the\n// 32-bit counter capacity, so option validation is attributed to the typeid\n// boundary instead of leaking `strategy: 'uuid'` through delegation.\nconst MAX_MSECS = 0xffffffffffff\nconst MAX_COUNTER = 0xffffffff\nconst TYPEID_ALPHABET = '0123456789abcdefghjkmnpqrstvwxyz'\n\nconst BASE32_DECODE: number[] = Array.from({ length: 128 }, () => -1)\nfor (let i = 0; i < TYPEID_ALPHABET.length; i += 1) {\n  BASE32_DECODE[TYPEID_ALPHABET.charCodeAt(i)] = i\n}\n\ntype ParsedTypeid = {\n  prefix: string\n  suffix: string\n  bytes: Uint8Array\n}\n\nfunction assertValidPrefix(prefix: string): void {\n  if (prefix.length === 0) {\n    return\n  }\n\n  if (prefix.length > 63) {\n    throw new InvalidInputError('PREFIX_TOO_LONG', 'TypeID prefix must be at most 63 characters', {\n      strategy: 'typeid',\n    })\n  }\n\n  for (let i = 0; i < prefix.length; i += 1) {\n    const code = prefix.charCodeAt(i)\n    const isLowercaseLetter = code >= 97 && code <= 122\n    const isUnderscore = code === 95\n\n    if (!isLowercaseLetter && !isUnderscore) {\n      throw new InvalidInputError(\n        'PREFIX_INVALID_CHAR',\n        'TypeID prefix must contain only lowercase ASCII letters and underscores',\n        { strategy: 'typeid' },\n      )\n    }\n\n    if ((i === 0 || i === prefix.length - 1) && !isLowercaseLetter) {\n      throw new InvalidInputError('PREFIX_INVALID_BOUNDARY', 'TypeID prefix must start and end with a-z', {\n        strategy: 'typeid',\n      })\n    }\n  }\n}\n\nfunction decodeSuffixValue(suffix: string, index: number): number {\n  const code = suffix.charCodeAt(index)\n  const value = code < BASE32_DECODE.length ? BASE32_DECODE[code] : -1\n\n  if (value === -1) {\n    throw new ParseError('INVALID_CHAR', `TypeID suffix contains invalid character at position ${index}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  return value\n}\n\nfunction assertValidSuffixShape(suffix: string): void {\n  if (suffix.length !== TYPEID_SUFFIX_LENGTH) {\n    throw new ParseError('INVALID_LENGTH', `TypeID suffix must be 26 characters, got ${suffix.length}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  if (suffix[0] > '7') {\n    throw new ParseError('VALUE_OUT_OF_RANGE', 'TypeID suffix must encode a 128-bit value', {\n      strategy: 'typeid',\n    })\n  }\n}\n\nfunction encodeBytesToSuffix(bytes: Uint8Array): string {\n  if (bytes.length !== TYPEID_UUID_BYTE_LENGTH) {\n    throw new InvalidInputError('BYTES_INVALID_LENGTH', `UUID bytes must be 16 bytes, got ${bytes.length}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  return (\n    TYPEID_ALPHABET[(bytes[0] & 0xe0) >> 5] +\n    TYPEID_ALPHABET[bytes[0] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[1] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[1] & 0x07) << 2) | ((bytes[2] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[2] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[2] & 0x01) << 4) | ((bytes[3] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[3] & 0x0f) << 1) | ((bytes[4] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[4] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[4] & 0x03) << 3) | ((bytes[5] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[5] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[6] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[6] & 0x07) << 2) | ((bytes[7] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[7] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[7] & 0x01) << 4) | ((bytes[8] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[8] & 0x0f) << 1) | ((bytes[9] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[9] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[9] & 0x03) << 3) | ((bytes[10] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[10] & 0x1f] +\n    TYPEID_ALPHABET[(bytes[11] & 0xf8) >> 3] +\n    TYPEID_ALPHABET[((bytes[11] & 0x07) << 2) | ((bytes[12] & 0xc0) >> 6)] +\n    TYPEID_ALPHABET[(bytes[12] & 0x3e) >> 1] +\n    TYPEID_ALPHABET[((bytes[12] & 0x01) << 4) | ((bytes[13] & 0xf0) >> 4)] +\n    TYPEID_ALPHABET[((bytes[13] & 0x0f) << 1) | ((bytes[14] & 0x80) >> 7)] +\n    TYPEID_ALPHABET[(bytes[14] & 0x7c) >> 2] +\n    TYPEID_ALPHABET[((bytes[14] & 0x03) << 3) | ((bytes[15] & 0xe0) >> 5)] +\n    TYPEID_ALPHABET[bytes[15] & 0x1f]\n  )\n}\n\nfunction decodeSuffixToBytes(suffix: string): Uint8Array {\n  assertValidSuffixShape(suffix)\n\n  const values = new Array<number>(TYPEID_SUFFIX_LENGTH)\n  for (let i = 0; i < TYPEID_SUFFIX_LENGTH; i += 1) {\n    values[i] = decodeSuffixValue(suffix, i)\n  }\n\n  const bytes = new Uint8Array(TYPEID_UUID_BYTE_LENGTH)\n  bytes[0] = (values[0] << 5) | values[1]\n  bytes[1] = (values[2] << 3) | (values[3] >> 2)\n  bytes[2] = ((values[3] & 0x03) << 6) | (values[4] << 1) | (values[5] >> 4)\n  bytes[3] = ((values[5] & 0x0f) << 4) | (values[6] >> 1)\n  bytes[4] = ((values[6] & 0x01) << 7) | (values[7] << 2) | (values[8] >> 3)\n  bytes[5] = ((values[8] & 0x07) << 5) | values[9]\n  bytes[6] = (values[10] << 3) | (values[11] >> 2)\n  bytes[7] = ((values[11] & 0x03) << 6) | (values[12] << 1) | (values[13] >> 4)\n  bytes[8] = ((values[13] & 0x0f) << 4) | (values[14] >> 1)\n  bytes[9] = ((values[14] & 0x01) << 7) | (values[15] << 2) | (values[16] >> 3)\n  bytes[10] = ((values[16] & 0x07) << 5) | values[17]\n  bytes[11] = (values[18] << 3) | (values[19] >> 2)\n  bytes[12] = ((values[19] & 0x03) << 6) | (values[20] << 1) | (values[21] >> 4)\n  bytes[13] = ((values[21] & 0x0f) << 4) | (values[22] >> 1)\n  bytes[14] = ((values[22] & 0x01) << 7) | (values[23] << 2) | (values[24] >> 3)\n  bytes[15] = ((values[24] & 0x07) << 5) | values[25]\n\n  return bytes\n}\n\nfunction assertUuidV7Bytes(bytes: Uint8Array): void {\n  if (bytes.length !== TYPEID_UUID_BYTE_LENGTH) {\n    throw new InvalidInputError('BYTES_INVALID_LENGTH', `UUID bytes must be 16 bytes, got ${bytes.length}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  if (bytes[6] >> 4 !== 7 || (bytes[8] & 0xc0) !== 0x80) {\n    throw new InvalidInputError('UUID_NOT_V7', 'TypeID UUID bytes must encode a UUID v7 value', {\n      strategy: 'typeid',\n    })\n  }\n}\n\nfunction uuidV7BytesFromSuffix(suffix: string): Uint8Array {\n  const bytes = decodeSuffixToBytes(suffix)\n  assertUuidV7Bytes(bytes)\n  return bytes\n}\n\nfunction uuidV7BytesFromUuid(uuid: string): Uint8Array {\n  if (!uuidv7.isValid(uuid)) {\n    throw new InvalidInputError('UUID_NOT_V7', 'TypeID can only wrap UUID v7 values', { strategy: 'typeid' })\n  }\n\n  return uuidv7.toBytes(uuid)\n}\n\nfunction parseTypeid(id: string): ParsedTypeid {\n  const separatorIndex = id.lastIndexOf('_')\n\n  if (separatorIndex === 0) {\n    throw new ParseError('INVALID_FORMAT', 'TypeID must not start with \"_\"', { strategy: 'typeid' })\n  }\n\n  const prefix = separatorIndex === -1 ? '' : id.slice(0, separatorIndex)\n  const suffix = separatorIndex === -1 ? id : id.slice(separatorIndex + 1)\n\n  assertValidPrefix(prefix)\n  const bytes = uuidV7BytesFromSuffix(suffix)\n\n  return { prefix, suffix, bytes }\n}\n\nfunction joinPrefixAndSuffix(prefix: string, suffix: string): string {\n  return prefix === '' ? suffix : `${prefix}_${suffix}`\n}\n\nfunction formatTypeidFromUuidV7Bytes(prefix: string, bytes: Uint8Array): string {\n  assertValidPrefix(prefix)\n  assertUuidV7Bytes(bytes)\n  return joinPrefixAndSuffix(prefix, encodeBytesToSuffix(bytes))\n}\n\nfunction timestampFromUuidV7Bytes(bytes: Uint8Array): number {\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\n/**\n * Mirror uuid/v7's option validation at the typeid boundary, so failures are\n * attributed to `strategy: 'typeid'` instead of leaking `strategy: 'uuid'`\n * through delegation.\n */\nfunction validateTypeidOptions(options: TypeidOptions): void {\n  const msecs = options.msecs\n  if (msecs !== undefined && !isIntegerInRange(msecs, 0, MAX_MSECS)) {\n    throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', `Timestamp must be an integer between 0 and ${MAX_MSECS}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  if (options.counter !== undefined && options.seq !== undefined) {\n    throw new InvalidInputError('CONFLICTING_OPTIONS', 'Pass only one of `counter` or `seq`, not both', {\n      strategy: 'typeid',\n    })\n  }\n  const counter = options.counter ?? options.seq\n  if (counter !== undefined && !isIntegerInRange(counter, 0, MAX_COUNTER)) {\n    throw new InvalidInputError('COUNTER_OUT_OF_RANGE', `Counter must be an integer between 0 and ${MAX_COUNTER}`, {\n      strategy: 'typeid',\n    })\n  }\n\n  const random = options.random\n  if (random && random.length < TYPEID_UUID_BYTE_LENGTH) {\n    throw new InvalidInputError('RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${TYPEID_UUID_BYTE_LENGTH}`, {\n      strategy: 'typeid',\n    })\n  }\n}\n\nfunction typeidFn(prefix: string, options?: TypeidOptions, buf?: undefined, offset?: number): string\nfunction typeidFn<TBuf extends Uint8Array = Uint8Array>(\n  prefix: string,\n  options: TypeidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction typeidFn<TBuf extends Uint8Array = Uint8Array>(\n  prefix: string,\n  options?: TypeidOptions,\n  buf?: TBuf,\n  offset = 0,\n): string | TBuf {\n  if (options !== undefined) {\n    validateTypeidOptions(options)\n  }\n\n  if (buf) {\n    if (!isWritableRange(buf, offset, TYPEID_UUID_BYTE_LENGTH)) {\n      throw new BufferError(\n        'BUFFER_OUT_OF_BOUNDS',\n        `TypeID byte range ${offset}:${offset + TYPEID_UUID_BYTE_LENGTH - 1} is out of buffer bounds`,\n        { strategy: 'typeid' },\n      )\n    }\n    assertValidPrefix(prefix)\n    return uuidv7(options, buf, offset)\n  }\n\n  const bytes = uuidv7(options, new Uint8Array(TYPEID_UUID_BYTE_LENGTH))\n  return formatTypeidFromUuidV7Bytes(prefix, bytes)\n}\n\nfunction typeidToBytes(id: string): Uint8Array {\n  return parseTypeid(id).bytes\n}\n\nfunction typeidFromBytes(prefix: string, bytes: Uint8Array): string {\n  return formatTypeidFromUuidV7Bytes(prefix, bytes)\n}\n\nfunction typeidToUuid(id: string): string {\n  return uuidv7.fromBytes(typeidToBytes(id))\n}\n\nfunction typeidFromUuid(prefix: string, uuid: string): string {\n  return formatTypeidFromUuidV7Bytes(prefix, uuidV7BytesFromUuid(uuid))\n}\n\nfunction timestamp(id: string): number {\n  return timestampFromUuidV7Bytes(parseTypeid(id).bytes)\n}\n\nfunction prefix(id: string): string {\n  return parseTypeid(id).prefix\n}\n\nfunction suffix(id: string): string {\n  return parseTypeid(id).suffix\n}\n\nfunction isValid(id: unknown): id is string {\n  if (typeof id !== 'string') {\n    return false\n  }\n\n  try {\n    parseTypeid(id)\n  } catch {\n    return false\n  }\n\n  return true\n}\n\n/**\n * Generate a TypeID string backed by UUID v7.\n *\n * TypeID combines a lowercase snake_case type prefix with a 26-character\n * modified base32 encoding of a UUID v7, producing sortable domain identifiers\n * such as `user_01h2xcejqtf2nbrexx3vqjhp41`.\n *\n * @example\n * ```ts\n * import { typeid } from 'uniku/typeid'\n *\n * const id = typeid('user')\n * // => \"user_01h2xcejqtf2nbrexx3vqjhp41\"\n *\n * const uuid = typeid.toUuid(id)\n * const restored = typeid.fromUuid('user', uuid)\n * ```\n */\nexport const typeid: Typeid = Object.assign(typeidFn, {\n  toBytes: typeidToBytes,\n  fromBytes: typeidFromBytes,\n  toUuid: typeidToUuid,\n  fromUuid: typeidFromUuid,\n  timestamp,\n  prefix,\n  suffix,\n  isValid,\n})\n\nexport { BufferError, InvalidInputError, ParseError, UniqueIdError } from '../errors'\n"],"mappings":"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"}

package/build/ulid/ulid.d.mts

@@ -1,4 +1,4 @@
-import { i as UniqueIdError, n as InvalidInputError, r as ParseError, t as BufferError } from "../errors-Dgoyi-ci.mjs";
+import { a as ParseError, i as InvalidInputError, o as UniqueIdError, t as BufferError } from "../errors-Da-8dh4J.mjs";
 
 //#region src/ulid/ulid.d.ts
 type UlidOptions = {

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

@@ -1 +1 @@
-{"version":3,"file":"ulid.d.mts","names":[],"sources":["../../src/ulid/ulid.ts"],"mappings":";;;KAMY,WAAA;;;AAAZ;;EAKE,MAAA,GAAS,UAAA;EAAA;;;;EAKT,KAAA;AAAA;AAAA,KAGU,IAAA;EAAA;gBAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,WAAA,cAAyB,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAErG,OAAA,GAAU,WAAA,EAAa,GAAA,cAAiB,MAAA;EAEzC,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA,WAAA;EAEjB,SAAA,CAAU,EAAA;EAEV,OAAA,CAAQ,EAAA,YAAc,EAAA;EAEtB,GAAA;EAEA,GAAA;AAAA;;;;;cA+JW,IAAA,EAAM,IAAA"}
+{"version":3,"file":"ulid.d.mts","names":[],"sources":["../../src/ulid/ulid.ts"],"mappings":";;;KAMY,WAAA;;;AAAZ;;EAKE,MAAA,GAAS,UAAA;EAAA;;;;EAKT,KAAA;AAAA;AAAA,KAGU,IAAA;EAAA;gBAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,WAAA,cAAyB,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAErG,OAAA,GAAU,WAAA,EAAa,GAAA,cAAiB,MAAA;EAEzC,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA,WAAA;EAEjB,SAAA,CAAU,EAAA;EAEV,OAAA,CAAQ,EAAA,YAAc,EAAA;EAEtB,GAAA;EAEA,GAAA;AAAA;;;;;cAmKW,IAAA,EAAM,IAAA"}

package/build/ulid/ulid.mjs

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

package/build/ulid/ulid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ulid.mjs","names":[],"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_INVALID_LENGTH', `ULID bytes must be exactly 16 bytes, got ${bytes.length}`)\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 { isIntegerInRange, isWritableRange } from '../common/validation'\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  /** Generate a time-ordered ULID string. */\n  (): string\n  /** Generate a ULID with explicit options or write its 16 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a ULID string with optional timestamp or random bytes. */\n  (options?: UlidOptions, buf?: undefined, offset?: number): string\n  /** Convert a ULID string to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 16 canonical ULID bytes to a ULID string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Read the embedded Unix timestamp in milliseconds. */\n  timestamp(id: string): number\n  /** Return whether a value is a syntactically valid ULID string. */\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\nconst ULID_BYTES = 16\nconst RANDOM_BYTES = 10\nconst MAX_MSECS = 0xffffffffffff\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(RANDOM_BYTES),\n}\n\nfunction writeUlidBytesUnchecked(time: number, random: Uint8Array, buf: Uint8Array, offset: number): void {\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 < RANDOM_BYTES; i += 1) {\n    buf[offset + 6 + i] = random[i]\n  }\n}\n\nfunction writeUlidBytes(time: number, random: Uint8Array, buf: Uint8Array, offset: number): void {\n  if (!isWritableRange(buf, offset, ULID_BYTES)) {\n    throw new BufferError(\n      'ULID_BUFFER_OUT_OF_BOUNDS',\n      `ULID byte range ${offset}:${offset + ULID_BYTES - 1} is out of buffer bounds`,\n    )\n  }\n  writeUlidBytesUnchecked(time, random, buf, offset)\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  if (options) {\n    // Explicit options provided - use them directly without monotonic state\n    const optMsecs = options.msecs\n    if (optMsecs !== undefined && !isIntegerInRange(optMsecs, 0, MAX_MSECS)) {\n      throw new InvalidInputError(\n        'ULID_TIMESTAMP_OUT_OF_RANGE',\n        `Timestamp must be an integer between 0 and ${MAX_MSECS}`,\n      )\n    }\n    time = optMsecs ?? Date.now()\n    const optRandom = options.random\n    if (optRandom) {\n      if (optRandom.length < RANDOM_BYTES) {\n        throw new InvalidInputError(\n          'ULID_RANDOM_BYTES_TOO_SHORT',\n          `Random bytes length must be >= ${RANDOM_BYTES} for ULID`,\n        )\n      }\n      random = optRandom\n    } else {\n      random = rng()\n    }\n  } else {\n    time = Date.now()\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, RANDOM_BYTES))\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    writeUlidBytes(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\n/**\n * Generate a ULID string or write its 16 canonical bytes into a buffer.\n * ULIDs are URL-safe, carry a millisecond timestamp, and sort by creation time.\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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"}
+{"version":3,"file":"ulid.mjs","names":[],"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('INVALID_CHAR', `Invalid ULID character: ${str[index]}`, { strategy: 'ulid' })\n}\n\nfunction timestampOverflowError(): ParseError {\n  return new ParseError('TIMESTAMP_OUT_OF_RANGE', 'ULID timestamp exceeds 48 bits', { strategy: 'ulid' })\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('INVALID_LENGTH', `ULID timestamp must be ${TIME_LEN} characters`, { strategy: 'ulid' })\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('INVALID_LENGTH', `ULID string must be ${ULID_LEN} characters`, { strategy: 'ulid' })\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('INVALID_LENGTH', `ULID string must be ${ULID_LEN} characters`, { strategy: 'ulid' })\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('BYTES_INVALID_LENGTH', `ULID bytes must be exactly 16 bytes, got ${bytes.length}`, {\n      strategy: 'ulid',\n    })\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 { isIntegerInRange, isWritableRange } from '../common/validation'\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  /** Generate a time-ordered ULID string. */\n  (): string\n  /** Generate a ULID with explicit options or write its 16 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a ULID string with optional timestamp or random bytes. */\n  (options?: UlidOptions, buf?: undefined, offset?: number): string\n  /** Convert a ULID string to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 16 canonical ULID bytes to a ULID string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Read the embedded Unix timestamp in milliseconds. */\n  timestamp(id: string): number\n  /** Return whether a value is a syntactically valid ULID string. */\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\nconst ULID_BYTES = 16\nconst RANDOM_BYTES = 10\nconst MAX_MSECS = 0xffffffffffff\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(RANDOM_BYTES),\n}\n\nfunction writeUlidBytesUnchecked(time: number, random: Uint8Array, buf: Uint8Array, offset: number): void {\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 < RANDOM_BYTES; i += 1) {\n    buf[offset + 6 + i] = random[i]\n  }\n}\n\nfunction writeUlidBytes(time: number, random: Uint8Array, buf: Uint8Array, offset: number): void {\n  if (!isWritableRange(buf, offset, ULID_BYTES)) {\n    throw new BufferError(\n      'BUFFER_OUT_OF_BOUNDS',\n      `ULID byte range ${offset}:${offset + ULID_BYTES - 1} is out of buffer bounds`,\n      { strategy: 'ulid' },\n    )\n  }\n  writeUlidBytesUnchecked(time, random, buf, offset)\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  if (options) {\n    // Explicit options provided - use them directly without monotonic state\n    const optMsecs = options.msecs\n    if (optMsecs !== undefined && !isIntegerInRange(optMsecs, 0, MAX_MSECS)) {\n      throw new InvalidInputError('TIMESTAMP_OUT_OF_RANGE', `Timestamp must be an integer between 0 and ${MAX_MSECS}`, {\n        strategy: 'ulid',\n      })\n    }\n    time = optMsecs ?? Date.now()\n    const optRandom = options.random\n    if (optRandom) {\n      if (optRandom.length < RANDOM_BYTES) {\n        throw new InvalidInputError(\n          'RANDOM_BYTES_TOO_SHORT',\n          `Random bytes length must be >= ${RANDOM_BYTES} for ULID`,\n          {\n            strategy: 'ulid',\n          },\n        )\n      }\n      random = optRandom\n    } else {\n      random = rng()\n    }\n  } else {\n    time = Date.now()\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, RANDOM_BYTES))\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          'RANDOM_OVERFLOW',\n          'ULID random component overflowed while preserving monotonic order',\n          { strategy: 'ulid' },\n        )\n      }\n      random = state.lastRandom\n    }\n  }\n\n  if (buf) {\n    writeUlidBytes(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\n/**\n * Generate a ULID string or write its 16 canonical bytes into a buffer.\n * ULIDs are URL-safe, carry a millisecond timestamp, and sort by creation time.\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.d.mts

@@ -1,4 +1,4 @@
-import { i as UniqueIdError, n as InvalidInputError, r as ParseError, t as BufferError } from "../errors-Dgoyi-ci.mjs";
+import { a as ParseError, i as InvalidInputError, o as UniqueIdError, t as BufferError } from "../errors-Da-8dh4J.mjs";
 
 //#region src/uuid/v4.d.ts
 type UuidV4Options = {

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

@@ -1 +1 @@
-{"version":3,"file":"v4.d.mts","names":[],"sources":["../../src/uuid/v4.ts"],"mappings":";;;KASY,aAAA;;;AAAZ;EAIE,MAAA,GAAS,UAAA;AAAA;AAAA,KAGC,MAAA;EAHD,oDAGC;EAAA,cAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,aAAA,cAA2B,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAEvG,OAAA,GAAU,aAAA,EAAe,GAAA,cAAiB,MAAA;EAE3C,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA;EAEjB,OAAA,CAAQ,EAAA,YAAc,EAAA,YAFL;EAIjB,GAAA;EAEA,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;cAiFW,MAAA,EAAQ,MAAA"}
+{"version":3,"file":"v4.d.mts","names":[],"sources":["../../src/uuid/v4.ts"],"mappings":";;;KASY,aAAA;;;AAAZ;EAIE,MAAA,GAAS,UAAA;AAAA;AAAA,KAGC,MAAA;EAHD,oDAGC;EAAA,cAII,UAAA,GAAa,UAAA,EAAY,OAAA,EAAS,aAAA,cAA2B,GAAA,EAAK,IAAA,EAAM,MAAA,YAAkB,IAAA;GAEvG,OAAA,GAAU,aAAA,EAAe,GAAA,cAAiB,MAAA;EAE3C,OAAA,CAAQ,EAAA,WAAa,UAAA;EAErB,SAAA,CAAU,KAAA,EAAO,UAAA;EAEjB,OAAA,CAAQ,EAAA,YAAc,EAAA,YAFL;EAIjB,GAAA;EAEA,GAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;cAoFW,MAAA,EAAQ,MAAA"}

package/build/uuid/v4.mjs

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

package/build/uuid/v4.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"v4.mjs","names":[],"sources":["../../src/uuid/v4.ts"],"sourcesContent":["import { rng } from '../common/random'\nimport { isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { formatUuid, formatUuidUnchecked, parseUuid } from './common/uuid'\n\nconst randomUUID = /*@__PURE__*/ globalThis.crypto.randomUUID.bind(globalThis.crypto)\nconst UUID_BYTES = 16\nconst reusableBuf = new Uint8Array(UUID_BYTES)\n\nexport type UuidV4Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   */\n  random?: Uint8Array\n}\n\nexport type UuidV4 = {\n  /** Generate a random UUID v4 string. */\n  (): string\n  /** Generate a UUID v4 with explicit options or write its 16 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a UUID v4 string with optional deterministic random bytes. */\n  (options?: UuidV4Options, buf?: undefined, offset?: number): string\n  /** Convert a UUID v4 string to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 16 canonical UUID bytes to a UUID v4 string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Return whether a value is a syntactically valid UUID v4 string. */\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_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n\nfunction writeV4BytesUnchecked(rnds: Uint8Array, buf: Uint8Array, offset: number): void {\n  // Copy 16 UUID bytes into the provided buffer slice.\n  for (let i = 0; i < UUID_BYTES; i += 1) {\n    buf[offset + i] = rnds[i]\n  }\n\n  // Set RFC 4122 version (4) and variant (10xx) bits on owned output only.\n  buf[offset + 6] = (buf[offset + 6] & 0x0f) | 0x40\n  buf[offset + 8] = (buf[offset + 8] & 0x3f) | 0x80\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v4(options?: UuidV4Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v4<TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf\nfunction v4<TBuf extends Uint8Array = Uint8Array>(options?: UuidV4Options, buf?: TBuf, offset?: number): string | TBuf {\n  if (!buf && !options) {\n    return randomUUID()\n  }\n\n  return _v4(options, buf, offset)\n}\n\nfunction _v4<TBuf extends Uint8Array = Uint8Array>(\n  options?: UuidV4Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  const random = options?.random\n  if (random && random.length < UUID_BYTES) {\n    throw new InvalidInputError('UUID_RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`)\n  }\n\n  const outputOffset = buf ? (offset ?? 0) : 0\n  if (buf && !isWritableRange(buf, outputOffset, UUID_BYTES)) {\n    throw new BufferError(\n      'UUID_BUFFER_OUT_OF_BOUNDS',\n      `UUID byte range ${outputOffset}:${outputOffset + UUID_BYTES - 1} is out of buffer bounds`,\n    )\n  }\n\n  const output = buf ?? reusableBuf\n  writeV4BytesUnchecked(random ?? rng(), output, outputOffset)\n  return buf ?? formatUuidUnchecked(output)\n}\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && UUID_V4_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v4 string or write the bytes into a buffer.\n *\n * UUID v4 is a purely random UUID with 122 bits of entropy. It's the most\n * widely compatible UUID format, supported by virtually all databases and systems.\n * Use when you need maximum compatibility and don't require time-ordering.\n *\n * @example\n * ```ts\n * import { uuidv4 } from 'uniku/uuid/v4'\n *\n * const id = uuidv4()\n * // => \"550e8400-e29b-41d4-a716-446655440000\"\n *\n * // Validate\n * uuidv4.isValid(id) // true\n *\n * // Convert to/from bytes (16 bytes)\n * const bytes = uuidv4.toBytes(id)\n * const restored = uuidv4.fromBytes(bytes)\n * ```\n */\nexport const uuidv4: UuidV4 = Object.assign(v4, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\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":"uPAKA,MAAM,EAA2B,WAAW,OAAO,WAAW,KAAK,WAAW,MAAM,EAE9E,EAAc,IAAI,WAAW,EAAU,EA4BvC,EAAgB,yEAEtB,SAAS,EAAsB,EAAkB,EAAiB,EAAsB,CAEtF,IAAK,IAAI,EAAI,EAAG,EAAI,GAAY,GAAK,EACnC,EAAI,EAAS,GAAK,EAAK,GAIzB,EAAI,EAAS,GAAM,EAAI,EAAS,GAAK,GAAQ,GAC7C,EAAI,EAAS,GAAM,EAAI,EAAS,GAAK,GAAQ,GAC/C,CAUA,SAAS,EAAyC,EAAyB,EAAY,EAAgC,CAKrH,MAJI,CAAC,GAAO,CAAC,EACJ,EAAW,EAGb,EAAI,EAAS,EAAK,CAAM,CACjC,CAEA,SAAS,EACP,EACA,EACA,EACe,CACf,IAAM,EAAS,GAAS,OACxB,GAAI,GAAU,EAAO,OAAS,GAC5B,MAAM,IAAI,EAAkB,8BAA+B,mCAA8C,EAG3G,IAAM,EAAe,EAAO,GAAU,EAAK,EAC3C,GAAI,GAAO,CAAC,EAAgB,EAAK,EAAc,EAAU,EACvD,MAAM,IAAI,EACR,4BACA,mBAAmB,EAAa,GAAG,EAAe,GAAa,EAAE,yBACnE,EAGF,IAAM,EAAS,GAAO,EAEtB,OADA,EAAsB,GAAU,EAAI,EAAG,EAAQ,CAAY,EACpD,GAAO,EAAoB,CAAM,CAC1C,CAEA,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAc,KAAK,CAAE,CACxD,CAwBA,MAAa,EAAiB,OAAO,OAAO,EAAI,CAC9C,QAAS,EACT,UAAW,EACX,UACA,IAAK,uCACL,IAAK,sCACP,CAAC"}
+{"version":3,"file":"v4.mjs","names":[],"sources":["../../src/uuid/v4.ts"],"sourcesContent":["import { rng } from '../common/random'\nimport { isWritableRange } from '../common/validation'\nimport { BufferError, InvalidInputError } from '../errors'\nimport { formatUuid, formatUuidUnchecked, parseUuid } from './common/uuid'\n\nconst randomUUID = /*@__PURE__*/ globalThis.crypto.randomUUID.bind(globalThis.crypto)\nconst UUID_BYTES = 16\nconst reusableBuf = new Uint8Array(UUID_BYTES)\n\nexport type UuidV4Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   */\n  random?: Uint8Array\n}\n\nexport type UuidV4 = {\n  /** Generate a random UUID v4 string. */\n  (): string\n  /** Generate a UUID v4 with explicit options or write its 16 canonical bytes into a caller-owned buffer. */\n  <TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf\n  /** Generate a UUID v4 string with optional deterministic random bytes. */\n  (options?: UuidV4Options, buf?: undefined, offset?: number): string\n  /** Convert a UUID v4 string to its canonical 16-byte representation. */\n  toBytes(id: string): Uint8Array\n  /** Convert 16 canonical UUID bytes to a UUID v4 string. */\n  fromBytes(bytes: Uint8Array): string\n  /** Return whether a value is a syntactically valid UUID v4 string. */\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_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n\nfunction writeV4BytesUnchecked(rnds: Uint8Array, buf: Uint8Array, offset: number): void {\n  // Copy 16 UUID bytes into the provided buffer slice.\n  for (let i = 0; i < UUID_BYTES; i += 1) {\n    buf[offset + i] = rnds[i]\n  }\n\n  // Set RFC 4122 version (4) and variant (10xx) bits on owned output only.\n  buf[offset + 6] = (buf[offset + 6] & 0x0f) | 0x40\n  buf[offset + 8] = (buf[offset + 8] & 0x3f) | 0x80\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v4(options?: UuidV4Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v4<TBuf extends Uint8Array = Uint8Array>(options: UuidV4Options | undefined, buf: TBuf, offset?: number): TBuf\nfunction v4<TBuf extends Uint8Array = Uint8Array>(options?: UuidV4Options, buf?: TBuf, offset?: number): string | TBuf {\n  if (!buf && !options) {\n    return randomUUID()\n  }\n\n  return _v4(options, buf, offset)\n}\n\nfunction _v4<TBuf extends Uint8Array = Uint8Array>(\n  options?: UuidV4Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  const random = options?.random\n  if (random && random.length < UUID_BYTES) {\n    throw new InvalidInputError('RANDOM_BYTES_TOO_SHORT', `Random bytes length must be >= ${UUID_BYTES}`, {\n      strategy: 'uuid',\n    })\n  }\n\n  const outputOffset = buf ? (offset ?? 0) : 0\n  if (buf && !isWritableRange(buf, outputOffset, UUID_BYTES)) {\n    throw new BufferError(\n      'BUFFER_OUT_OF_BOUNDS',\n      `UUID byte range ${outputOffset}:${outputOffset + UUID_BYTES - 1} is out of buffer bounds`,\n      { strategy: 'uuid' },\n    )\n  }\n\n  const output = buf ?? reusableBuf\n  writeV4BytesUnchecked(random ?? rng(), output, outputOffset)\n  return buf ?? formatUuidUnchecked(output)\n}\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && UUID_V4_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v4 string or write the bytes into a buffer.\n *\n * UUID v4 is a purely random UUID with 122 bits of entropy. It's the most\n * widely compatible UUID format, supported by virtually all databases and systems.\n * Use when you need maximum compatibility and don't require time-ordering.\n *\n * @example\n * ```ts\n * import { uuidv4 } from 'uniku/uuid/v4'\n *\n * const id = uuidv4()\n * // => \"550e8400-e29b-41d4-a716-446655440000\"\n *\n * // Validate\n * uuidv4.isValid(id) // true\n *\n * // Convert to/from bytes (16 bytes)\n * const bytes = uuidv4.toBytes(id)\n * const restored = uuidv4.fromBytes(bytes)\n * ```\n */\nexport const uuidv4: UuidV4 = Object.assign(v4, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\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":"uPAKA,MAAM,EAA2B,WAAW,OAAO,WAAW,KAAK,WAAW,MAAM,EAE9E,EAAc,IAAI,WAAW,EAAU,EA4BvC,EAAgB,yEAEtB,SAAS,EAAsB,EAAkB,EAAiB,EAAsB,CAEtF,IAAK,IAAI,EAAI,EAAG,EAAI,GAAY,GAAK,EACnC,EAAI,EAAS,GAAK,EAAK,GAIzB,EAAI,EAAS,GAAM,EAAI,EAAS,GAAK,GAAQ,GAC7C,EAAI,EAAS,GAAM,EAAI,EAAS,GAAK,GAAQ,GAC/C,CAUA,SAAS,EAAyC,EAAyB,EAAY,EAAgC,CAKrH,MAJI,CAAC,GAAO,CAAC,EACJ,EAAW,EAGb,EAAI,EAAS,EAAK,CAAM,CACjC,CAEA,SAAS,EACP,EACA,EACA,EACe,CACf,IAAM,EAAS,GAAS,OACxB,GAAI,GAAU,EAAO,OAAS,GAC5B,MAAM,IAAI,EAAkB,yBAA0B,oCAAgD,CACpG,SAAU,MACZ,CAAC,EAGH,IAAM,EAAe,EAAO,GAAU,EAAK,EAC3C,GAAI,GAAO,CAAC,EAAgB,EAAK,EAAc,EAAU,EACvD,MAAM,IAAI,EACR,uBACA,mBAAmB,EAAa,GAAG,EAAe,GAAa,EAAE,0BACjE,CAAE,SAAU,MAAO,CACrB,EAGF,IAAM,EAAS,GAAO,EAEtB,OADA,EAAsB,GAAU,EAAI,EAAG,EAAQ,CAAY,EACpD,GAAO,EAAoB,CAAM,CAC1C,CAEA,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAc,KAAK,CAAE,CACxD,CAwBA,MAAa,EAAiB,OAAO,OAAO,EAAI,CAC9C,QAAS,EACT,UAAW,EACX,UACA,IAAK,uCACL,IAAK,sCACP,CAAC"}