uniku 0.0.1 → 0.0.4

package/README.md

@@ -5,7 +5,7 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
 [![Bundle Size](https://img.shields.io/bundlephobia/minzip/uniku)](https://bundlephobia.com/package/uniku)
 
-Minimal, tree-shakeable UUID utilities for every JavaScript runtime.
+Minimal, tree-shakeable UUID and ULID utilities for every JavaScript runtime.
 
 > *uniku* means "unique" in Maltese.
 
@@ -20,8 +20,11 @@ Minimal, tree-shakeable UUID utilities for every JavaScript runtime.
 
 ## Supported ID generation algorithms
 
-- UUID v4 ([RFC 4122](./rfcs/rfc4122))
-- UUID v7 ([RFC 9562](./rfcs/rfc9562), time-ordered, monotonic sequencing)
+- UUID v4 ([RFC 4122](../../rfcs/rfc4122.txt))
+- UUID v7 ([RFC 9562](../../rfcs/rfc9562.txt), time-ordered, monotonic sequencing)
+- ULID ([spec](../../rfcs/ulid.txt), time-ordered, monotonic sequencing)
+- CUID2 ([spec](../../rfcs/cuid2.txt), secure, non-time-ordered)
+- Nanoid ([spec](../../rfcs/nanoid.txt), URL-friendly, custom alphabet support)
 
 ## Installation
 
@@ -71,6 +74,59 @@ const ids = [uuidv7(), uuidv7(), uuidv7()]
 ids.sort() // Already in creation order
 ```
 
+### ULID (time-ordered)
+
+```ts
+import { ulid } from 'uniku/ulid'
+
+const id = ulid()
+// => "01HW9T2W9W9YJ3JZ1H4P4M2T8Q"
+
+// Convert to/from bytes
+const bytes = ulid.toBytes(id)
+const str = ulid.fromBytes(bytes)
+```
+
+### CUID2 (secure, non-time-ordered)
+
+```ts
+import { cuid2 } from 'uniku/cuid2'
+
+const id = cuid2()
+// => "pfh0haxfpzowht3oi213cqos"
+
+// Custom length
+const shortId = cuid2({ length: 10 })
+// => "tz4a98xxat"
+
+// Validation (type guard)
+const maybeId: unknown = getUserInput()
+if (cuid2.isValid(maybeId)) {
+  console.log(maybeId) // TypeScript knows this is a string
+}
+```
+
+### Nanoid (URL-friendly, custom alphabet)
+
+```ts
+import { nanoid } from 'uniku/nanoid'
+
+const id = nanoid()
+// => "V1StGXR8_Z5jdHi6B-myT"
+
+// Custom size
+const shortId = nanoid(10)
+// => "IRFa-VaY2b"
+
+// Custom alphabet and size via options
+const hexId = nanoid({ alphabet: '0123456789abcdef', size: 12 })
+// => "4f90d13a42bc"
+
+// Validation (default alphabet only)
+nanoid.isValid(id)
+// => true
+```
+
 ## API Reference
 
 ### `uuidv4` (from `uniku/uuid/v4`)
@@ -94,6 +150,8 @@ uuidv7(options: Version7Options | undefined, buf: Uint8Array, offset?: number):
 
 uuidv7.toBytes(id: string): Uint8Array
 uuidv7.fromBytes(bytes: Uint8Array): string
+uuidv7.timestamp(id: string): number
+uuidv7.isValid(id: string): boolean
 ```
 
 **Options:**
@@ -101,6 +159,51 @@ uuidv7.fromBytes(bytes: Uint8Array): string
 - `seq?: number` - Sequence number for monotonicity
 - `random?: Uint8Array` - 16 bytes of random data
 
+### `ulid` (from `uniku/ulid`)
+
+```ts
+ulid(options?: UlidOptions): string
+ulid(options: UlidOptions | undefined, buf: Uint8Array, offset?: number): Uint8Array
+
+ulid.toBytes(id: string): Uint8Array
+ulid.fromBytes(bytes: Uint8Array): string
+ulid.timestamp(id: string): number
+ulid.isValid(id: string): boolean
+```
+
+**Options:**
+- `msecs?: number` - Timestamp in milliseconds (defaults to `Date.now()`)
+- `random?: Uint8Array` - 16 bytes of random data (only first 10 bytes used)
+
+### `cuid2` (from `uniku/cuid2`)
+
+```ts
+cuid2(options?: Cuid2Options): string
+cuid2.isValid(id: unknown): id is string
+```
+
+**Options:**
+- `length?: number` - ID length (2-32, default 24)
+- `random?: Uint8Array` - Custom random bytes for testing
+
+Note: Unlike UUID and ULID, CUID2 does not provide `toBytes`/`fromBytes` because it is a string-native format with no canonical binary representation.
+
+### `nanoid` (from `uniku/nanoid`)
+
+```ts
+nanoid(): string
+nanoid(size: number): string
+nanoid(options: NanoidOptions): string
+nanoid.isValid(id: unknown): id is string
+```
+
+**Options:**
+- `size?: number` - ID length (default 21, max 2048)
+- `alphabet?: string` - Custom alphabet (2-256 printable ASCII characters)
+- `random?: Uint8Array` - Custom random bytes for testing
+
+Note: `isValid()` only validates IDs against the default URL-safe alphabet (`A-Za-z0-9_-`). IDs generated with custom alphabets cannot be validated with this method.
+
 ## Documentation
 
 For advanced usage, examples, and contributing guidelines, see the [full documentation on GitHub](https://github.com/jkomyno/uniku).

package/build/cuid2/cuid2.d.mts

@@ -0,0 +1,51 @@
+//#region src/cuid2/cuid2.d.ts
+type Cuid2Options = {
+  /**
+  * Length of the generated ID (2-32 characters).
+  * Default: 24
+  */
+  length?: number;
+  /**
+  * Custom random bytes for deterministic testing.
+  * Must be at least 1 byte. For adequate entropy, use at least 16 bytes.
+  * Note: The fingerprint always uses cryptographically secure random bytes,
+  * regardless of this option.
+  */
+  random?: Uint8Array;
+};
+type Cuid2 = {
+  (options?: Cuid2Options): string;
+  isValid(id: unknown): id is string;
+};
+/**
+* Generate a CUID2 string.
+*
+* CUID2 is a secure, collision-resistant identifier that hashes multiple
+* entropy sources using SHA3-512. Unlike time-ordered IDs (ULID, UUID v7),
+* CUID2 prevents enumeration attacks by making IDs non-predictable.
+*
+* Note: CUID2 does not provide toBytes/fromBytes because it is a string-native
+* format with no canonical binary representation (unlike UUID's 16-byte format).
+*
+* @example
+* ```ts
+* import { cuid2 } from 'uniku/cuid2'
+*
+* const id = cuid2()
+* // => "pfh0haxfpzowht3oi213cqos"
+*
+* // Custom length
+* const shortId = cuid2({ length: 10 })
+* // => "tz4a98xxat"
+*
+* // Validation (type guard)
+* const maybeId: unknown = getUserInput()
+* if (cuid2.isValid(maybeId)) {
+*   console.log(maybeId.length) // TypeScript knows maybeId is string
+* }
+* ```
+*/
+declare const cuid2: Cuid2;
+//#endregion
+export { Cuid2, Cuid2Options, cuid2 };
+//# sourceMappingURL=cuid2.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cuid2.d.mts","names":["cuid2: Cuid2"],"sources":["../../src/cuid2/cuid2.ts"],"sourcesContent":[],"mappings":";KAEY,YAAA;EAAZ;AAeA;AA2MA;;;;;;;;;WA9MW;;KAGC,KAAA;aACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0MAA,OAAO"}

package/build/cuid2/cuid2.mjs

@@ -0,0 +1,134 @@
+import { sha3_512 } from "@noble/hashes/sha3.js";
+
+//#region src/cuid2/cuid2.ts
+const DEFAULT_LENGTH = 24;
+const MAX_LENGTH = 32;
+const MIN_LENGTH = 2;
+const INITIAL_COUNT_MAX = 476782367;
+const CUID2_REGEX = /^[a-z][0-9a-z]+$/;
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+const LETTER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+const textEncoder = new TextEncoder();
+const RANDOM_BUFFER_SIZE = 256;
+const randomBuffer = new Uint8Array(RANDOM_BUFFER_SIZE);
+let randomBufferOffset = RANDOM_BUFFER_SIZE;
+/**
+* Module-level state for counter and fingerprint.
+* Counter is initialized lazily on first call to prevent unnecessary crypto operations.
+* Fingerprint is also generated lazily on first call.
+*/
+const state = {
+	counter: void 0,
+	fingerprint: void 0
+};
+/**
+* Initialize counter using crypto for consistency with other entropy sources.
+*/
+function initializeCounter() {
+	const buffer = new Uint8Array(4);
+	globalThis.crypto.getRandomValues(buffer);
+	return ((buffer[0] << 24 | buffer[1] << 16 | buffer[2] << 8 | buffer[3]) >>> 0) % (INITIAL_COUNT_MAX + 1);
+}
+function bufToBigInt(buf) {
+	let value = 0n;
+	for (const byte of buf) value = value * 256n + BigInt(byte);
+	return value;
+}
+function bigIntToBase36(value) {
+	if (value === 0n) return "0";
+	const chars = [];
+	while (value > 0n) {
+		chars.push(ALPHABET[Number(value % 36n)]);
+		value = value / 36n;
+	}
+	return chars.reverse().join("");
+}
+function randomLetter(random) {
+	return LETTER_ALPHABET[Math.floor(random() * 26)];
+}
+function createEntropy(length, random) {
+	const chars = new Array(length);
+	for (let i = 0; i < length; i++) chars[i] = ALPHABET[Math.floor(random() * 36)];
+	return chars.join("");
+}
+function hash(input) {
+	return sha3_512(textEncoder.encode(input));
+}
+const BIG_LENGTH = 32;
+function createFingerprint() {
+	const random = getCryptoRandom;
+	return bigIntToBase36(bufToBigInt(hash(Object.keys(globalThis).toString() + createEntropy(BIG_LENGTH, random)))).slice(1, BIG_LENGTH + 1);
+}
+/**
+* Get a random number in [0, 1) using batched CSPRNG.
+* Uses a pre-allocated buffer to reduce crypto.getRandomValues calls.
+*/
+function getCryptoRandom() {
+	if (randomBufferOffset >= RANDOM_BUFFER_SIZE) {
+		globalThis.crypto.getRandomValues(randomBuffer);
+		randomBufferOffset = 0;
+	}
+	const value = (randomBuffer[randomBufferOffset] * 16777216 + randomBuffer[randomBufferOffset + 1] * 65536 + randomBuffer[randomBufferOffset + 2] * 256 + randomBuffer[randomBufferOffset + 3]) / 4294967296;
+	randomBufferOffset += 4;
+	return value;
+}
+function getRandomFn(random) {
+	if (random) {
+		if (random.length === 0) throw new Error("Random byte array cannot be empty");
+		let index = 0;
+		return () => {
+			const value = random[index % random.length] / 256;
+			index += 1;
+			return value;
+		};
+	}
+	return getCryptoRandom;
+}
+function cuid2Fn(options) {
+	const length = options?.length ?? DEFAULT_LENGTH;
+	if (length < MIN_LENGTH || length > MAX_LENGTH) throw new RangeError(`CUID2 length must be between ${MIN_LENGTH} and ${MAX_LENGTH}. Received: ${length}`);
+	const random = getRandomFn(options?.random);
+	if (state.counter === void 0) state.counter = initializeCounter();
+	if (state.fingerprint === void 0) state.fingerprint = createFingerprint();
+	const firstLetter = randomLetter(random);
+	const time = Date.now().toString(36);
+	state.counter += 1;
+	const count = state.counter.toString(36);
+	return firstLetter + bigIntToBase36(bufToBigInt(hash(time + createEntropy(length, random) + count + state.fingerprint))).slice(1, length);
+}
+function isValid(id) {
+	return typeof id === "string" && id.length >= MIN_LENGTH && id.length <= MAX_LENGTH && CUID2_REGEX.test(id);
+}
+/**
+* Generate a CUID2 string.
+*
+* CUID2 is a secure, collision-resistant identifier that hashes multiple
+* entropy sources using SHA3-512. Unlike time-ordered IDs (ULID, UUID v7),
+* CUID2 prevents enumeration attacks by making IDs non-predictable.
+*
+* Note: CUID2 does not provide toBytes/fromBytes because it is a string-native
+* format with no canonical binary representation (unlike UUID's 16-byte format).
+*
+* @example
+* ```ts
+* import { cuid2 } from 'uniku/cuid2'
+*
+* const id = cuid2()
+* // => "pfh0haxfpzowht3oi213cqos"
+*
+* // Custom length
+* const shortId = cuid2({ length: 10 })
+* // => "tz4a98xxat"
+*
+* // Validation (type guard)
+* const maybeId: unknown = getUserInput()
+* if (cuid2.isValid(maybeId)) {
+*   console.log(maybeId.length) // TypeScript knows maybeId is string
+* }
+* ```
+*/
+const cuid2 = Object.assign(cuid2Fn, { isValid });
+
+//#endregion
+export { cuid2 };
+//# sourceMappingURL=cuid2.mjs.map

package/build/cuid2/cuid2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cuid2.mjs","names":["state: { counter: number | undefined; fingerprint: string | undefined }","chars: string[]","cuid2: Cuid2"],"sources":["../../src/cuid2/cuid2.ts"],"sourcesContent":["import { sha3_512 } from '@noble/hashes/sha3.js'\n\nexport type Cuid2Options = {\n  /**\n   * Length of the generated ID (2-32 characters).\n   * Default: 24\n   */\n  length?: number\n  /**\n   * Custom random bytes for deterministic testing.\n   * Must be at least 1 byte. For adequate entropy, use at least 16 bytes.\n   * Note: The fingerprint always uses cryptographically secure random bytes,\n   * regardless of this option.\n   */\n  random?: Uint8Array\n}\n\nexport type Cuid2 = {\n  (options?: Cuid2Options): string\n  isValid(id: unknown): id is string\n}\n\nconst DEFAULT_LENGTH = 24\nconst MAX_LENGTH = 32\nconst MIN_LENGTH = 2\n\n// Maximum initial counter value from cuid2 spec - provides ~29 bits of\n// initial entropy to prevent cross-process collisions at startup\nconst INITIAL_COUNT_MAX = 476782367\n\n// Validation regex: first char must be a-z, rest can be a-z or 0-9\nconst CUID2_REGEX = /^[a-z][0-9a-z]+$/\n\n// Base36 alphabet\nconst ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'\nconst LETTER_ALPHABET = 'abcdefghijklmnopqrstuvwxyz'\n\n// Reusable TextEncoder instance (stateless, safe to share)\nconst textEncoder = new TextEncoder()\n\n// Pre-allocated buffer for batched random byte generation (64 random numbers per batch)\nconst RANDOM_BUFFER_SIZE = 256\nconst randomBuffer = new Uint8Array(RANDOM_BUFFER_SIZE)\nlet randomBufferOffset = RANDOM_BUFFER_SIZE // Force initial fill\n\n/**\n * Module-level state for counter and fingerprint.\n * Counter is initialized lazily on first call to prevent unnecessary crypto operations.\n * Fingerprint is also generated lazily on first call.\n */\nconst state: { counter: number | undefined; fingerprint: string | undefined } = {\n  counter: undefined,\n  fingerprint: undefined,\n}\n\n/**\n * Initialize counter using crypto for consistency with other entropy sources.\n */\nfunction initializeCounter(): number {\n  const buffer = new Uint8Array(4)\n  globalThis.crypto.getRandomValues(buffer)\n  return (((buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]) >>> 0) % (INITIAL_COUNT_MAX + 1)\n}\n\n// --- Base36 utilities ---\n\nfunction bufToBigInt(buf: Uint8Array): bigint {\n  let value = 0n\n  for (const byte of buf) {\n    value = value * 256n + BigInt(byte)\n  }\n  return value\n}\n\nfunction bigIntToBase36(value: bigint): string {\n  if (value === 0n) return '0'\n  const chars: string[] = []\n  while (value > 0n) {\n    chars.push(ALPHABET[Number(value % 36n)])\n    value = value / 36n\n  }\n  return chars.reverse().join('')\n}\n\nfunction randomLetter(random: () => number): string {\n  return LETTER_ALPHABET[Math.floor(random() * 26)]\n}\n\nfunction createEntropy(length: number, random: () => number): string {\n  const chars = new Array<string>(length)\n  for (let i = 0; i < length; i++) {\n    chars[i] = ALPHABET[Math.floor(random() * 36)]\n  }\n  return chars.join('')\n}\n\n// --- SHA3 hash wrapper ---\n\nfunction hash(input: string): Uint8Array {\n  return sha3_512(textEncoder.encode(input))\n}\n\n// --- Fingerprint generation ---\n\nconst BIG_LENGTH = 32\n\nfunction createFingerprint(): string {\n  // Always use CSPRNG for fingerprint to ensure security regardless of custom random option\n  const random = getCryptoRandom\n  const globals = Object.keys(globalThis).toString()\n  const sourceString = globals + createEntropy(BIG_LENGTH, random)\n  const hashed = hash(sourceString)\n  return bigIntToBase36(bufToBigInt(hashed)).slice(1, BIG_LENGTH + 1)\n}\n\n// --- Random function factory ---\n\n/**\n * Get a random number in [0, 1) using batched CSPRNG.\n * Uses a pre-allocated buffer to reduce crypto.getRandomValues calls.\n */\nfunction getCryptoRandom(): number {\n  if (randomBufferOffset >= RANDOM_BUFFER_SIZE) {\n    globalThis.crypto.getRandomValues(randomBuffer)\n    randomBufferOffset = 0\n  }\n  const value =\n    (randomBuffer[randomBufferOffset] * 0x1000000 +\n      randomBuffer[randomBufferOffset + 1] * 0x10000 +\n      randomBuffer[randomBufferOffset + 2] * 0x100 +\n      randomBuffer[randomBufferOffset + 3]) /\n    0x100000000\n  randomBufferOffset += 4\n  return value\n}\n\nfunction getRandomFn(random?: Uint8Array): () => number {\n  if (random) {\n    if (random.length === 0) {\n      throw new Error('Random byte array cannot be empty')\n    }\n    let index = 0\n    return () => {\n      const value = random[index % random.length] / 256\n      index += 1\n      return value\n    }\n  }\n  return getCryptoRandom\n}\n\n// --- Main generator ---\n\nfunction cuid2Fn(options?: Cuid2Options): string {\n  const length = options?.length ?? DEFAULT_LENGTH\n\n  if (length < MIN_LENGTH || length > MAX_LENGTH) {\n    throw new RangeError(`CUID2 length must be between ${MIN_LENGTH} and ${MAX_LENGTH}. Received: ${length}`)\n  }\n\n  const random = getRandomFn(options?.random)\n\n  // Initialize counter lazily on first call\n  if (state.counter === undefined) {\n    state.counter = initializeCounter()\n  }\n\n  // Initialize fingerprint lazily on first call (always uses CSPRNG)\n  if (state.fingerprint === undefined) {\n    state.fingerprint = createFingerprint()\n  }\n\n  const firstLetter = randomLetter(random)\n  const time = Date.now().toString(36)\n  state.counter += 1\n  const count = state.counter.toString(36)\n  const salt = createEntropy(length, random)\n\n  const hashInput = time + salt + count + state.fingerprint\n  const hashed = hash(hashInput)\n  const base36Hash = bigIntToBase36(bufToBigInt(hashed))\n\n  // Drop first char of hash to avoid histogram bias, prepend random letter\n  return firstLetter + base36Hash.slice(1, length)\n}\n\n// --- Validation (type guard) ---\n\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length >= MIN_LENGTH && id.length <= MAX_LENGTH && CUID2_REGEX.test(id)\n}\n\n/**\n * Generate a CUID2 string.\n *\n * CUID2 is a secure, collision-resistant identifier that hashes multiple\n * entropy sources using SHA3-512. Unlike time-ordered IDs (ULID, UUID v7),\n * CUID2 prevents enumeration attacks by making IDs non-predictable.\n *\n * Note: CUID2 does not provide toBytes/fromBytes because it is a string-native\n * format with no canonical binary representation (unlike UUID's 16-byte format).\n *\n * @example\n * ```ts\n * import { cuid2 } from 'uniku/cuid2'\n *\n * const id = cuid2()\n * // => \"pfh0haxfpzowht3oi213cqos\"\n *\n * // Custom length\n * const shortId = cuid2({ length: 10 })\n * // => \"tz4a98xxat\"\n *\n * // Validation (type guard)\n * const maybeId: unknown = getUserInput()\n * if (cuid2.isValid(maybeId)) {\n *   console.log(maybeId.length) // TypeScript knows maybeId is string\n * }\n * ```\n */\nexport const cuid2: Cuid2 = Object.assign(cuid2Fn, {\n  isValid,\n})\n"],"mappings":"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"}

package/build/nanoid/nanoid.d.mts

@@ -0,0 +1,39 @@
+//#region src/nanoid/nanoid.d.ts
+/** Default URL-safe alphabet (64 characters): A-Z, a-z, 0-9, underscore, hyphen */
+declare const URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+type NanoidOptions = {
+  /**
+  * Random bytes for deterministic output (testing).
+  * Must provide enough bytes for rejection sampling (~size * 2).
+  */
+  random?: Uint8Array;
+  /**
+  * Custom alphabet to use. Default: URL-safe A-Za-z0-9_-
+  * Must be 2-256 printable ASCII characters (32-126) with no duplicates.
+  */
+  alphabet?: string;
+  /**
+  * Length of generated ID. Default: 21. Maximum: 2048.
+  */
+  size?: number;
+};
+type Nanoid = {
+  /** Generate nanoid with default settings */
+  (): string;
+  /** Generate nanoid with custom size */
+  (size: number): string;
+  /** Generate nanoid with options */
+  (options: NanoidOptions): string;
+  /**
+  * Validate a nanoid string against the default URL-safe alphabet.
+  * Note: Does not validate IDs generated with custom alphabets.
+  */
+  isValid(id: unknown): id is string;
+};
+/**
+* Generate a URL-friendly unique string ID.
+*/
+declare const nanoid: Nanoid;
+//#endregion
+export { Nanoid, NanoidOptions, URL_ALPHABET, nanoid };
+//# sourceMappingURL=nanoid.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nanoid.d.mts","names":["nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":[],"mappings":";;AACa,cAAA,YAAA,GAAA,kEAAA;AAMD,KAAA,aAAA,GAAA;EAiBZ;AAsHA;;;WAlIW;;;;;;;;;;;KAYC,MAAA;;;;;;YAMA;;;;;;;;;;cAgHCA,QAAQ"}

package/build/nanoid/nanoid.mjs

@@ -0,0 +1,73 @@
+//#region src/nanoid/nanoid.ts
+/** Default URL-safe alphabet (64 characters): A-Z, a-z, 0-9, underscore, hyphen */
+const URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
+const DEFAULT_SIZE = 21;
+const MAX_SIZE = 2048;
+const NANOID_REGEX = /^[A-Za-z0-9_-]+$/;
+/**
+* Validate alphabet: 2-256 printable ASCII chars, no duplicates
+*/
+function validateAlphabet(alphabet) {
+	if (alphabet.length < 2) throw new Error("Alphabet must contain at least 2 characters");
+	if (alphabet.length > 256) throw new Error("Alphabet must not exceed 256 characters");
+	const seen = /* @__PURE__ */ new Set();
+	for (const char of alphabet) {
+		const code = char.charCodeAt(0);
+		if (code < 32 || code > 126) throw new Error("Alphabet must contain only printable ASCII characters (32-126)");
+		if (seen.has(char)) throw new Error(`Duplicate character in alphabet: "${char}"`);
+		seen.add(char);
+	}
+}
+/**
+* Validate size parameter
+*/
+function validateSize(size) {
+	if (!Number.isInteger(size) || size < 0) throw new RangeError("Size must be a non-negative integer");
+	if (size > MAX_SIZE) throw new RangeError(`Size must not exceed ${MAX_SIZE}`);
+}
+function nanoidFn(sizeOrOptions) {
+	let size = DEFAULT_SIZE;
+	let alphabet = URL_ALPHABET;
+	let randomBytes;
+	if (typeof sizeOrOptions === "number") size = sizeOrOptions;
+	else if (sizeOrOptions) {
+		size = sizeOrOptions.size ?? DEFAULT_SIZE;
+		alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET;
+		randomBytes = sizeOrOptions.random;
+		if (sizeOrOptions.alphabet) validateAlphabet(alphabet);
+	}
+	validateSize(size);
+	if (size === 0) return "";
+	const mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+	const step = Math.ceil(1.6 * mask * size / alphabet.length);
+	let id = "";
+	let randomOffset = 0;
+	while (id.length < size) {
+		let bytes;
+		if (randomBytes) {
+			if (randomBytes.length - randomOffset < step) throw new Error(`Insufficient random bytes: need at least ${step} more, have ${randomBytes.length - randomOffset}`);
+			bytes = randomBytes.subarray(randomOffset, randomOffset + step);
+			randomOffset += step;
+		} else bytes = globalThis.crypto.getRandomValues(new Uint8Array(step));
+		for (let i = 0; i < bytes.length && id.length < size; i++) {
+			const index = bytes[i] & mask;
+			if (index < alphabet.length) id += alphabet[index];
+		}
+	}
+	return id;
+}
+/**
+* Validate a nanoid string against the default URL-safe alphabet.
+* Note: Does not validate IDs generated with custom alphabets.
+*/
+function isValid(id) {
+	return typeof id === "string" && id.length > 0 && NANOID_REGEX.test(id);
+}
+/**
+* Generate a URL-friendly unique string ID.
+*/
+const nanoid = Object.assign(nanoidFn, { isValid });
+
+//#endregion
+export { URL_ALPHABET, nanoid };
+//# sourceMappingURL=nanoid.mjs.map

package/build/nanoid/nanoid.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nanoid.mjs","names":["randomBytes: Uint8Array | undefined","bytes: Uint8Array","nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":["/** Default URL-safe alphabet (64 characters): A-Z, a-z, 0-9, underscore, hyphen */\nexport const URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-'\n\nconst DEFAULT_SIZE = 21\nconst MAX_SIZE = 2048\nconst NANOID_REGEX = /^[A-Za-z0-9_-]+$/\n\nexport type NanoidOptions = {\n  /**\n   * Random bytes for deterministic output (testing).\n   * Must provide enough bytes for rejection sampling (~size * 2).\n   */\n  random?: Uint8Array\n  /**\n   * Custom alphabet to use. Default: URL-safe A-Za-z0-9_-\n   * Must be 2-256 printable ASCII characters (32-126) with no duplicates.\n   */\n  alphabet?: string\n  /**\n   * Length of generated ID. Default: 21. Maximum: 2048.\n   */\n  size?: number\n}\n\nexport type Nanoid = {\n  /** Generate nanoid with default settings */\n  (): string\n  /** Generate nanoid with custom size */\n  (size: number): string\n  /** Generate nanoid with options */\n  (options: NanoidOptions): string\n  /**\n   * Validate a nanoid string against the default URL-safe alphabet.\n   * Note: Does not validate IDs generated with custom alphabets.\n   */\n  isValid(id: unknown): id is string\n}\n\n/**\n * Validate alphabet: 2-256 printable ASCII chars, no duplicates\n */\nfunction validateAlphabet(alphabet: string): void {\n  if (alphabet.length < 2) {\n    throw new Error('Alphabet must contain at least 2 characters')\n  }\n  if (alphabet.length > 256) {\n    throw new Error('Alphabet must not exceed 256 characters')\n  }\n  const seen = new Set<string>()\n  for (const char of alphabet) {\n    const code = char.charCodeAt(0)\n    if (code < 32 || code > 126) {\n      throw new Error('Alphabet must contain only printable ASCII characters (32-126)')\n    }\n    if (seen.has(char)) {\n      throw new Error(`Duplicate character in alphabet: \"${char}\"`)\n    }\n    seen.add(char)\n  }\n}\n\n/**\n * Validate size parameter\n */\nfunction validateSize(size: number): void {\n  if (!Number.isInteger(size) || size < 0) {\n    throw new RangeError('Size must be a non-negative integer')\n  }\n  if (size > MAX_SIZE) {\n    throw new RangeError(`Size must not exceed ${MAX_SIZE}`)\n  }\n}\n\n// Overloads\nfunction nanoidFn(): string\nfunction nanoidFn(size: number): string\nfunction nanoidFn(options: NanoidOptions): string\nfunction nanoidFn(sizeOrOptions?: number | NanoidOptions): string {\n  let size = DEFAULT_SIZE\n  let alphabet = URL_ALPHABET\n  let randomBytes: Uint8Array | undefined\n\n  if (typeof sizeOrOptions === 'number') {\n    size = sizeOrOptions\n  } else if (sizeOrOptions) {\n    size = sizeOrOptions.size ?? DEFAULT_SIZE\n    alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET\n    randomBytes = sizeOrOptions.random\n    if (sizeOrOptions.alphabet) {\n      validateAlphabet(alphabet)\n    }\n  }\n\n  validateSize(size)\n\n  if (size === 0) return ''\n\n  // Calculate mask: smallest power-of-2 minus 1 that covers alphabet size\n  const mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1\n  // Calculate step: random bytes per batch (1.6x accounts for rejection)\n  const step = Math.ceil((1.6 * mask * size) / alphabet.length)\n\n  let id = ''\n  let randomOffset = 0\n\n  while (id.length < size) {\n    let bytes: Uint8Array\n    if (randomBytes) {\n      if (randomBytes.length - randomOffset < step) {\n        throw new Error(\n          `Insufficient random bytes: need at least ${step} more, have ${randomBytes.length - randomOffset}`,\n        )\n      }\n      bytes = randomBytes.subarray(randomOffset, randomOffset + step)\n      randomOffset += step\n    } else {\n      bytes = globalThis.crypto.getRandomValues(new Uint8Array(step))\n    }\n\n    for (let i = 0; i < bytes.length && id.length < size; i++) {\n      const index = bytes[i] & mask\n      if (index < alphabet.length) {\n        id += alphabet[index]\n      }\n      // Otherwise reject and continue (no modulo bias)\n    }\n  }\n\n  return id\n}\n\n/**\n * Validate a nanoid string against the default URL-safe alphabet.\n * Note: Does not validate IDs generated with custom alphabets.\n */\nfunction isValid(id: unknown): id is string {\n  return typeof id === 'string' && id.length > 0 && NANOID_REGEX.test(id)\n}\n\n/**\n * Generate a URL-friendly unique string ID.\n */\nexport const nanoid: Nanoid = Object.assign(nanoidFn, {\n  isValid,\n})\n"],"mappings":";;AACA,MAAa,eAAe;AAE5B,MAAM,eAAe;AACrB,MAAM,WAAW;AACjB,MAAM,eAAe;;;;AAoCrB,SAAS,iBAAiB,UAAwB;AAChD,KAAI,SAAS,SAAS,EACpB,OAAM,IAAI,MAAM,8CAA8C;AAEhE,KAAI,SAAS,SAAS,IACpB,OAAM,IAAI,MAAM,0CAA0C;CAE5D,MAAM,uBAAO,IAAI,KAAa;AAC9B,MAAK,MAAM,QAAQ,UAAU;EAC3B,MAAM,OAAO,KAAK,WAAW,EAAE;AAC/B,MAAI,OAAO,MAAM,OAAO,IACtB,OAAM,IAAI,MAAM,iEAAiE;AAEnF,MAAI,KAAK,IAAI,KAAK,CAChB,OAAM,IAAI,MAAM,qCAAqC,KAAK,GAAG;AAE/D,OAAK,IAAI,KAAK;;;;;;AAOlB,SAAS,aAAa,MAAoB;AACxC,KAAI,CAAC,OAAO,UAAU,KAAK,IAAI,OAAO,EACpC,OAAM,IAAI,WAAW,sCAAsC;AAE7D,KAAI,OAAO,SACT,OAAM,IAAI,WAAW,wBAAwB,WAAW;;AAQ5D,SAAS,SAAS,eAAgD;CAChE,IAAI,OAAO;CACX,IAAI,WAAW;CACf,IAAIA;AAEJ,KAAI,OAAO,kBAAkB,SAC3B,QAAO;UACE,eAAe;AACxB,SAAO,cAAc,QAAQ;AAC7B,aAAW,cAAc,YAAY;AACrC,gBAAc,cAAc;AAC5B,MAAI,cAAc,SAChB,kBAAiB,SAAS;;AAI9B,cAAa,KAAK;AAElB,KAAI,SAAS,EAAG,QAAO;CAGvB,MAAM,QAAQ,KAAM,KAAK,KAAK,MAAO,SAAS,SAAS,IAAK,EAAE,IAAK;CAEnE,MAAM,OAAO,KAAK,KAAM,MAAM,OAAO,OAAQ,SAAS,OAAO;CAE7D,IAAI,KAAK;CACT,IAAI,eAAe;AAEnB,QAAO,GAAG,SAAS,MAAM;EACvB,IAAIC;AACJ,MAAI,aAAa;AACf,OAAI,YAAY,SAAS,eAAe,KACtC,OAAM,IAAI,MACR,4CAA4C,KAAK,cAAc,YAAY,SAAS,eACrF;AAEH,WAAQ,YAAY,SAAS,cAAc,eAAe,KAAK;AAC/D,mBAAgB;QAEhB,SAAQ,WAAW,OAAO,gBAAgB,IAAI,WAAW,KAAK,CAAC;AAGjE,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,UAAU,GAAG,SAAS,MAAM,KAAK;GACzD,MAAM,QAAQ,MAAM,KAAK;AACzB,OAAI,QAAQ,SAAS,OACnB,OAAM,SAAS;;;AAMrB,QAAO;;;;;;AAOT,SAAS,QAAQ,IAA2B;AAC1C,QAAO,OAAO,OAAO,YAAY,GAAG,SAAS,KAAK,aAAa,KAAK,GAAG;;;;;AAMzE,MAAaC,SAAiB,OAAO,OAAO,UAAU,EACpD,SACD,CAAC"}

package/build/random-Dul5R6oJ.mjs

@@ -0,0 +1,17 @@
+//#region src/uuid/common/random.ts
+function randomBytes(out) {
+	globalThis.crypto.getRandomValues(out);
+}
+/**
+* Generate 16 bytes of cryptographically strong random data.
+* Used internally by UUID generators.
+*/
+function rng() {
+	const bytes = new Uint8Array(16);
+	randomBytes(bytes);
+	return bytes;
+}
+
+//#endregion
+export { rng as t };
+//# sourceMappingURL=random-Dul5R6oJ.mjs.map

package/build/random-Dul5R6oJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-Dul5R6oJ.mjs","names":[],"sources":["../src/uuid/common/random.ts"],"sourcesContent":["export function randomBytes(out: Uint8Array): void {\n  const crypto = globalThis.crypto\n  crypto.getRandomValues(out)\n}\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Used internally by UUID generators.\n */\nexport function rng(): Uint8Array {\n  const bytes = new Uint8Array(16)\n  randomBytes(bytes)\n  return bytes\n}\n"],"mappings":";AAAA,SAAgB,YAAY,KAAuB;AAEjD,CADe,WAAW,OACnB,gBAAgB,IAAI;;;;;;AAO7B,SAAgB,MAAkB;CAChC,MAAM,QAAQ,IAAI,WAAW,GAAG;AAChC,aAAY,MAAM;AAClB,QAAO"}

package/build/ulid/ulid.d.mts

@@ -0,0 +1,30 @@
+//#region src/ulid/ulid.d.ts
+type UlidOptions = {
+  /**
+  * 16 bytes of random data to use for ULID generation.
+  * Only the first 10 bytes are used.
+  */
+  random?: Uint8Array;
+  /**
+  * Timestamp in milliseconds since Unix epoch.
+  * Defaults to Date.now().
+  */
+  msecs?: number;
+};
+type Ulid = {
+  (): string;
+  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf;
+  (options?: UlidOptions, buf?: undefined, offset?: number): string;
+  toBytes(id: string): Uint8Array;
+  fromBytes(bytes: Uint8Array): string;
+  timestamp(id: string): number;
+  isValid(id: string): boolean;
+};
+/**
+* Generate a ULID string or write the bytes into a buffer.
+* It also includes helpers to convert to and from byte arrays.
+*/
+declare const ulid: Ulid;
+//#endregion
+export { Ulid, UlidOptions, ulid };
+//# sourceMappingURL=ulid.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ulid.d.mts","names":["ulid: Ulid"],"sources":["../../src/ulid/ulid.ts"],"sourcesContent":[],"mappings":";KAGY,WAAA;EAAZ;AAaA;;;EAEkD,MAAA,CAAA,EAVvC,UAUuC;EAA8B;;;;EAG7D,KAAA,CAAA,EAAA,MAAA;CAAA;AA4HNA,KAjID,IAAA,GAiIO;;gBA/HH,aAAa,qBAAqB,8BAA8B,wBAAwB;aAC3F;uBACU;mBACJ;;;;;;;;cA4HNA,MAAM"}

package/build/ulid/ulid.mjs

@@ -0,0 +1,192 @@
+import { t as rng } from "../random-Dul5R6oJ.mjs";
+
+//#region src/ulid/common/crockford.ts
+const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const DECODING = new Uint8Array(128);
+DECODING.fill(255);
+for (let i = 0; i < 32; i += 1) {
+	const upper = ENCODING.charCodeAt(i);
+	const lower = ENCODING[i].toLowerCase().charCodeAt(0);
+	DECODING[upper] = i;
+	DECODING[lower] = i;
+}
+const TIME_LEN = 10;
+/**
+* Encode a 48-bit timestamp to a 10-character Crockford Base32 string.
+* Uses unrolled division for performance.
+*/
+function encodeTime(time) {
+	return ENCODING[Math.floor(time / 35184372088832) & 31] + ENCODING[Math.floor(time / 1099511627776) & 31] + ENCODING[Math.floor(time / 34359738368) & 31] + ENCODING[Math.floor(time / 1073741824) & 31] + ENCODING[Math.floor(time / 33554432) & 31] + ENCODING[Math.floor(time / 1048576) & 31] + ENCODING[Math.floor(time / 32768) & 31] + ENCODING[Math.floor(time / 1024) & 31] + ENCODING[Math.floor(time / 32) & 31] + ENCODING[time & 31];
+}
+/**
+* Encode 10 bytes (80 bits) of random data to a 16-character Crockford Base32 string.
+*/
+function encodeRandom(bytes) {
+	return ENCODING[bytes[0] >> 3 & 31] + ENCODING[(bytes[0] << 2 | bytes[1] >> 6) & 31] + ENCODING[bytes[1] >> 1 & 31] + ENCODING[(bytes[1] << 4 | bytes[2] >> 4) & 31] + ENCODING[(bytes[2] << 1 | bytes[3] >> 7) & 31] + ENCODING[bytes[3] >> 2 & 31] + ENCODING[(bytes[3] << 3 | bytes[4] >> 5) & 31] + ENCODING[bytes[4] & 31] + ENCODING[bytes[5] >> 3 & 31] + ENCODING[(bytes[5] << 2 | bytes[6] >> 6) & 31] + ENCODING[bytes[6] >> 1 & 31] + ENCODING[(bytes[6] << 4 | bytes[7] >> 4) & 31] + ENCODING[(bytes[7] << 1 | bytes[8] >> 7) & 31] + ENCODING[bytes[8] >> 2 & 31] + ENCODING[(bytes[8] << 3 | bytes[9] >> 5) & 31] + ENCODING[bytes[9] & 31];
+}
+/**
+* Decode the first 10 characters of a ULID string to a timestamp (Unix epoch milliseconds).
+*/
+function decodeTime(str) {
+	let time = 0;
+	for (let i = 0; i < TIME_LEN; i += 1) {
+		const value = DECODING[str.charCodeAt(i)];
+		if (value === 255) throw new Error(`Invalid ULID character: ${str[i]}`);
+		time = time * 32 + value;
+	}
+	return time;
+}
+/**
+* Decode a 26-character ULID string to 16 bytes.
+* Inlines all lookups to avoid intermediate array allocation.
+*/
+function decodeToBytes(str) {
+	if (str.length !== 26) throw new Error("ULID string must be 26 characters");
+	const bytes = new Uint8Array(16);
+	const v0 = DECODING[str.charCodeAt(0)];
+	const v1 = DECODING[str.charCodeAt(1)];
+	const v2 = DECODING[str.charCodeAt(2)];
+	const v3 = DECODING[str.charCodeAt(3)];
+	const v4 = DECODING[str.charCodeAt(4)];
+	const v5 = DECODING[str.charCodeAt(5)];
+	const v6 = DECODING[str.charCodeAt(6)];
+	const v7 = DECODING[str.charCodeAt(7)];
+	const v8 = DECODING[str.charCodeAt(8)];
+	const v9 = DECODING[str.charCodeAt(9)];
+	const v10 = DECODING[str.charCodeAt(10)];
+	const v11 = DECODING[str.charCodeAt(11)];
+	const v12 = DECODING[str.charCodeAt(12)];
+	const v13 = DECODING[str.charCodeAt(13)];
+	const v14 = DECODING[str.charCodeAt(14)];
+	const v15 = DECODING[str.charCodeAt(15)];
+	const v16 = DECODING[str.charCodeAt(16)];
+	const v17 = DECODING[str.charCodeAt(17)];
+	const v18 = DECODING[str.charCodeAt(18)];
+	const v19 = DECODING[str.charCodeAt(19)];
+	const v20 = DECODING[str.charCodeAt(20)];
+	const v21 = DECODING[str.charCodeAt(21)];
+	const v22 = DECODING[str.charCodeAt(22)];
+	const v23 = DECODING[str.charCodeAt(23)];
+	const v24 = DECODING[str.charCodeAt(24)];
+	const v25 = DECODING[str.charCodeAt(25)];
+	if ((v0 | v1 | v2 | v3 | v4 | v5 | v6 | v7 | v8 | v9 | v10 | v11 | v12 | v13 | v14 | v15 | v16 | v17 | v18 | v19 | v20 | v21 | v22 | v23 | v24 | v25) & 128) {
+		for (let i = 0; i < 26; i += 1) if (DECODING[str.charCodeAt(i)] === 255) throw new Error(`Invalid ULID character: ${str[i]}`);
+	}
+	bytes[0] = v0 << 5 | v1;
+	bytes[1] = v2 << 3 | v3 >> 2;
+	bytes[2] = v3 << 6 | v4 << 1 | v5 >> 4;
+	bytes[3] = v5 << 4 | v6 >> 1;
+	bytes[4] = v6 << 7 | v7 << 2 | v8 >> 3;
+	bytes[5] = v8 << 5 | v9;
+	bytes[6] = v10 << 3 | v11 >> 2;
+	bytes[7] = v11 << 6 | v12 << 1 | v13 >> 4;
+	bytes[8] = v13 << 4 | v14 >> 1;
+	bytes[9] = v14 << 7 | v15 << 2 | v16 >> 3;
+	bytes[10] = v16 << 5 | v17;
+	bytes[11] = v18 << 3 | v19 >> 2;
+	bytes[12] = v19 << 6 | v20 << 1 | v21 >> 4;
+	bytes[13] = v21 << 4 | v22 >> 1;
+	bytes[14] = v22 << 7 | v23 << 2 | v24 >> 3;
+	bytes[15] = v24 << 5 | v25;
+	return bytes;
+}
+/**
+* Encode 16 bytes to a 26-character ULID string.
+*/
+function bytesToUlid(bytes) {
+	if (bytes.length < 16) throw new Error("Byte array must be at least 16 bytes");
+	let time = 0;
+	for (let i = 0; i < 6; i += 1) time = time * 256 + bytes[i];
+	return encodeTime(time) + encodeRandom(bytes.subarray(6, 16));
+}
+
+//#endregion
+//#region src/ulid/ulid.ts
+const ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i;
+/**
+* Module-level state for maintaining monotonic ordering within the same millisecond.
+*
+* IMPORTANT: This state persists across all ulid() calls in the module's lifetime.
+* - In serverless/edge functions with warm starts, state persists between invocations.
+* - For isolated state, pass explicit `msecs` and `random` via options.
+* - Tests should mock Date.now() or provide explicit options for deterministic behavior.
+*/
+const state = {
+	msecs: -Infinity,
+	lastRandom: new Uint8Array(10)
+};
+/**
+* Increment a byte array by 1, propagating carry from LSB to MSB.
+* Returns a new array (does not modify input).
+*/
+function incrementBytes(bytes) {
+	const result = new Uint8Array(bytes);
+	for (let i = result.length - 1; i >= 0; i -= 1) {
+		if (result[i] < 255) {
+			result[i] += 1;
+			return result;
+		}
+		result[i] = 0;
+	}
+	return result;
+}
+function ulidBytes(time, random, buf, offset = 0) {
+	if (!buf) {
+		buf = new Uint8Array(16);
+		offset = 0;
+	} else if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`ULID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+	buf[offset] = time / 1099511627776 & 255;
+	buf[offset + 1] = time / 4294967296 & 255;
+	buf[offset + 2] = time / 16777216 & 255;
+	buf[offset + 3] = time / 65536 & 255;
+	buf[offset + 4] = time / 256 & 255;
+	buf[offset + 5] = time & 255;
+	for (let i = 0; i < 10; i += 1) buf[offset + 6 + i] = random[i];
+	return buf;
+}
+function ulidFn(options, buf, offset = 0) {
+	let time;
+	let random;
+	/**
+	* Note: by default, Cloudflare Workers "freezes" time during request handling to prevent
+	* side-channel attacks. This means that Date.now() will return the same value for the entire
+	* duration of a request.
+	* Implications:
+	* - all ULIDs generated within a single request will have the same timestamp.
+	* - the monotonic ordering will rely entirely on incrementing the random portion.
+	*/
+	const defaultTime = Date.now();
+	if (options) {
+		time = options.msecs ?? defaultTime;
+		random = options.random ?? rng();
+	} else {
+		time = defaultTime;
+		if (time > state.msecs) {
+			random = rng();
+			state.msecs = time;
+			state.lastRandom.set(random.subarray(0, 10));
+		} else {
+			random = incrementBytes(state.lastRandom);
+			state.lastRandom = random;
+		}
+	}
+	if (buf) {
+		ulidBytes(time, random, buf, offset);
+		return buf;
+	}
+	return encodeTime(time) + encodeRandom(random);
+}
+/**
+* Generate a ULID string or write the bytes into a buffer.
+* It also includes helpers to convert to and from byte arrays.
+*/
+const ulid = Object.assign(ulidFn, {
+	toBytes: (id) => decodeToBytes(id),
+	fromBytes: (bytes) => bytesToUlid(bytes),
+	timestamp: (id) => decodeTime(id.slice(0, 10)),
+	isValid: (id) => ULID_REGEX.test(id)
+});
+
+//#endregion
+export { ulid };
+//# sourceMappingURL=ulid.mjs.map

package/build/ulid/ulid.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ulid.mjs","names":["state: UlidState","time: number","random: Uint8Array","ulid: Ulid"],"sources":["../../src/ulid/common/crockford.ts","../../src/ulid/ulid.ts"],"sourcesContent":["// Crockford's Base32 alphabet (excludes I, L, O, U to avoid confusion)\nconst ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ'\n\n// Pre-computed decoding table indexed by ASCII code (0-127)\n// Uses Uint8Array for cache-efficient lookups via charCodeAt\nconst DECODING = new Uint8Array(128)\nDECODING.fill(255) // 255 = invalid marker\nfor (let i = 0; i < ENCODING.length; i += 1) {\n  const upper = ENCODING.charCodeAt(i)\n  const lower = ENCODING[i].toLowerCase().charCodeAt(0)\n  DECODING[upper] = i\n  DECODING[lower] = i\n}\n\nconst TIME_LEN = 10\n\n/**\n * Encode a 48-bit timestamp to a 10-character Crockford Base32 string.\n * Uses unrolled division for performance.\n */\nexport function encodeTime(time: number): string {\n  // Unrolled encoding - each step divides by 32 and extracts 5 bits\n  // Powers of 32: 32^9=0x200000000000, 32^8=0x10000000000, etc.\n  return (\n    ENCODING[Math.floor(time / 0x200000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x10000000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x800000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x40000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x2000000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x100000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x8000) & 0x1f] +\n    ENCODING[Math.floor(time / 0x400) & 0x1f] +\n    ENCODING[Math.floor(time / 0x20) & 0x1f] +\n    ENCODING[time & 0x1f]\n  )\n}\n\n/**\n * Encode 10 bytes (80 bits) of random data to a 16-character Crockford Base32 string.\n */\nexport function encodeRandom(bytes: Uint8Array): string {\n  // Each character encodes 5 bits. 80 bits = 16 characters.\n  // Single concatenation expression for optimal performance.\n  return (\n    ENCODING[(bytes[0] >> 3) & 0x1f] +\n    ENCODING[((bytes[0] << 2) | (bytes[1] >> 6)) & 0x1f] +\n    ENCODING[(bytes[1] >> 1) & 0x1f] +\n    ENCODING[((bytes[1] << 4) | (bytes[2] >> 4)) & 0x1f] +\n    ENCODING[((bytes[2] << 1) | (bytes[3] >> 7)) & 0x1f] +\n    ENCODING[(bytes[3] >> 2) & 0x1f] +\n    ENCODING[((bytes[3] << 3) | (bytes[4] >> 5)) & 0x1f] +\n    ENCODING[bytes[4] & 0x1f] +\n    ENCODING[(bytes[5] >> 3) & 0x1f] +\n    ENCODING[((bytes[5] << 2) | (bytes[6] >> 6)) & 0x1f] +\n    ENCODING[(bytes[6] >> 1) & 0x1f] +\n    ENCODING[((bytes[6] << 4) | (bytes[7] >> 4)) & 0x1f] +\n    ENCODING[((bytes[7] << 1) | (bytes[8] >> 7)) & 0x1f] +\n    ENCODING[(bytes[8] >> 2) & 0x1f] +\n    ENCODING[((bytes[8] << 3) | (bytes[9] >> 5)) & 0x1f] +\n    ENCODING[bytes[9] & 0x1f]\n  )\n}\n\n/**\n * Decode the first 10 characters of a ULID string to a timestamp (Unix epoch milliseconds).\n */\nexport function decodeTime(str: string): number {\n  let time = 0\n  for (let i = 0; i < TIME_LEN; i += 1) {\n    const value = DECODING[str.charCodeAt(i)]\n    if (value === 255) {\n      throw new Error(`Invalid ULID character: ${str[i]}`)\n    }\n    time = time * 32 + value\n  }\n  return time\n}\n\n/**\n * Decode a 26-character ULID string to 16 bytes.\n * Inlines all lookups to avoid intermediate array allocation.\n */\nexport function decodeToBytes(str: string): Uint8Array {\n  if (str.length !== 26) {\n    throw new Error('ULID string must be 26 characters')\n  }\n\n  const bytes = new Uint8Array(16)\n\n  // Inline all 26 character lookups\n  const v0 = DECODING[str.charCodeAt(0)]\n  const v1 = DECODING[str.charCodeAt(1)]\n  const v2 = DECODING[str.charCodeAt(2)]\n  const v3 = DECODING[str.charCodeAt(3)]\n  const v4 = DECODING[str.charCodeAt(4)]\n  const v5 = DECODING[str.charCodeAt(5)]\n  const v6 = DECODING[str.charCodeAt(6)]\n  const v7 = DECODING[str.charCodeAt(7)]\n  const v8 = DECODING[str.charCodeAt(8)]\n  const v9 = DECODING[str.charCodeAt(9)]\n  const v10 = DECODING[str.charCodeAt(10)]\n  const v11 = DECODING[str.charCodeAt(11)]\n  const v12 = DECODING[str.charCodeAt(12)]\n  const v13 = DECODING[str.charCodeAt(13)]\n  const v14 = DECODING[str.charCodeAt(14)]\n  const v15 = DECODING[str.charCodeAt(15)]\n  const v16 = DECODING[str.charCodeAt(16)]\n  const v17 = DECODING[str.charCodeAt(17)]\n  const v18 = DECODING[str.charCodeAt(18)]\n  const v19 = DECODING[str.charCodeAt(19)]\n  const v20 = DECODING[str.charCodeAt(20)]\n  const v21 = DECODING[str.charCodeAt(21)]\n  const v22 = DECODING[str.charCodeAt(22)]\n  const v23 = DECODING[str.charCodeAt(23)]\n  const v24 = DECODING[str.charCodeAt(24)]\n  const v25 = DECODING[str.charCodeAt(25)]\n\n  // Validate all characters (255 = invalid marker)\n  if (\n    (v0 |\n      v1 |\n      v2 |\n      v3 |\n      v4 |\n      v5 |\n      v6 |\n      v7 |\n      v8 |\n      v9 |\n      v10 |\n      v11 |\n      v12 |\n      v13 |\n      v14 |\n      v15 |\n      v16 |\n      v17 |\n      v18 |\n      v19 |\n      v20 |\n      v21 |\n      v22 |\n      v23 |\n      v24 |\n      v25) &\n    0x80\n  ) {\n    // Find the invalid character for error message\n    for (let i = 0; i < 26; i += 1) {\n      if (DECODING[str.charCodeAt(i)] === 255) {\n        throw new Error(`Invalid ULID character: ${str[i]}`)\n      }\n    }\n  }\n\n  // Timestamp: first 10 characters -> bytes 0-5\n  bytes[0] = (v0 << 5) | v1\n  bytes[1] = (v2 << 3) | (v3 >> 2)\n  bytes[2] = (v3 << 6) | (v4 << 1) | (v5 >> 4)\n  bytes[3] = (v5 << 4) | (v6 >> 1)\n  bytes[4] = (v6 << 7) | (v7 << 2) | (v8 >> 3)\n  bytes[5] = (v8 << 5) | v9\n\n  // Random: last 16 characters -> bytes 6-15\n  bytes[6] = (v10 << 3) | (v11 >> 2)\n  bytes[7] = (v11 << 6) | (v12 << 1) | (v13 >> 4)\n  bytes[8] = (v13 << 4) | (v14 >> 1)\n  bytes[9] = (v14 << 7) | (v15 << 2) | (v16 >> 3)\n  bytes[10] = (v16 << 5) | v17\n  bytes[11] = (v18 << 3) | (v19 >> 2)\n  bytes[12] = (v19 << 6) | (v20 << 1) | (v21 >> 4)\n  bytes[13] = (v21 << 4) | (v22 >> 1)\n  bytes[14] = (v22 << 7) | (v23 << 2) | (v24 >> 3)\n  bytes[15] = (v24 << 5) | v25\n\n  return bytes\n}\n\n/**\n * Encode 16 bytes to a 26-character ULID string.\n */\nexport function bytesToUlid(bytes: Uint8Array): string {\n  if (bytes.length < 16) {\n    throw new Error('Byte array must be at least 16 bytes')\n  }\n\n  // Timestamp: bytes 0-5 -> 10 characters\n  let time = 0\n  for (let i = 0; i < 6; i += 1) {\n    time = time * 256 + bytes[i]\n  }\n  const timeStr = encodeTime(time)\n\n  // Random: bytes 6-15 -> 16 characters\n  const randomStr = encodeRandom(bytes.subarray(6, 16))\n\n  return timeStr + randomStr\n}\n","import { rng } from '../uuid/common/random'\nimport { bytesToUlid, decodeTime, decodeToBytes, encodeRandom, encodeTime } from './common/crockford'\n\nexport type UlidOptions = {\n  /**\n   * 16 bytes of random data to use for ULID generation.\n   * Only the first 10 bytes are used.\n   */\n  random?: Uint8Array\n  /**\n   * Timestamp in milliseconds since Unix epoch.\n   * Defaults to Date.now().\n   */\n  msecs?: number\n}\n\nexport type Ulid = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: UlidOptions | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: UlidOptions, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: string): boolean\n}\n\n// Validation regex: first char [0-7] to prevent overflow, rest from Crockford alphabet\nconst ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i\n\ntype UlidState = {\n  msecs: number\n  lastRandom: Uint8Array\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all ulid() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `random` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: UlidState = {\n  msecs: -Infinity,\n  lastRandom: new Uint8Array(10),\n}\n\n/**\n * Increment a byte array by 1, propagating carry from LSB to MSB.\n * Returns a new array (does not modify input).\n */\nfunction incrementBytes(bytes: Uint8Array): Uint8Array {\n  const result = new Uint8Array(bytes)\n  for (let i = result.length - 1; i >= 0; i -= 1) {\n    if (result[i] < 255) {\n      result[i] += 1\n      return result\n    }\n    result[i] = 0\n  }\n  return result\n}\n\nfunction ulidBytes(time: number, random: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (!buf) {\n    buf = new Uint8Array(16)\n    offset = 0\n  } else if (offset < 0 || offset + 16 > buf.length) {\n    throw new RangeError(`ULID byte range ${offset}:${offset + 15} is out of buffer bounds`)\n  }\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch) -> bytes 0-5\n  buf[offset] = (time / 0x10000000000) & 0xff\n  buf[offset + 1] = (time / 0x100000000) & 0xff\n  buf[offset + 2] = (time / 0x1000000) & 0xff\n  buf[offset + 3] = (time / 0x10000) & 0xff\n  buf[offset + 4] = (time / 0x100) & 0xff\n  buf[offset + 5] = time & 0xff\n\n  // Random (80 bits) -> bytes 6-15\n  for (let i = 0; i < 10; i += 1) {\n    buf[offset + 6 + i] = random[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a ULID string.\n */\nfunction ulidFn(options?: UlidOptions, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with ULID bytes.\n */\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(\n  options: UlidOptions | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction ulidFn<TBuf extends Uint8Array = Uint8Array>(options?: UlidOptions, buf?: TBuf, offset = 0): string | TBuf {\n  let time: number\n  let random: Uint8Array\n\n  /**\n   * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n   * side-channel attacks. This means that Date.now() will return the same value for the entire\n   * duration of a request.\n   * Implications:\n   * - all ULIDs generated within a single request will have the same timestamp.\n   * - the monotonic ordering will rely entirely on incrementing the random portion.\n   */\n  const defaultTime = Date.now()\n\n  if (options) {\n    // Explicit options provided - use them directly without monotonic state\n    time = options.msecs ?? defaultTime\n    random = options.random ?? rng()\n  } else {\n    time = defaultTime\n\n    if (time > state.msecs) {\n      // New millisecond: generate fresh random\n      random = rng()\n      state.msecs = time\n      state.lastRandom.set(random.subarray(0, 10))\n    } else {\n      // Same millisecond: increment random portion for monotonic ordering\n      random = incrementBytes(state.lastRandom)\n      state.lastRandom = random\n    }\n  }\n\n  if (buf) {\n    ulidBytes(time, random, buf, offset)\n    return buf\n  }\n\n  // String mode: encode directly without buffer allocation\n  return encodeTime(time) + encodeRandom(random)\n}\n\n/**\n * Generate a ULID string or write the bytes into a buffer.\n * It also includes helpers to convert to and from byte arrays.\n */\nexport const ulid: Ulid = Object.assign(ulidFn, {\n  toBytes: (id: string) => decodeToBytes(id),\n  fromBytes: (bytes: Uint8Array) => bytesToUlid(bytes),\n  timestamp: (id: string) => decodeTime(id.slice(0, 10)),\n  isValid: (id: string) => ULID_REGEX.test(id),\n})\n"],"mappings":";;;AACA,MAAM,WAAW;AAIjB,MAAM,WAAW,IAAI,WAAW,IAAI;AACpC,SAAS,KAAK,IAAI;AAClB,KAAK,IAAI,IAAI,GAAG,IAAI,IAAiB,KAAK,GAAG;CAC3C,MAAM,QAAQ,SAAS,WAAW,EAAE;CACpC,MAAM,QAAQ,SAAS,GAAG,aAAa,CAAC,WAAW,EAAE;AACrD,UAAS,SAAS;AAClB,UAAS,SAAS;;AAGpB,MAAM,WAAW;;;;;AAMjB,SAAgB,WAAW,MAAsB;AAG/C,QACE,SAAS,KAAK,MAAM,OAAO,eAAe,GAAG,MAC7C,SAAS,KAAK,MAAM,OAAO,cAAc,GAAG,MAC5C,SAAS,KAAK,MAAM,OAAO,YAAY,GAAG,MAC1C,SAAS,KAAK,MAAM,OAAO,WAAW,GAAG,MACzC,SAAS,KAAK,MAAM,OAAO,SAAU,GAAG,MACxC,SAAS,KAAK,MAAM,OAAO,QAAS,GAAG,MACvC,SAAS,KAAK,MAAM,OAAO,MAAO,GAAG,MACrC,SAAS,KAAK,MAAM,OAAO,KAAM,GAAG,MACpC,SAAS,KAAK,MAAM,OAAO,GAAK,GAAG,MACnC,SAAS,OAAO;;;;;AAOpB,SAAgB,aAAa,OAA2B;AAGtD,QACE,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAS,MAAM,KAAK,MACpB,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAU,MAAM,MAAM,IAAK,MAC3B,UAAW,MAAM,MAAM,IAAM,MAAM,MAAM,KAAM,MAC/C,SAAS,MAAM,KAAK;;;;;AAOxB,SAAgB,WAAW,KAAqB;CAC9C,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,GAAG,IAAI,UAAU,KAAK,GAAG;EACpC,MAAM,QAAQ,SAAS,IAAI,WAAW,EAAE;AACxC,MAAI,UAAU,IACZ,OAAM,IAAI,MAAM,2BAA2B,IAAI,KAAK;AAEtD,SAAO,OAAO,KAAK;;AAErB,QAAO;;;;;;AAOT,SAAgB,cAAc,KAAyB;AACrD,KAAI,IAAI,WAAW,GACjB,OAAM,IAAI,MAAM,oCAAoC;CAGtD,MAAM,QAAQ,IAAI,WAAW,GAAG;CAGhC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,KAAK,SAAS,IAAI,WAAW,EAAE;CACrC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;CACvC,MAAM,MAAM,SAAS,IAAI,WAAW,GAAG;AAGvC,MACG,KACC,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,MACA,OACF,KAGA;OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,EAC3B,KAAI,SAAS,IAAI,WAAW,EAAE,MAAM,IAClC,OAAM,IAAI,MAAM,2BAA2B,IAAI,KAAK;;AAM1D,OAAM,KAAM,MAAM,IAAK;AACvB,OAAM,KAAM,MAAM,IAAM,MAAM;AAC9B,OAAM,KAAM,MAAM,IAAM,MAAM,IAAM,MAAM;AAC1C,OAAM,KAAM,MAAM,IAAM,MAAM;AAC9B,OAAM,KAAM,MAAM,IAAM,MAAM,IAAM,MAAM;AAC1C,OAAM,KAAM,MAAM,IAAK;AAGvB,OAAM,KAAM,OAAO,IAAM,OAAO;AAChC,OAAM,KAAM,OAAO,IAAM,OAAO,IAAM,OAAO;AAC7C,OAAM,KAAM,OAAO,IAAM,OAAO;AAChC,OAAM,KAAM,OAAO,IAAM,OAAO,IAAM,OAAO;AAC7C,OAAM,MAAO,OAAO,IAAK;AACzB,OAAM,MAAO,OAAO,IAAM,OAAO;AACjC,OAAM,MAAO,OAAO,IAAM,OAAO,IAAM,OAAO;AAC9C,OAAM,MAAO,OAAO,IAAM,OAAO;AACjC,OAAM,MAAO,OAAO,IAAM,OAAO,IAAM,OAAO;AAC9C,OAAM,MAAO,OAAO,IAAK;AAEzB,QAAO;;;;;AAMT,SAAgB,YAAY,OAA2B;AACrD,KAAI,MAAM,SAAS,GACjB,OAAM,IAAI,MAAM,uCAAuC;CAIzD,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,EAC1B,QAAO,OAAO,MAAM,MAAM;AAO5B,QALgB,WAAW,KAAK,GAGd,aAAa,MAAM,SAAS,GAAG,GAAG,CAAC;;;;;ACvKvD,MAAM,aAAa;;;;;;;;;AAenB,MAAMA,QAAmB;CACvB,OAAO;CACP,YAAY,IAAI,WAAW,GAAG;CAC/B;;;;;AAMD,SAAS,eAAe,OAA+B;CACrD,MAAM,SAAS,IAAI,WAAW,MAAM;AACpC,MAAK,IAAI,IAAI,OAAO,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;AAC9C,MAAI,OAAO,KAAK,KAAK;AACnB,UAAO,MAAM;AACb,UAAO;;AAET,SAAO,KAAK;;AAEd,QAAO;;AAGT,SAAS,UAAU,MAAc,QAAoB,KAAkB,SAAS,GAAe;AAC7F,KAAI,CAAC,KAAK;AACR,QAAM,IAAI,WAAW,GAAG;AACxB,WAAS;YACA,SAAS,KAAK,SAAS,KAAK,IAAI,OACzC,OAAM,IAAI,WAAW,mBAAmB,OAAO,GAAG,SAAS,GAAG,0BAA0B;AAI1F,KAAI,UAAW,OAAO,gBAAiB;AACvC,KAAI,SAAS,KAAM,OAAO,aAAe;AACzC,KAAI,SAAS,KAAM,OAAO,WAAa;AACvC,KAAI,SAAS,KAAM,OAAO,QAAW;AACrC,KAAI,SAAS,KAAM,OAAO,MAAS;AACnC,KAAI,SAAS,KAAK,OAAO;AAGzB,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,EAC3B,KAAI,SAAS,IAAI,KAAK,OAAO;AAG/B,QAAO;;AAeT,SAAS,OAA6C,SAAuB,KAAY,SAAS,GAAkB;CAClH,IAAIC;CACJ,IAAIC;;;;;;;;;CAUJ,MAAM,cAAc,KAAK,KAAK;AAE9B,KAAI,SAAS;AAEX,SAAO,QAAQ,SAAS;AACxB,WAAS,QAAQ,UAAU,KAAK;QAC3B;AACL,SAAO;AAEP,MAAI,OAAO,MAAM,OAAO;AAEtB,YAAS,KAAK;AACd,SAAM,QAAQ;AACd,SAAM,WAAW,IAAI,OAAO,SAAS,GAAG,GAAG,CAAC;SACvC;AAEL,YAAS,eAAe,MAAM,WAAW;AACzC,SAAM,aAAa;;;AAIvB,KAAI,KAAK;AACP,YAAU,MAAM,QAAQ,KAAK,OAAO;AACpC,SAAO;;AAIT,QAAO,WAAW,KAAK,GAAG,aAAa,OAAO;;;;;;AAOhD,MAAaC,OAAa,OAAO,OAAO,QAAQ;CAC9C,UAAU,OAAe,cAAc,GAAG;CAC1C,YAAY,UAAsB,YAAY,MAAM;CACpD,YAAY,OAAe,WAAW,GAAG,MAAM,GAAG,GAAG,CAAC;CACtD,UAAU,OAAe,WAAW,KAAK,GAAG;CAC7C,CAAC"}

package/build/{v4.d.mts → uuid/v4.d.mts}

@@ -12,6 +12,7 @@ type UuidV4 = {
   (options?: Version4Options, buf?: undefined, offset?: number): string;
   toBytes(id: string): Uint8Array;
   fromBytes(bytes: Uint8Array): string;
+  isValid(id: string): boolean;
 };
 /**
 * Generate a UUID v4 string or write the bytes into a buffer.

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

@@ -0,0 +1 @@
+{"version":3,"file":"v4.d.mts","names":["uuidv4: UuidV4"],"sources":["../../src/uuid/v4.ts"],"sourcesContent":[],"mappings":";KAGY,eAAA;EAAZ;AAQA;;;EAEkD,MAAA,CAAA,EALvC,UAKuC;CAAkC;AAAwB,KAFhG,MAAA,GAEgG;EAC/F,EAAA,EAAA,MAAA;EACU,CAAA,aAFP,UAEO,GAFM,UAEN,CAAA,CAAA,OAAA,EAF2B,eAE3B,GAAA,SAAA,EAAA,GAAA,EAF6D,IAE7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAFqF,IAErF;EACJ,CAAA,OAAA,CAAA,EAFN,eAEM,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,OAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EADI,UACJ;EAkEnB,SAAaA,CAAAA,KAAQ,EAlEF,UAkEE,CAAA,EAAA,MAAA;;;;;;;cAARA,QAAQ"}

package/build/{v4.mjs → uuid/v4.mjs}

@@ -1,6 +1,8 @@
-import { n as parseUuid, r as rng, t as formatUuid } from "./uuid-DaimLSJD.mjs";
+import { t as rng } from "../random-Dul5R6oJ.mjs";
+import { n as parseUuid, t as formatUuid } from "../uuid-cJ5hOOIR.mjs";
 
 //#region src/uuid/v4.ts
+const 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;
 function v4Bytes(rnds, buf, offset = 0) {
 	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
 	rnds[6] = rnds[6] & 15 | 64;
@@ -15,13 +17,17 @@ function v4(options, buf, offset) {
 	const bytes = v4Bytes(options?.random ?? rng(), buf, offset);
 	return buf ?? formatUuid(bytes);
 }
+function isValid(id) {
+	return UUID_V4_REGEX.test(id);
+}
 /**
 * Generate a UUID v4 string or write the bytes into a buffer.
 * It also includes helpers to convert to and from byte arrays.
 */
 const uuidv4 = Object.assign(v4, {
-	toBytes: (id) => parseUuid(id),
-	fromBytes: (bytes) => formatUuid(bytes)
+	toBytes: parseUuid,
+	fromBytes: formatUuid,
+	isValid
 });
 
 //#endregion

package/build/uuid/v4.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"v4.mjs","names":["uuidv4: UuidV4"],"sources":["../../src/uuid/v4.ts"],"sourcesContent":["import { rng } from './common/random'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type Version4Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Bytes at index 6 and 8 will be modified in-place to set version/variant bits.\n   */\n  random?: Uint8Array\n}\n\nexport type UuidV4 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: Version4Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: Version4Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  isValid(id: string): boolean\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 v4Bytes(rnds: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (rnds.length < 16) {\n    throw new Error('Random bytes length must be >= 16')\n  }\n\n  // Set RFC 4122 version (4) and variant (10xx) bits.\n  // Note: This modifies the input array in-place.\n  rnds[6] = (rnds[6] & 0x0f) | 0x40\n  rnds[8] = (rnds[8] & 0x3f) | 0x80\n\n  if (!buf) {\n    // No output buffer provided - return the modified random bytes directly\n    return rnds\n  }\n\n  if (offset < 0 || offset + 16 > buf.length) {\n    throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`)\n  }\n\n  // Copy 16 UUID bytes into the provided buffer slice.\n  for (let i = 0; i < 16; i += 1) {\n    buf[offset + i] = rnds[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v4(options?: Version4Options, 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>(\n  options: Version4Options | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction v4<TBuf extends Uint8Array = Uint8Array>(\n  options?: Version4Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  if (globalThis.crypto?.randomUUID && !buf && !options) {\n    return globalThis.crypto.randomUUID()\n  }\n\n  const bytes = v4Bytes(options?.random ?? rng(), buf, offset)\n  return buf ?? formatUuid(bytes)\n}\n\nfunction isValid(id: string): boolean {\n  return UUID_V4_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v4 string or write the bytes into a buffer.\n * It also includes helpers to convert to and from byte arrays.\n */\nexport const uuidv4: UuidV4 = Object.assign(v4, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\n  isValid,\n})\n"],"mappings":";;;;AAoBA,MAAM,gBAAgB;AAEtB,SAAS,QAAQ,MAAkB,KAAkB,SAAS,GAAe;AAC3E,KAAI,KAAK,SAAS,GAChB,OAAM,IAAI,MAAM,oCAAoC;AAKtD,MAAK,KAAM,KAAK,KAAK,KAAQ;AAC7B,MAAK,KAAM,KAAK,KAAK,KAAQ;AAE7B,KAAI,CAAC,IAEH,QAAO;AAGT,KAAI,SAAS,KAAK,SAAS,KAAK,IAAI,OAClC,OAAM,IAAI,WAAW,mBAAmB,OAAO,GAAG,SAAS,GAAG,0BAA0B;AAI1F,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,EAC3B,KAAI,SAAS,KAAK,KAAK;AAGzB,QAAO;;AAeT,SAAS,GACP,SACA,KACA,QACe;AACf,KAAI,WAAW,QAAQ,cAAc,CAAC,OAAO,CAAC,QAC5C,QAAO,WAAW,OAAO,YAAY;CAGvC,MAAM,QAAQ,QAAQ,SAAS,UAAU,KAAK,EAAE,KAAK,OAAO;AAC5D,QAAO,OAAO,WAAW,MAAM;;AAGjC,SAAS,QAAQ,IAAqB;AACpC,QAAO,cAAc,KAAK,GAAG;;;;;;AAO/B,MAAaA,SAAiB,OAAO,OAAO,IAAI;CAC9C,SAAS;CACT,WAAW;CACX;CACD,CAAC"}

package/build/{v7.d.mts → uuid/v7.d.mts}

@@ -14,10 +14,12 @@ type UuidV7 = {
   (options?: Version7Options, buf?: undefined, offset?: number): string;
   toBytes(id: string): Uint8Array;
   fromBytes(bytes: Uint8Array): string;
+  timestamp(id: string): number;
+  isValid(id: string): boolean;
 };
 /**
 * Generate a UUID v7 string or write the bytes into a buffer.
-* It also includes helpers to convert to and from byte arrays.
+* It also includes helpers to convert to and from byte arrays.j
 */
 declare const uuidv7: UuidV7;
 //#endregion

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

@@ -0,0 +1 @@
+{"version":3,"file":"v7.d.mts","names":["uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":[],"mappings":";KAGY,eAAA;EAAZ;AAUA;;;EAEkD,MAAA,CAAA,EAPvC,UAOuC;EAAkC,KAAA,CAAA,EAAA,MAAA;EAAwB,GAAA,CAAA,EAAA,MAAA;CAC/F;AACU,KAJX,MAAA,GAIW;EACJ,EAAA,EAAA,MAAA;EAAA,CAAA,aAHH,UAGG,GAHU,UAGV,CAAA,CAAA,OAAA,EAH+B,eAG/B,GAAA,SAAA,EAAA,GAAA,EAHiE,IAGjE,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAHyF,IAGzF;EA4InB,CAAA,OAAqB,CAARA,EA9IA,eA8IQ,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;uBA7IE;mBACJ;;;;;;;;cA4INA,QAAQ"}

package/build/{v7.mjs → uuid/v7.mjs}

@@ -1,6 +1,8 @@
-import { n as parseUuid, r as rng, t as formatUuid } from "./uuid-DaimLSJD.mjs";
+import { t as rng } from "../random-Dul5R6oJ.mjs";
+import { n as parseUuid, t as formatUuid } from "../uuid-cJ5hOOIR.mjs";
 
 //#region src/uuid/v7.ts
+const UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 /**
 * Module-level state for maintaining monotonic ordering within the same millisecond.
 *
@@ -67,13 +69,24 @@ function v7(options, buf, offset) {
 	}
 	return buf ?? formatUuid(bytes);
 }
+function timestamp(id) {
+	const bytes = parseUuid(id);
+	let msecs = 0;
+	for (let i = 0; i < 6; i += 1) msecs = msecs * 256 + bytes[i];
+	return msecs;
+}
+function isValid(id) {
+	return UUID_V7_REGEX.test(id);
+}
 /**
 * Generate a UUID v7 string or write the bytes into a buffer.
-* It also includes helpers to convert to and from byte arrays.
+* It also includes helpers to convert to and from byte arrays.j
 */
 const uuidv7 = Object.assign(v7, {
-	toBytes: (id) => parseUuid(id),
-	fromBytes: (bytes) => formatUuid(bytes)
+	toBytes: parseUuid,
+	fromBytes: formatUuid,
+	timestamp,
+	isValid
 });
 
 //#endregion

package/build/uuid/v7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"v7.mjs","names":["state: V7State","bytes: Uint8Array","uuidv7: UuidV7"],"sources":["../../src/uuid/v7.ts"],"sourcesContent":["import { rng } from './common/random'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type Version7Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Several bytes will be overwritten with timestamp, version, and variant data.\n   */\n  random?: Uint8Array\n  msecs?: number\n  seq?: number\n}\n\nexport type UuidV7 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: Version7Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: Version7Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n  timestamp(id: string): number\n  isValid(id: string): boolean\n}\n\nconst UUID_V7_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i\n\ntype V7State = {\n  msecs?: number\n  seq?: number\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all uuidv7() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `seq` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: V7State = {}\n\nfunction updateV7State(current: V7State, now: number, rnds: Uint8Array): V7State {\n  // Initialize state on first call (-Infinity ensures any real timestamp is greater)\n  current.msecs ??= -Infinity\n  current.seq ??= 0\n\n  if (now > current.msecs) {\n    // New millisecond tick: reseed sequence from random bytes.\n    current.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n    current.msecs = now\n  } else {\n    // Same millisecond: increment sequence, roll over into the next tick if needed.\n    current.seq = (current.seq + 1) | 0\n    if (current.seq === 0) {\n      current.msecs += 1\n    }\n  }\n\n  return current\n}\n\nfunction v7Bytes(rnds: Uint8Array, msecs?: number, seq?: number, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (rnds.length < 16) {\n    throw new Error('Random bytes length must be >= 16')\n  }\n\n  if (!buf) {\n    buf = new Uint8Array(16)\n    offset = 0\n  } else if (offset < 0 || offset + 16 > buf.length) {\n    throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`)\n  }\n\n  msecs ??= Date.now()\n  // Derive a 30-bit sequence if not provided by the caller.\n  seq ??= ((rnds[6] * 0x7f) << 24) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch).\n  buf[offset++] = (msecs / 0x10000000000) & 0xff\n  buf[offset++] = (msecs / 0x100000000) & 0xff\n  buf[offset++] = (msecs / 0x1000000) & 0xff\n  buf[offset++] = (msecs / 0x10000) & 0xff\n  buf[offset++] = (msecs / 0x100) & 0xff\n  buf[offset++] = msecs & 0xff\n\n  // Set version (7) and variant (10xx), then pack sequence and random tail bytes.\n  buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f)\n  buf[offset++] = (seq >>> 20) & 0xff\n  buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f)\n  buf[offset++] = (seq >>> 6) & 0xff\n  // Lower seq bits plus 2 random bits to complete the 128-bit payload.\n  buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03)\n  buf[offset++] = rnds[11]\n  buf[offset++] = rnds[12]\n  buf[offset++] = rnds[13]\n  buf[offset++] = rnds[14]\n  buf[offset++] = rnds[15]\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v7(options?: Version7Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v7<TBuf extends Uint8Array = Uint8Array>(\n  options: Version7Options | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction v7<TBuf extends Uint8Array = Uint8Array>(\n  options?: Version7Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  let bytes: Uint8Array\n\n  if (options) {\n    bytes = v7Bytes(options.random ?? rng(), options.msecs, options.seq, buf, offset)\n  } else {\n    /**\n     * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n     * side-channel attacks. This means that Date.now() will return the same value for the entire\n     * duration of a request.\n     * Implications:\n     * - all UUIDv7 generated within a single request will have the same timestamp.\n     * - the monotonic ordering will rely entirely on the `state.seq` counter\n     */\n    const now = Date.now()\n    const rnds = rng()\n\n    updateV7State(state, now, rnds)\n\n    bytes = v7Bytes(rnds, state.msecs, state.seq, buf, offset)\n  }\n\n  return buf ?? formatUuid(bytes)\n}\n\nfunction timestamp(id: string): number {\n  const bytes = parseUuid(id)\n  let msecs = 0\n  for (let i = 0; i < 6; i += 1) {\n    msecs = msecs * 256 + bytes[i]\n  }\n  return msecs\n}\n\nfunction isValid(id: string): boolean {\n  return UUID_V7_REGEX.test(id)\n}\n\n/**\n * Generate a UUID v7 string or write the bytes into a buffer.\n * It also includes helpers to convert to and from byte arrays.j\n */\nexport const uuidv7: UuidV7 = Object.assign(v7, {\n  toBytes: parseUuid,\n  fromBytes: formatUuid,\n  timestamp,\n  isValid,\n})\n"],"mappings":";;;;AAuBA,MAAM,gBAAgB;;;;;;;;;AAetB,MAAMA,QAAiB,EAAE;AAEzB,SAAS,cAAc,SAAkB,KAAa,MAA2B;AAE/E,SAAQ,UAAU;AAClB,SAAQ,QAAQ;AAEhB,KAAI,MAAM,QAAQ,OAAO;AAEvB,UAAQ,MAAO,KAAK,MAAM,KAAO,KAAK,MAAM,KAAO,KAAK,MAAM,IAAK,KAAK;AACxE,UAAQ,QAAQ;QACX;AAEL,UAAQ,MAAO,QAAQ,MAAM,IAAK;AAClC,MAAI,QAAQ,QAAQ,EAClB,SAAQ,SAAS;;AAIrB,QAAO;;AAGT,SAAS,QAAQ,MAAkB,OAAgB,KAAc,KAAkB,SAAS,GAAe;AACzG,KAAI,KAAK,SAAS,GAChB,OAAM,IAAI,MAAM,oCAAoC;AAGtD,KAAI,CAAC,KAAK;AACR,QAAM,IAAI,WAAW,GAAG;AACxB,WAAS;YACA,SAAS,KAAK,SAAS,KAAK,IAAI,OACzC,OAAM,IAAI,WAAW,mBAAmB,OAAO,GAAG,SAAS,GAAG,0BAA0B;AAG1F,WAAU,KAAK,KAAK;AAEpB,SAAU,KAAK,KAAK,OAAS,KAAO,KAAK,MAAM,KAAO,KAAK,MAAM,IAAK,KAAK;AAG3E,KAAI,YAAa,QAAQ,gBAAiB;AAC1C,KAAI,YAAa,QAAQ,aAAe;AACxC,KAAI,YAAa,QAAQ,WAAa;AACtC,KAAI,YAAa,QAAQ,QAAW;AACpC,KAAI,YAAa,QAAQ,MAAS;AAClC,KAAI,YAAY,QAAQ;AAGxB,KAAI,YAAY,MAAS,QAAQ,KAAM;AACvC,KAAI,YAAa,QAAQ,KAAM;AAC/B,KAAI,YAAY,MAAS,QAAQ,KAAM;AACvC,KAAI,YAAa,QAAQ,IAAK;AAE9B,KAAI,YAAc,OAAO,IAAK,MAAS,KAAK,MAAM;AAClD,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AAErB,QAAO;;AAeT,SAAS,GACP,SACA,KACA,QACe;CACf,IAAIC;AAEJ,KAAI,QACF,SAAQ,QAAQ,QAAQ,UAAU,KAAK,EAAE,QAAQ,OAAO,QAAQ,KAAK,KAAK,OAAO;MAC5E;;;;;;;;;EASL,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,OAAO,KAAK;AAElB,gBAAc,OAAO,KAAK,KAAK;AAE/B,UAAQ,QAAQ,MAAM,MAAM,OAAO,MAAM,KAAK,KAAK,OAAO;;AAG5D,QAAO,OAAO,WAAW,MAAM;;AAGjC,SAAS,UAAU,IAAoB;CACrC,MAAM,QAAQ,UAAU,GAAG;CAC3B,IAAI,QAAQ;AACZ,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,EAC1B,SAAQ,QAAQ,MAAM,MAAM;AAE9B,QAAO;;AAGT,SAAS,QAAQ,IAAqB;AACpC,QAAO,cAAc,KAAK,GAAG;;;;;;AAO/B,MAAaC,SAAiB,OAAO,OAAO,IAAI;CAC9C,SAAS;CACT,WAAW;CACX;CACA;CACD,CAAC"}

package/build/{uuid-DaimLSJD.mjs → uuid-cJ5hOOIR.mjs}

@@ -1,18 +1,3 @@
-//#region src/uuid/common/random.ts
-function randomBytes(out) {
-	globalThis.crypto.getRandomValues(out);
-}
-/**
-* Generate 16 bytes of cryptographically strong random data.
-* Used internally by UUID generators.
-*/
-function rng() {
-	const bytes = new Uint8Array(16);
-	randomBytes(bytes);
-	return bytes;
-}
-
-//#endregion
 //#region src/uuid/common/hex.ts
 const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bytesToHex(bytes) {
@@ -60,5 +45,5 @@ function parseUuid(value) {
 }
 
 //#endregion
-export { parseUuid as n, rng as r, formatUuid as t };
-//# sourceMappingURL=uuid-DaimLSJD.mjs.map
+export { parseUuid as n, formatUuid as t };
+//# sourceMappingURL=uuid-cJ5hOOIR.mjs.map

package/build/uuid-cJ5hOOIR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid-cJ5hOOIR.mjs","names":[],"sources":["../src/uuid/common/hex.ts","../src/uuid/common/uuid.ts"],"sourcesContent":["// Pre-computed lookup table for byte-to-hex conversion (0x00 -> \"00\", 0xff -> \"ff\")\nconst HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))\n\nexport function bytesToHex(bytes: Uint8Array): string {\n  // Build string directly, without intermediate array allocation\n  let hex = ''\n  for (let i = 0; i < bytes.length; i += 1) {\n    hex += HEX_TABLE[bytes[i]]\n  }\n  return hex\n}\n\n// ASCII code ranges for hex character validation\nconst ASCII_0 = 48 // '0'\nconst ASCII_9 = 57 // '9'\nconst ASCII_A = 65 // 'A'\nconst ASCII_F = 70 // 'F'\nconst ASCII_a = 97 // 'a'\nconst ASCII_f = 102 // 'f'\n\nfunction hexValue(code: number): number {\n  if (code >= ASCII_0 && code <= ASCII_9) {\n    return code - ASCII_0\n  }\n  if (code >= ASCII_A && code <= ASCII_F) {\n    return code - ASCII_A + 10\n  }\n  if (code >= ASCII_a && code <= ASCII_f) {\n    return code - ASCII_a + 10\n  }\n  return -1 // Invalid hex character\n}\n\nexport function hexToBytes(hex: string, out: Uint8Array): void {\n  if (hex.length !== out.length * 2) {\n    throw new Error(`hex string must be ${out.length * 2} chars, got ${hex.length}`)\n  }\n\n  for (let i = 0; i < out.length; i += 1) {\n    const hi = hexValue(hex.charCodeAt(i * 2))\n    const lo = hexValue(hex.charCodeAt(i * 2 + 1))\n    if (hi === -1 || lo === -1) {\n      throw new Error('hex string contains invalid characters')\n    }\n    out[i] = (hi << 4) | lo\n  }\n}\n","import { bytesToHex, hexToBytes } from './hex'\n\nconst UUID_BYTE_LENGTH = 16\nconst UUID_STRING_LENGTH = 36\n\nexport function formatUuid(bytes: Uint8Array): string {\n  // precondition: bytes.length === UUID_BYTE_LENGTH\n  const hex = bytesToHex(bytes)\n\n  // Build UUID string with dashes at positions 8, 13, 18, 23\n  // Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`\n}\n\nexport function parseUuid(value: string): Uint8Array {\n  if (value.length !== UUID_STRING_LENGTH) {\n    throw new Error('uuid string must be 36 characters')\n  }\n\n  // Validate separator positions directly (more efficient than full loop)\n  if (value[8] !== '-' || value[13] !== '-' || value[18] !== '-' || value[23] !== '-') {\n    throw new Error('uuid string has invalid separators')\n  }\n\n  const hex = value.slice(0, 8) + value.slice(9, 13) + value.slice(14, 18) + value.slice(19, 23) + value.slice(24)\n\n  const bytes = new Uint8Array(UUID_BYTE_LENGTH)\n  hexToBytes(hex, bytes)\n  return bytes\n}\n"],"mappings":";AACA,MAAM,YAAY,MAAM,KAAK,EAAE,QAAQ,KAAK,GAAG,GAAG,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;AAExF,SAAgB,WAAW,OAA2B;CAEpD,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,QAAO,UAAU,MAAM;AAEzB,QAAO;;AAIT,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAEhB,SAAS,SAAS,MAAsB;AACtC,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO;AAEhB,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO,UAAU;AAE1B,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO,UAAU;AAE1B,QAAO;;AAGT,SAAgB,WAAW,KAAa,KAAuB;AAC7D,KAAI,IAAI,WAAW,IAAI,SAAS,EAC9B,OAAM,IAAI,MAAM,sBAAsB,IAAI,SAAS,EAAE,cAAc,IAAI,SAAS;AAGlF,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,GAAG;EACtC,MAAM,KAAK,SAAS,IAAI,WAAW,IAAI,EAAE,CAAC;EAC1C,MAAM,KAAK,SAAS,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;AAC9C,MAAI,OAAO,MAAM,OAAO,GACtB,OAAM,IAAI,MAAM,yCAAyC;AAE3D,MAAI,KAAM,MAAM,IAAK;;;;;;AC1CzB,MAAM,mBAAmB;AACzB,MAAM,qBAAqB;AAE3B,SAAgB,WAAW,OAA2B;CAEpD,MAAM,MAAM,WAAW,MAAM;AAI7B,QAAO,GAAG,IAAI,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,MAAM,GAAG;;AAG1G,SAAgB,UAAU,OAA2B;AACnD,KAAI,MAAM,WAAW,mBACnB,OAAM,IAAI,MAAM,oCAAoC;AAItD,KAAI,MAAM,OAAO,OAAO,MAAM,QAAQ,OAAO,MAAM,QAAQ,OAAO,MAAM,QAAQ,IAC9E,OAAM,IAAI,MAAM,qCAAqC;CAGvD,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,MAAM,GAAG,GAAG,GAAG,MAAM,MAAM,IAAI,GAAG,GAAG,MAAM,MAAM,IAAI,GAAG,GAAG,MAAM,MAAM,GAAG;CAEhH,MAAM,QAAQ,IAAI,WAAW,iBAAiB;AAC9C,YAAW,KAAK,MAAM;AACtB,QAAO"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "uniku",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "Minimal, tree-shakeable UUID utilities for every JavaScript runtime",
   "author": {
     "name": "Alberto Schiabel",
@@ -22,6 +22,9 @@
     "uuid",
     "uuidv4",
     "uuidv7",
+    "ulid",
+    "cuid2",
+    "nanoid",
     "unique",
     "id",
     "identifier",
@@ -51,29 +54,57 @@
   ],
   "exports": {
     "./uuid/v4": {
-      "types": "./build/v4.d.mts",
+      "types": "./build/uuid/v4.d.mts",
       "import": {
         "@jkomyno/source": "./src/uuid/v4.ts",
-        "default": "./build/v4.mjs"
+        "default": "./build/uuid/v4.mjs"
       },
-      "default": "./build/v4.mjs"
+      "default": "./build/uuid/v4.mjs"
     },
     "./uuid/v7": {
-      "types": "./build/v7.d.mts",
+      "types": "./build/uuid/v7.d.mts",
       "import": {
         "@jkomyno/source": "./src/uuid/v7.ts",
-        "default": "./build/v7.mjs"
+        "default": "./build/uuid/v7.mjs"
       },
-      "default": "./build/v7.mjs"
+      "default": "./build/uuid/v7.mjs"
+    },
+    "./ulid": {
+      "types": "./build/ulid/ulid.d.mts",
+      "import": {
+        "@jkomyno/source": "./src/ulid/ulid.ts",
+        "default": "./build/ulid/ulid.mjs"
+      },
+      "default": "./build/ulid/ulid.mjs"
+    },
+    "./cuid2": {
+      "types": "./build/cuid2/cuid2.d.mts",
+      "import": {
+        "@jkomyno/source": "./src/cuid2/cuid2.ts",
+        "default": "./build/cuid2/cuid2.mjs"
+      },
+      "default": "./build/cuid2/cuid2.mjs"
+    },
+    "./nanoid": {
+      "types": "./build/nanoid/nanoid.d.mts",
+      "import": {
+        "@jkomyno/source": "./src/nanoid/nanoid.ts",
+        "default": "./build/nanoid/nanoid.mjs"
+      },
+      "default": "./build/nanoid/nanoid.mjs"
     },
     "./package.json": "./package.json"
   },
+  "dependencies": {
+    "@noble/hashes": "^2.0.1"
+  },
   "scripts": {
     "clean": "rimraf build .turbo",
     "build": "tsdown --config-loader unrun",
     "build:watch": "tsdown --config-loader unrun --watch",
     "test": "vitest run",
     "test:unit": "vitest --project unit run",
-    "bench": "vitest bench"
+    "bench": "vitest bench",
+    "typecheck": "tsc --noEmit"
   }
 }

package/build/uuid-DaimLSJD.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuid-DaimLSJD.mjs","names":[],"sources":["../src/uuid/common/random.ts","../src/uuid/common/hex.ts","../src/uuid/common/uuid.ts"],"sourcesContent":["export function randomBytes(out: Uint8Array): void {\n  const crypto = globalThis.crypto\n  crypto.getRandomValues(out)\n}\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Used internally by UUID generators.\n */\nexport function rng(): Uint8Array {\n  const bytes = new Uint8Array(16)\n  randomBytes(bytes)\n  return bytes\n}\n","// Pre-computed lookup table for byte-to-hex conversion (0x00 -> \"00\", 0xff -> \"ff\")\nconst HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'))\n\nexport function bytesToHex(bytes: Uint8Array): string {\n  // Build string directly, without intermediate array allocation\n  let hex = ''\n  for (let i = 0; i < bytes.length; i += 1) {\n    hex += HEX_TABLE[bytes[i]]\n  }\n  return hex\n}\n\n// ASCII code ranges for hex character validation\nconst ASCII_0 = 48 // '0'\nconst ASCII_9 = 57 // '9'\nconst ASCII_A = 65 // 'A'\nconst ASCII_F = 70 // 'F'\nconst ASCII_a = 97 // 'a'\nconst ASCII_f = 102 // 'f'\n\nfunction hexValue(code: number): number {\n  if (code >= ASCII_0 && code <= ASCII_9) {\n    return code - ASCII_0\n  }\n  if (code >= ASCII_A && code <= ASCII_F) {\n    return code - ASCII_A + 10\n  }\n  if (code >= ASCII_a && code <= ASCII_f) {\n    return code - ASCII_a + 10\n  }\n  return -1 // Invalid hex character\n}\n\nexport function hexToBytes(hex: string, out: Uint8Array): void {\n  if (hex.length !== out.length * 2) {\n    throw new Error(`hex string must be ${out.length * 2} chars, got ${hex.length}`)\n  }\n\n  for (let i = 0; i < out.length; i += 1) {\n    const hi = hexValue(hex.charCodeAt(i * 2))\n    const lo = hexValue(hex.charCodeAt(i * 2 + 1))\n    if (hi === -1 || lo === -1) {\n      throw new Error('hex string contains invalid characters')\n    }\n    out[i] = (hi << 4) | lo\n  }\n}\n","import { bytesToHex, hexToBytes } from './hex'\n\nconst UUID_BYTE_LENGTH = 16\nconst UUID_STRING_LENGTH = 36\n\nexport function formatUuid(bytes: Uint8Array): string {\n  // precondition: bytes.length === UUID_BYTE_LENGTH\n  const hex = bytesToHex(bytes)\n\n  // Build UUID string with dashes at positions 8, 13, 18, 23\n  // Format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`\n}\n\nexport function parseUuid(value: string): Uint8Array {\n  if (value.length !== UUID_STRING_LENGTH) {\n    throw new Error('uuid string must be 36 characters')\n  }\n\n  // Validate separator positions directly (more efficient than full loop)\n  if (value[8] !== '-' || value[13] !== '-' || value[18] !== '-' || value[23] !== '-') {\n    throw new Error('uuid string has invalid separators')\n  }\n\n  const hex = value.slice(0, 8) + value.slice(9, 13) + value.slice(14, 18) + value.slice(19, 23) + value.slice(24)\n\n  const bytes = new Uint8Array(UUID_BYTE_LENGTH)\n  hexToBytes(hex, bytes)\n  return bytes\n}\n"],"mappings":";AAAA,SAAgB,YAAY,KAAuB;AAEjD,CADe,WAAW,OACnB,gBAAgB,IAAI;;;;;;AAO7B,SAAgB,MAAkB;CAChC,MAAM,QAAQ,IAAI,WAAW,GAAG;AAChC,aAAY,MAAM;AAClB,QAAO;;;;;ACXT,MAAM,YAAY,MAAM,KAAK,EAAE,QAAQ,KAAK,GAAG,GAAG,MAAM,EAAE,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC;AAExF,SAAgB,WAAW,OAA2B;CAEpD,IAAI,MAAM;AACV,MAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EACrC,QAAO,UAAU,MAAM;AAEzB,QAAO;;AAIT,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAChB,MAAM,UAAU;AAEhB,SAAS,SAAS,MAAsB;AACtC,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO;AAEhB,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO,UAAU;AAE1B,KAAI,QAAQ,WAAW,QAAQ,QAC7B,QAAO,OAAO,UAAU;AAE1B,QAAO;;AAGT,SAAgB,WAAW,KAAa,KAAuB;AAC7D,KAAI,IAAI,WAAW,IAAI,SAAS,EAC9B,OAAM,IAAI,MAAM,sBAAsB,IAAI,SAAS,EAAE,cAAc,IAAI,SAAS;AAGlF,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,GAAG;EACtC,MAAM,KAAK,SAAS,IAAI,WAAW,IAAI,EAAE,CAAC;EAC1C,MAAM,KAAK,SAAS,IAAI,WAAW,IAAI,IAAI,EAAE,CAAC;AAC9C,MAAI,OAAO,MAAM,OAAO,GACtB,OAAM,IAAI,MAAM,yCAAyC;AAE3D,MAAI,KAAM,MAAM,IAAK;;;;;;AC1CzB,MAAM,mBAAmB;AACzB,MAAM,qBAAqB;AAE3B,SAAgB,WAAW,OAA2B;CAEpD,MAAM,MAAM,WAAW,MAAM;AAI7B,QAAO,GAAG,IAAI,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC,GAAG,IAAI,MAAM,GAAG;;AAG1G,SAAgB,UAAU,OAA2B;AACnD,KAAI,MAAM,WAAW,mBACnB,OAAM,IAAI,MAAM,oCAAoC;AAItD,KAAI,MAAM,OAAO,OAAO,MAAM,QAAQ,OAAO,MAAM,QAAQ,OAAO,MAAM,QAAQ,IAC9E,OAAM,IAAI,MAAM,qCAAqC;CAGvD,MAAM,MAAM,MAAM,MAAM,GAAG,EAAE,GAAG,MAAM,MAAM,GAAG,GAAG,GAAG,MAAM,MAAM,IAAI,GAAG,GAAG,MAAM,MAAM,IAAI,GAAG,GAAG,MAAM,MAAM,GAAG;CAEhH,MAAM,QAAQ,IAAI,WAAW,iBAAiB;AAC9C,YAAW,KAAK,MAAM;AACtB,QAAO"}

package/build/v4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"v4.d.mts","names":["uuidv4: UuidV4"],"sources":["../src/uuid/v4.ts"],"sourcesContent":[],"mappings":";KAGY,eAAA;EAAZ;AAQA;;;EAEkD,MAAA,CAAA,EALvC,UAKuC;CAAkC;AAAwB,KAFhG,MAAA,GAEgG;EAC/F,EAAA,EAAA,MAAA;EACU,CAAA,aAFP,UAEO,GAFM,UAEN,CAAA,CAAA,OAAA,EAF2B,eAE3B,GAAA,SAAA,EAAA,GAAA,EAF6D,IAE7D,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAFqF,IAErF;EACJ,CAAA,OAAA,CAAA,EAFN,eAEM,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAAA,OAAA,CAAA,EAAA,EAAA,MAAA,CAAA,EADI,UACJ;EA2DnB,SAAaA,CAAAA,KAAQ,EA3DF,UA2DE,CAAA,EAAA,MAAA;;;;;;cAARA,QAAQ"}

package/build/v4.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"v4.mjs","names":["uuidv4: UuidV4"],"sources":["../src/uuid/v4.ts"],"sourcesContent":["import { rng } from './common/random'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type Version4Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Bytes at index 6 and 8 will be modified in-place to set version/variant bits.\n   */\n  random?: Uint8Array\n}\n\nexport type UuidV4 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: Version4Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: Version4Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n}\n\nfunction v4Bytes(rnds: Uint8Array, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (rnds.length < 16) {\n    throw new Error('Random bytes length must be >= 16')\n  }\n\n  // Set RFC 4122 version (4) and variant (10xx) bits.\n  // Note: This modifies the input array in-place.\n  rnds[6] = (rnds[6] & 0x0f) | 0x40\n  rnds[8] = (rnds[8] & 0x3f) | 0x80\n\n  if (!buf) {\n    // No output buffer provided - return the modified random bytes directly\n    return rnds\n  }\n\n  if (offset < 0 || offset + 16 > buf.length) {\n    throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`)\n  }\n\n  // Copy 16 UUID bytes into the provided buffer slice.\n  for (let i = 0; i < 16; i += 1) {\n    buf[offset + i] = rnds[i]\n  }\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v4(options?: Version4Options, 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>(\n  options: Version4Options | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction v4<TBuf extends Uint8Array = Uint8Array>(\n  options?: Version4Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  if (globalThis.crypto?.randomUUID && !buf && !options) {\n    return globalThis.crypto.randomUUID()\n  }\n\n  const bytes = v4Bytes(options?.random ?? rng(), buf, offset)\n  return buf ?? formatUuid(bytes)\n}\n\n/**\n * Generate a UUID v4 string or write the bytes into a buffer.\n * It also includes helpers to convert to and from byte arrays.\n */\nexport const uuidv4: UuidV4 = Object.assign(v4, {\n  toBytes: (id: string) => parseUuid(id),\n  fromBytes: (bytes: Uint8Array) => formatUuid(bytes),\n})\n"],"mappings":";;;AAmBA,SAAS,QAAQ,MAAkB,KAAkB,SAAS,GAAe;AAC3E,KAAI,KAAK,SAAS,GAChB,OAAM,IAAI,MAAM,oCAAoC;AAKtD,MAAK,KAAM,KAAK,KAAK,KAAQ;AAC7B,MAAK,KAAM,KAAK,KAAK,KAAQ;AAE7B,KAAI,CAAC,IAEH,QAAO;AAGT,KAAI,SAAS,KAAK,SAAS,KAAK,IAAI,OAClC,OAAM,IAAI,WAAW,mBAAmB,OAAO,GAAG,SAAS,GAAG,0BAA0B;AAI1F,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK,EAC3B,KAAI,SAAS,KAAK,KAAK;AAGzB,QAAO;;AAeT,SAAS,GACP,SACA,KACA,QACe;AACf,KAAI,WAAW,QAAQ,cAAc,CAAC,OAAO,CAAC,QAC5C,QAAO,WAAW,OAAO,YAAY;CAGvC,MAAM,QAAQ,QAAQ,SAAS,UAAU,KAAK,EAAE,KAAK,OAAO;AAC5D,QAAO,OAAO,WAAW,MAAM;;;;;;AAOjC,MAAaA,SAAiB,OAAO,OAAO,IAAI;CAC9C,UAAU,OAAe,UAAU,GAAG;CACtC,YAAY,UAAsB,WAAW,MAAM;CACpD,CAAC"}

package/build/v7.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"v7.d.mts","names":["uuidv7: UuidV7"],"sources":["../src/uuid/v7.ts"],"sourcesContent":[],"mappings":";KAGY,eAAA;EAAZ;AAUA;;;EAEkD,MAAA,CAAA,EAPvC,UAOuC;EAAkC,KAAA,CAAA,EAAA,MAAA;EAAwB,GAAA,CAAA,EAAA,MAAA;CAC/F;AACU,KAJX,MAAA,GAIW;EACJ,EAAA,EAAA,MAAA;EAAA,CAAA,aAHH,UAGG,GAHU,UAGV,CAAA,CAAA,OAAA,EAH+B,eAG/B,GAAA,SAAA,EAAA,GAAA,EAHiE,IAGjE,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAHyF,IAGzF;EA2HnB,CAAA,OAAqB,CAARA,EA7HA,eA6HQ,EAAA,GAAA,CAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EAAA,MAAA,CAAA,EAAA,MAAA;uBA5HE;mBACJ;;;;;;cA2HNA,QAAQ"}

package/build/v7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"v7.mjs","names":["state: V7State","bytes: Uint8Array","uuidv7: UuidV7"],"sources":["../src/uuid/v7.ts"],"sourcesContent":["import { rng } from './common/random'\nimport { formatUuid, parseUuid } from './common/uuid'\n\nexport type Version7Options = {\n  /**\n   * 16 bytes of random data to use for UUID generation.\n   * Note: Several bytes will be overwritten with timestamp, version, and variant data.\n   */\n  random?: Uint8Array\n  msecs?: number\n  seq?: number\n}\n\nexport type UuidV7 = {\n  (): string\n  <TBuf extends Uint8Array = Uint8Array>(options: Version7Options | undefined, buf: TBuf, offset?: number): TBuf\n  (options?: Version7Options, buf?: undefined, offset?: number): string\n  toBytes(id: string): Uint8Array\n  fromBytes(bytes: Uint8Array): string\n}\n\ntype V7State = {\n  msecs?: number\n  seq?: number\n}\n\n/**\n * Module-level state for maintaining monotonic ordering within the same millisecond.\n *\n * IMPORTANT: This state persists across all uuidv7() calls in the module's lifetime.\n * - In serverless/edge functions with warm starts, state persists between invocations.\n * - For isolated state, pass explicit `msecs` and `seq` via options.\n * - Tests should mock Date.now() or provide explicit options for deterministic behavior.\n */\nconst state: V7State = {}\n\nfunction updateV7State(current: V7State, now: number, rnds: Uint8Array): V7State {\n  // Initialize state on first call (-Infinity ensures any real timestamp is greater)\n  current.msecs ??= -Infinity\n  current.seq ??= 0\n\n  if (now > current.msecs) {\n    // New millisecond tick: reseed sequence from random bytes.\n    current.seq = (rnds[6] << 23) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n    current.msecs = now\n  } else {\n    // Same millisecond: increment sequence, roll over into the next tick if needed.\n    current.seq = (current.seq + 1) | 0\n    if (current.seq === 0) {\n      current.msecs += 1\n    }\n  }\n\n  return current\n}\n\nfunction v7Bytes(rnds: Uint8Array, msecs?: number, seq?: number, buf?: Uint8Array, offset = 0): Uint8Array {\n  if (rnds.length < 16) {\n    throw new Error('Random bytes length must be >= 16')\n  }\n\n  if (!buf) {\n    buf = new Uint8Array(16)\n    offset = 0\n  } else if (offset < 0 || offset + 16 > buf.length) {\n    throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`)\n  }\n\n  msecs ??= Date.now()\n  // Derive a 30-bit sequence if not provided by the caller.\n  seq ??= ((rnds[6] * 0x7f) << 24) | (rnds[7] << 16) | (rnds[8] << 8) | rnds[9]\n\n  // Timestamp (48-bit big-endian milliseconds since Unix epoch).\n  buf[offset++] = (msecs / 0x10000000000) & 0xff\n  buf[offset++] = (msecs / 0x100000000) & 0xff\n  buf[offset++] = (msecs / 0x1000000) & 0xff\n  buf[offset++] = (msecs / 0x10000) & 0xff\n  buf[offset++] = (msecs / 0x100) & 0xff\n  buf[offset++] = msecs & 0xff\n\n  // Set version (7) and variant (10xx), then pack sequence and random tail bytes.\n  buf[offset++] = 0x70 | ((seq >>> 28) & 0x0f)\n  buf[offset++] = (seq >>> 20) & 0xff\n  buf[offset++] = 0x80 | ((seq >>> 14) & 0x3f)\n  buf[offset++] = (seq >>> 6) & 0xff\n  // Lower seq bits plus 2 random bits to complete the 128-bit payload.\n  buf[offset++] = ((seq << 2) & 0xff) | (rnds[10] & 0x03)\n  buf[offset++] = rnds[11]\n  buf[offset++] = rnds[12]\n  buf[offset++] = rnds[13]\n  buf[offset++] = rnds[14]\n  buf[offset++] = rnds[15]\n\n  return buf\n}\n\n/*\n * Overload: no buffer => return a UUID string.\n */\nfunction v7(options?: Version7Options, buf?: undefined, offset?: number): string\n/*\n * Overload: caller provides a buffer slice to fill with UUID bytes.\n */\nfunction v7<TBuf extends Uint8Array = Uint8Array>(\n  options: Version7Options | undefined,\n  buf: TBuf,\n  offset?: number,\n): TBuf\nfunction v7<TBuf extends Uint8Array = Uint8Array>(\n  options?: Version7Options,\n  buf?: TBuf,\n  offset?: number,\n): string | TBuf {\n  let bytes: Uint8Array\n\n  if (options) {\n    bytes = v7Bytes(options.random ?? rng(), options.msecs, options.seq, buf, offset)\n  } else {\n    /**\n     * Note: by default, Cloudflare Workers \"freezes\" time during request handling to prevent\n     * side-channel attacks. This means that Date.now() will return the same value for the entire\n     * duration of a request.\n     * Implications:\n     * - all UUIDv7 generated within a single request will have the same timestamp.\n     * - the monotonic ordering will rely entirely on the `state.seq` counter\n     */\n    const now = Date.now()\n    const rnds = rng()\n\n    updateV7State(state, now, rnds)\n\n    bytes = v7Bytes(rnds, state.msecs, state.seq, buf, offset)\n  }\n\n  return buf ?? formatUuid(bytes)\n}\n\n/**\n * Generate a UUID v7 string or write the bytes into a buffer.\n * It also includes helpers to convert to and from byte arrays.\n */\nexport const uuidv7: UuidV7 = Object.assign(v7, {\n  toBytes: (id: string) => parseUuid(id),\n  fromBytes: (bytes: Uint8Array) => formatUuid(bytes),\n})\n"],"mappings":";;;;;;;;;;;AAkCA,MAAMA,QAAiB,EAAE;AAEzB,SAAS,cAAc,SAAkB,KAAa,MAA2B;AAE/E,SAAQ,UAAU;AAClB,SAAQ,QAAQ;AAEhB,KAAI,MAAM,QAAQ,OAAO;AAEvB,UAAQ,MAAO,KAAK,MAAM,KAAO,KAAK,MAAM,KAAO,KAAK,MAAM,IAAK,KAAK;AACxE,UAAQ,QAAQ;QACX;AAEL,UAAQ,MAAO,QAAQ,MAAM,IAAK;AAClC,MAAI,QAAQ,QAAQ,EAClB,SAAQ,SAAS;;AAIrB,QAAO;;AAGT,SAAS,QAAQ,MAAkB,OAAgB,KAAc,KAAkB,SAAS,GAAe;AACzG,KAAI,KAAK,SAAS,GAChB,OAAM,IAAI,MAAM,oCAAoC;AAGtD,KAAI,CAAC,KAAK;AACR,QAAM,IAAI,WAAW,GAAG;AACxB,WAAS;YACA,SAAS,KAAK,SAAS,KAAK,IAAI,OACzC,OAAM,IAAI,WAAW,mBAAmB,OAAO,GAAG,SAAS,GAAG,0BAA0B;AAG1F,WAAU,KAAK,KAAK;AAEpB,SAAU,KAAK,KAAK,OAAS,KAAO,KAAK,MAAM,KAAO,KAAK,MAAM,IAAK,KAAK;AAG3E,KAAI,YAAa,QAAQ,gBAAiB;AAC1C,KAAI,YAAa,QAAQ,aAAe;AACxC,KAAI,YAAa,QAAQ,WAAa;AACtC,KAAI,YAAa,QAAQ,QAAW;AACpC,KAAI,YAAa,QAAQ,MAAS;AAClC,KAAI,YAAY,QAAQ;AAGxB,KAAI,YAAY,MAAS,QAAQ,KAAM;AACvC,KAAI,YAAa,QAAQ,KAAM;AAC/B,KAAI,YAAY,MAAS,QAAQ,KAAM;AACvC,KAAI,YAAa,QAAQ,IAAK;AAE9B,KAAI,YAAc,OAAO,IAAK,MAAS,KAAK,MAAM;AAClD,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AACrB,KAAI,YAAY,KAAK;AAErB,QAAO;;AAeT,SAAS,GACP,SACA,KACA,QACe;CACf,IAAIC;AAEJ,KAAI,QACF,SAAQ,QAAQ,QAAQ,UAAU,KAAK,EAAE,QAAQ,OAAO,QAAQ,KAAK,KAAK,OAAO;MAC5E;;;;;;;;;EASL,MAAM,MAAM,KAAK,KAAK;EACtB,MAAM,OAAO,KAAK;AAElB,gBAAc,OAAO,KAAK,KAAK;AAE/B,UAAQ,QAAQ,MAAM,MAAM,OAAO,MAAM,KAAK,KAAK,OAAO;;AAG5D,QAAO,OAAO,WAAW,MAAM;;;;;;AAOjC,MAAaC,SAAiB,OAAO,OAAO,IAAI;CAC9C,UAAU,OAAe,UAAU,GAAG;CACtC,YAAY,UAAsB,WAAW,MAAM;CACpD,CAAC"}