uniku 0.0.5 → 0.0.7

package/build/random-pool-CRCqpq0I.mjs

@@ -1,100 +0,0 @@
-//#region src/common/random-pool.ts
-/**
-* Thread-safe random byte pool utilities using Atomics (when SharedArrayBuffer is available).
-* Falls back to regular pooling in environments without SharedArrayBuffer.
-*
-* This module provides STATELESS utilities - each consumer creates and manages its own pool.
-* Pass the pool state to each function (C-style) for explicit, predictable behavior.
-*
-* @example
-* ```ts
-* // Each module creates its own pool
-* let pool: RandomPool | undefined
-*
-* function getBytes(count: number): number {
-*   if (!pool) pool = createPool(count)
-*   return getPooledBytes(pool, count)
-* }
-* ```
-*/
-const POOL_SIZE_MULTIPLIER = 128;
-const POOL_HEADER_SIZE = 4;
-/**
-* Create a new random pool. Uses SharedArrayBuffer + Atomics when available
-* for thread-safety in Web Worker scenarios.
-*
-* @param minSize - Minimum bytes needed per request (pool = minSize * 128)
-*/
-function createPool(minSize) {
-	const totalSize = POOL_HEADER_SIZE + minSize * POOL_SIZE_MULTIPLIER;
-	let buffer;
-	let useAtomics = false;
-	if (typeof SharedArrayBuffer !== "undefined") try {
-		buffer = new SharedArrayBuffer(totalSize);
-		useAtomics = true;
-	} catch {
-		buffer = new ArrayBuffer(totalSize);
-	}
-	else buffer = new ArrayBuffer(totalSize);
-	const offset = new Int32Array(buffer, 0, 1);
-	const bytes = new Uint8Array(buffer, POOL_HEADER_SIZE);
-	crypto.getRandomValues(bytes);
-	return {
-		buffer,
-		bytes,
-		offset,
-		useAtomics
-	};
-}
-/**
-* Get pooled random bytes. Thread-safe when SharedArrayBuffer is available.
-* Returns the starting index in the pool for the requested bytes.
-*
-* @param pool - The pool state (from createPool)
-* @param count - Number of bytes needed
-* @returns Starting offset in pool.bytes
-*
-* @example
-* ```ts
-* const offset = getPooledBytes(pool, 21)
-* for (let i = offset; i < offset + 21; i++) {
-*   // Use pool.bytes[i]
-* }
-* ```
-*/
-function getPooledBytes(pool, count) {
-	if (pool.useAtomics) {
-		const startOffset = Atomics.add(pool.offset, 0, count);
-		if (startOffset + count <= pool.bytes.length) return startOffset;
-		if (Atomics.compareExchange(pool.offset, 0, startOffset + count, count) === startOffset + count) {
-			crypto.getRandomValues(pool.bytes);
-			return 0;
-		}
-		return getPooledBytes(pool, count);
-	} else {
-		let currentOffset = pool.offset[0];
-		if (currentOffset + count > pool.bytes.length) {
-			crypto.getRandomValues(pool.bytes);
-			currentOffset = 0;
-		}
-		pool.offset[0] = currentOffset + count;
-		return currentOffset;
-	}
-}
-/**
-* Get a Uint8Array slice of random bytes from the pool.
-*
-* Note: Returns a subarray VIEW into the pool. If you need the bytes to persist
-* beyond the current synchronous operation, use getRandomBytesCopy() instead.
-*
-* @param pool - The pool state
-* @param count - Number of bytes needed
-*/
-function getRandomBytes(pool, count) {
-	const offset = getPooledBytes(pool, count);
-	return pool.bytes.subarray(offset, offset + count);
-}
-
-//#endregion
-export { getPooledBytes as n, getRandomBytes as r, createPool as t };
-//# sourceMappingURL=random-pool-CRCqpq0I.mjs.map

package/build/random-pool-CRCqpq0I.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"random-pool-CRCqpq0I.mjs","names":["buffer: SharedArrayBuffer | ArrayBuffer"],"sources":["../src/common/random-pool.ts"],"sourcesContent":["/**\n * Thread-safe random byte pool utilities using Atomics (when SharedArrayBuffer is available).\n * Falls back to regular pooling in environments without SharedArrayBuffer.\n *\n * This module provides STATELESS utilities - each consumer creates and manages its own pool.\n * Pass the pool state to each function (C-style) for explicit, predictable behavior.\n *\n * @example\n * ```ts\n * // Each module creates its own pool\n * let pool: RandomPool | undefined\n *\n * function getBytes(count: number): number {\n *   if (!pool) pool = createPool(count)\n *   return getPooledBytes(pool, count)\n * }\n * ```\n */\n\nconst POOL_SIZE_MULTIPLIER = 128\nconst POOL_HEADER_SIZE = 4 // 4 bytes for Int32 offset counter\n\n/**\n * Pool state - passed to all pool functions.\n * Each module creates and owns its own pool instance.\n */\nexport type RandomPool = {\n  buffer: SharedArrayBuffer | ArrayBuffer\n  bytes: Uint8Array\n  offset: Int32Array\n  useAtomics: boolean\n}\n\n/**\n * Create a new random pool. Uses SharedArrayBuffer + Atomics when available\n * for thread-safety in Web Worker scenarios.\n *\n * @param minSize - Minimum bytes needed per request (pool = minSize * 128)\n */\nexport function createPool(minSize: number): RandomPool {\n  const poolSize = minSize * POOL_SIZE_MULTIPLIER\n  const totalSize = POOL_HEADER_SIZE + poolSize\n\n  let buffer: SharedArrayBuffer | ArrayBuffer\n  let useAtomics = false\n\n  // Try SharedArrayBuffer first (thread-safe with Atomics)\n  if (typeof SharedArrayBuffer !== 'undefined') {\n    try {\n      buffer = new SharedArrayBuffer(totalSize)\n      useAtomics = true\n    } catch {\n      // SharedArrayBuffer may be disabled (security restrictions)\n      buffer = new ArrayBuffer(totalSize)\n    }\n  } else {\n    buffer = new ArrayBuffer(totalSize)\n  }\n\n  // First 4 bytes = atomic offset counter, rest = random bytes\n  const offset = new Int32Array(buffer, 0, 1)\n  const bytes = new Uint8Array(buffer, POOL_HEADER_SIZE)\n  crypto.getRandomValues(bytes)\n\n  return { buffer, bytes, offset, useAtomics }\n}\n\n/**\n * Get pooled random bytes. Thread-safe when SharedArrayBuffer is available.\n * Returns the starting index in the pool for the requested bytes.\n *\n * @param pool - The pool state (from createPool)\n * @param count - Number of bytes needed\n * @returns Starting offset in pool.bytes\n *\n * @example\n * ```ts\n * const offset = getPooledBytes(pool, 21)\n * for (let i = offset; i < offset + 21; i++) {\n *   // Use pool.bytes[i]\n * }\n * ```\n */\nexport function getPooledBytes(pool: RandomPool, count: number): number {\n  if (pool.useAtomics) {\n    // Thread-safe path using Atomics\n    const startOffset = Atomics.add(pool.offset, 0, count)\n\n    if (startOffset + count <= pool.bytes.length) {\n      return startOffset\n    }\n\n    // Pool exhausted - need to refill\n    // Use compareExchange to ensure only one thread refills\n    const resetResult = Atomics.compareExchange(pool.offset, 0, startOffset + count, count)\n    if (resetResult === startOffset + count) {\n      // We won the race - refill the pool\n      crypto.getRandomValues(pool.bytes)\n      return 0\n    }\n\n    // Another thread is refilling or already refilled - retry\n    return getPooledBytes(pool, count)\n  } else {\n    // Single-threaded path\n    let currentOffset = pool.offset[0]\n\n    if (currentOffset + count > pool.bytes.length) {\n      crypto.getRandomValues(pool.bytes)\n      currentOffset = 0\n    }\n\n    pool.offset[0] = currentOffset + count\n    return currentOffset\n  }\n}\n\n/**\n * Get a Uint8Array slice of random bytes from the pool.\n *\n * Note: Returns a subarray VIEW into the pool. If you need the bytes to persist\n * beyond the current synchronous operation, use getRandomBytesCopy() instead.\n *\n * @param pool - The pool state\n * @param count - Number of bytes needed\n */\nexport function getRandomBytes(pool: RandomPool, count: number): Uint8Array {\n  const offset = getPooledBytes(pool, count)\n  return pool.bytes.subarray(offset, offset + count)\n}\n\n/**\n * Get a COPY of random bytes from the pool.\n * Use this when bytes need to persist (e.g., returned to caller who may use them later).\n *\n * @param pool - The pool state\n * @param count - Number of bytes needed\n */\nexport function getRandomBytesCopy(pool: RandomPool, count: number): Uint8Array {\n  const offset = getPooledBytes(pool, count)\n  return pool.bytes.slice(offset, offset + count)\n}\n\n/**\n * Fill the provided buffer with random bytes from the pool.\n *\n * @param pool - The pool state\n * @param out - Buffer to fill\n */\nexport function fillRandomBytes(pool: RandomPool, out: Uint8Array): void {\n  const offset = getPooledBytes(pool, out.length)\n  out.set(pool.bytes.subarray(offset, offset + out.length))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAM,uBAAuB;AAC7B,MAAM,mBAAmB;;;;;;;AAmBzB,SAAgB,WAAW,SAA6B;CAEtD,MAAM,YAAY,mBADD,UAAU;CAG3B,IAAIA;CACJ,IAAI,aAAa;AAGjB,KAAI,OAAO,sBAAsB,YAC/B,KAAI;AACF,WAAS,IAAI,kBAAkB,UAAU;AACzC,eAAa;SACP;AAEN,WAAS,IAAI,YAAY,UAAU;;KAGrC,UAAS,IAAI,YAAY,UAAU;CAIrC,MAAM,SAAS,IAAI,WAAW,QAAQ,GAAG,EAAE;CAC3C,MAAM,QAAQ,IAAI,WAAW,QAAQ,iBAAiB;AACtD,QAAO,gBAAgB,MAAM;AAE7B,QAAO;EAAE;EAAQ;EAAO;EAAQ;EAAY;;;;;;;;;;;;;;;;;;AAmB9C,SAAgB,eAAe,MAAkB,OAAuB;AACtE,KAAI,KAAK,YAAY;EAEnB,MAAM,cAAc,QAAQ,IAAI,KAAK,QAAQ,GAAG,MAAM;AAEtD,MAAI,cAAc,SAAS,KAAK,MAAM,OACpC,QAAO;AAMT,MADoB,QAAQ,gBAAgB,KAAK,QAAQ,GAAG,cAAc,OAAO,MAAM,KACnE,cAAc,OAAO;AAEvC,UAAO,gBAAgB,KAAK,MAAM;AAClC,UAAO;;AAIT,SAAO,eAAe,MAAM,MAAM;QAC7B;EAEL,IAAI,gBAAgB,KAAK,OAAO;AAEhC,MAAI,gBAAgB,QAAQ,KAAK,MAAM,QAAQ;AAC7C,UAAO,gBAAgB,KAAK,MAAM;AAClC,mBAAgB;;AAGlB,OAAK,OAAO,KAAK,gBAAgB;AACjC,SAAO;;;;;;;;;;;;AAaX,SAAgB,eAAe,MAAkB,OAA2B;CAC1E,MAAM,SAAS,eAAe,MAAM,MAAM;AAC1C,QAAO,KAAK,MAAM,SAAS,QAAQ,SAAS,MAAM"}

package/build/uuid-BEUMa9NG.mjs

@@ -1,43 +0,0 @@
-//#region src/uuid/common/hex.ts
-const HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-const ASCII_0 = 48;
-const ASCII_9 = 57;
-const ASCII_A = 65;
-const ASCII_F = 70;
-const ASCII_a = 97;
-const ASCII_f = 102;
-function hexValue(code) {
-	if (code >= ASCII_0 && code <= ASCII_9) return code - ASCII_0;
-	if (code >= ASCII_A && code <= ASCII_F) return code - ASCII_A + 10;
-	if (code >= ASCII_a && code <= ASCII_f) return code - ASCII_a + 10;
-	return -1;
-}
-function hexToBytes(hex, out) {
-	if (hex.length !== out.length * 2) throw new Error(`hex string must be ${out.length * 2} chars, got ${hex.length}`);
-	for (let i = 0; i < out.length; i += 1) {
-		const hi = hexValue(hex.charCodeAt(i * 2));
-		const lo = hexValue(hex.charCodeAt(i * 2 + 1));
-		if (hi === -1 || lo === -1) throw new Error("hex string contains invalid characters");
-		out[i] = hi << 4 | lo;
-	}
-}
-
-//#endregion
-//#region src/uuid/common/uuid.ts
-const UUID_BYTE_LENGTH = 16;
-const UUID_STRING_LENGTH = 36;
-function formatUuid(bytes) {
-	return HEX_TABLE[bytes[0]] + HEX_TABLE[bytes[1]] + HEX_TABLE[bytes[2]] + HEX_TABLE[bytes[3]] + "-" + HEX_TABLE[bytes[4]] + HEX_TABLE[bytes[5]] + "-" + HEX_TABLE[bytes[6]] + HEX_TABLE[bytes[7]] + "-" + HEX_TABLE[bytes[8]] + HEX_TABLE[bytes[9]] + "-" + HEX_TABLE[bytes[10]] + HEX_TABLE[bytes[11]] + HEX_TABLE[bytes[12]] + HEX_TABLE[bytes[13]] + HEX_TABLE[bytes[14]] + HEX_TABLE[bytes[15]];
-}
-function parseUuid(value) {
-	if (value.length !== UUID_STRING_LENGTH) throw new Error("uuid string must be 36 characters");
-	if (value[8] !== "-" || value[13] !== "-" || value[18] !== "-" || value[23] !== "-") throw new Error("uuid string has invalid separators");
-	const hex = value.slice(0, 8) + value.slice(9, 13) + value.slice(14, 18) + value.slice(19, 23) + value.slice(24);
-	const bytes = new Uint8Array(UUID_BYTE_LENGTH);
-	hexToBytes(hex, bytes);
-	return bytes;
-}
-
-//#endregion
-export { parseUuid as n, formatUuid as t };
-//# sourceMappingURL=uuid-BEUMa9NG.mjs.map