uniku 0.0.5 → 0.0.7

package/build/nanoid/nanoid.mjs

@@ -1,92 +1,2 @@
-import { n as getPooledBytes, t as createPool } from "../random-pool-CRCqpq0I.mjs";
-
-//#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_-]+$/;
-let pool;
-/**
-* 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) {
-	if (sizeOrOptions === void 0) {
-		if (!pool) pool = createPool(DEFAULT_SIZE);
-		const startOffset = getPooledBytes(pool, DEFAULT_SIZE);
-		let id$1 = "";
-		for (let i = startOffset; i < startOffset + DEFAULT_SIZE; i++) id$1 += URL_ALPHABET[pool.bytes[i] & 63];
-		return id$1;
-	}
-	let size = DEFAULT_SIZE;
-	let alphabet = URL_ALPHABET;
-	let randomBytes;
-	if (typeof sizeOrOptions === "number") size = sizeOrOptions;
-	else {
-		size = sizeOrOptions.size ?? DEFAULT_SIZE;
-		alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET;
-		randomBytes = sizeOrOptions.random;
-		if (sizeOrOptions.alphabet !== void 0) validateAlphabet(alphabet);
-	}
-	validateSize(size);
-	if (size === 0) return "";
-	const alphabetLen = alphabet.length;
-	if ((alphabetLen & alphabetLen - 1) === 0) {
-		const mask$1 = alphabetLen - 1;
-		if (randomBytes && randomBytes.length < size) throw new Error(`Insufficient random bytes: need ${size}, have ${randomBytes.length}`);
-		const bytes = randomBytes?.subarray(0, size) ?? globalThis.crypto.getRandomValues(new Uint8Array(size));
-		let id$1 = "";
-		for (let i = 0; i < size; i++) id$1 += alphabet[bytes[i] & mask$1];
-		return id$1;
-	}
-	const mask = (2 << 31 - Math.clz32(alphabetLen - 1 | 1)) - 1;
-	const step = Math.ceil(1.6 * mask * size / alphabetLen);
-	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 < alphabetLen) 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 };
+const e=`ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-`,t=2048,n=/^[A-Za-z0-9_-]+$/;let r,i=0;function a(e){let t=e*128;!r||r.length<t?(r=new Uint8Array(t),crypto.getRandomValues(r),i=0):i+e>r.length&&(crypto.getRandomValues(r),i=0),i+=e}function o(e){if(e.length<2)throw Error(`Alphabet must contain at least 2 characters`);if(e.length>256)throw Error(`Alphabet must not exceed 256 characters`);let t=new Set;for(let n of e){let e=n.charCodeAt(0);if(e<32||e>126)throw Error(`Alphabet must contain only printable ASCII characters (32-126)`);if(t.has(n))throw Error(`Duplicate character in alphabet: "${n}"`);t.add(n)}}function s(e){if(!Number.isInteger(e)||e<0)throw RangeError(`Size must be a non-negative integer`);if(e>t)throw RangeError(`Size must not exceed ${t}`)}function c(t){if(t===void 0){a(21);let t=``;for(let n=i-21;n<i;n++)t+=e[r[n]&63];return t}let n=21,c=e,l;if(typeof t==`number`?n=t:(n=t.size??21,c=t.alphabet??e,l=t.random,t.alphabet!==void 0&&o(c)),s(n),n===0)return``;let u=c.length;if(!(u&u-1)){let e=u-1;if(l&&l.length<n)throw Error(`Insufficient random bytes: need ${n}, have ${l.length}`);let t=l?.subarray(0,n)??globalThis.crypto.getRandomValues(new Uint8Array(n)),r=``;for(let i=0;i<n;i++)r+=c[t[i]&e];return r}let d=(2<<31-Math.clz32(u-1|1))-1,f=Math.ceil(1.6*d*n/u),p=``,m=0;for(;p.length<n;){let e;if(l){if(l.length-m<f)throw Error(`Insufficient random bytes: need at least ${f} more, have ${l.length-m}`);e=l.subarray(m,m+f),m+=f}else e=globalThis.crypto.getRandomValues(new Uint8Array(f));for(let t=0;t<e.length&&p.length<n;t++){let n=e[t]&d;n<u&&(p+=c[n])}}return p}function l(e){return typeof e==`string`&&e.length>0&&n.test(e)}const u=Object.assign(c,{isValid:l});export{e as URL_ALPHABET,u as nanoid};
 //# sourceMappingURL=nanoid.mjs.map

package/build/nanoid/nanoid.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"nanoid.mjs","names":["pool: RandomPool | undefined","id","randomBytes: Uint8Array | undefined","mask","bytes: Uint8Array","nanoid: Nanoid"],"sources":["../../src/nanoid/nanoid.ts"],"sourcesContent":["import { createPool, getPooledBytes, type RandomPool } from '../common/random-pool'\n\n/** 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\n// Nanoid's own pool - lazily initialized on first use\nlet pool: RandomPool | undefined\n\nexport type NanoidOptions = {\n  /**\n   * Random bytes for deterministic output (testing).\n   * For power-of-2 alphabets (2, 4, 8, 16, 32, 64, 128, 256): exactly `size` bytes needed.\n   * For other alphabets: ~size * 2 bytes needed (rejection sampling).\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  // ULTRA-FAST PATH: No arguments = default nanoid\n  // Uses thread-safe pooled random bytes for high performance\n  if (sizeOrOptions === undefined) {\n    if (!pool) pool = createPool(DEFAULT_SIZE)\n    const startOffset = getPooledBytes(pool, DEFAULT_SIZE)\n    let id = ''\n    for (let i = startOffset; i < startOffset + DEFAULT_SIZE; i++) {\n      id += URL_ALPHABET[pool.bytes[i] & 63]\n    }\n    return id\n  }\n\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 {\n    size = sizeOrOptions.size ?? DEFAULT_SIZE\n    alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET\n    randomBytes = sizeOrOptions.random\n    if (sizeOrOptions.alphabet !== undefined) {\n      validateAlphabet(alphabet)\n    }\n  }\n\n  validateSize(size)\n\n  if (size === 0) return ''\n\n  const alphabetLen = alphabet.length\n\n  // FAST PATH: Power-of-2 alphabet (includes default 64-char)\n  // No rejection needed - each byte maps directly to a character\n  if ((alphabetLen & (alphabetLen - 1)) === 0) {\n    const mask = alphabetLen - 1\n    if (randomBytes && randomBytes.length < size) {\n      throw new Error(`Insufficient random bytes: need ${size}, have ${randomBytes.length}`)\n    }\n    const bytes = randomBytes?.subarray(0, size) ?? globalThis.crypto.getRandomValues(new Uint8Array(size))\n    let id = ''\n    for (let i = 0; i < size; i++) {\n      id += alphabet[bytes[i] & mask]\n    }\n    return id\n  }\n\n  // SLOW PATH: Rejection sampling for non-power-of-2 alphabets\n  // Calculate mask: smallest power-of-2 minus 1 that covers alphabet size\n  const mask = (2 << (31 - Math.clz32((alphabetLen - 1) | 1))) - 1\n  // Calculate step: random bytes per batch (1.6x accounts for rejection)\n  const step = Math.ceil((1.6 * mask * size) / alphabetLen)\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 < alphabetLen) {\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":";;;;AAGA,MAAa,eAAe;AAE5B,MAAM,eAAe;AACrB,MAAM,WAAW;AACjB,MAAM,eAAe;AAGrB,IAAIA;;;;AAqCJ,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;AAGhE,KAAI,kBAAkB,QAAW;AAC/B,MAAI,CAAC,KAAM,QAAO,WAAW,aAAa;EAC1C,MAAM,cAAc,eAAe,MAAM,aAAa;EACtD,IAAIC,OAAK;AACT,OAAK,IAAI,IAAI,aAAa,IAAI,cAAc,cAAc,IACxD,SAAM,aAAa,KAAK,MAAM,KAAK;AAErC,SAAOA;;CAGT,IAAI,OAAO;CACX,IAAI,WAAW;CACf,IAAIC;AAEJ,KAAI,OAAO,kBAAkB,SAC3B,QAAO;MACF;AACL,SAAO,cAAc,QAAQ;AAC7B,aAAW,cAAc,YAAY;AACrC,gBAAc,cAAc;AAC5B,MAAI,cAAc,aAAa,OAC7B,kBAAiB,SAAS;;AAI9B,cAAa,KAAK;AAElB,KAAI,SAAS,EAAG,QAAO;CAEvB,MAAM,cAAc,SAAS;AAI7B,MAAK,cAAe,cAAc,OAAQ,GAAG;EAC3C,MAAMC,SAAO,cAAc;AAC3B,MAAI,eAAe,YAAY,SAAS,KACtC,OAAM,IAAI,MAAM,mCAAmC,KAAK,SAAS,YAAY,SAAS;EAExF,MAAM,QAAQ,aAAa,SAAS,GAAG,KAAK,IAAI,WAAW,OAAO,gBAAgB,IAAI,WAAW,KAAK,CAAC;EACvG,IAAIF,OAAK;AACT,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,IACxB,SAAM,SAAS,MAAM,KAAKE;AAE5B,SAAOF;;CAKT,MAAM,QAAQ,KAAM,KAAK,KAAK,MAAO,cAAc,IAAK,EAAE,IAAK;CAE/D,MAAM,OAAO,KAAK,KAAM,MAAM,OAAO,OAAQ,YAAY;CAEzD,IAAI,KAAK;CACT,IAAI,eAAe;AAEnB,QAAO,GAAG,SAAS,MAAM;EACvB,IAAIG;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,YACV,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"}
+{"version":3,"file":"nanoid.mjs","names":["pool: Uint8Array | undefined","id","randomBytes: Uint8Array | undefined","mask","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\n// Simple random pool for ultra-fast path (npm nanoid style - no thread-safety overhead)\nconst POOL_SIZE_MULTIPLIER = 128\nlet pool: Uint8Array | undefined\nlet poolOffset = 0\n\nfunction fillPool(bytes: number): void {\n  const size = bytes * POOL_SIZE_MULTIPLIER\n  if (!pool || pool.length < size) {\n    pool = new Uint8Array(size)\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  } else if (poolOffset + bytes > pool.length) {\n    crypto.getRandomValues(pool)\n    poolOffset = 0\n  }\n  poolOffset += bytes\n}\n\nexport type NanoidOptions = {\n  /**\n   * Random bytes for deterministic output (testing).\n   * For power-of-2 alphabets (2, 4, 8, 16, 32, 64, 128, 256): exactly `size` bytes needed.\n   * For other alphabets: ~size * 2 bytes needed (rejection sampling).\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  // ULTRA-FAST PATH: No arguments = default nanoid\n  // Uses simple pooled random bytes (npm nanoid style) for best performance\n  if (sizeOrOptions === undefined) {\n    fillPool(DEFAULT_SIZE)\n    let id = ''\n    for (let i = poolOffset - DEFAULT_SIZE; i < poolOffset; i++) {\n      id += URL_ALPHABET[pool![i] & 63]\n    }\n    return id\n  }\n\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 {\n    size = sizeOrOptions.size ?? DEFAULT_SIZE\n    alphabet = sizeOrOptions.alphabet ?? URL_ALPHABET\n    randomBytes = sizeOrOptions.random\n    if (sizeOrOptions.alphabet !== undefined) {\n      validateAlphabet(alphabet)\n    }\n  }\n\n  validateSize(size)\n\n  if (size === 0) return ''\n\n  const alphabetLen = alphabet.length\n\n  // FAST PATH: Power-of-2 alphabet (includes default 64-char)\n  // No rejection needed - each byte maps directly to a character\n  if ((alphabetLen & (alphabetLen - 1)) === 0) {\n    const mask = alphabetLen - 1\n    if (randomBytes && randomBytes.length < size) {\n      throw new Error(`Insufficient random bytes: need ${size}, have ${randomBytes.length}`)\n    }\n    const bytes = randomBytes?.subarray(0, size) ?? globalThis.crypto.getRandomValues(new Uint8Array(size))\n    let id = ''\n    for (let i = 0; i < size; i++) {\n      id += alphabet[bytes[i] & mask]\n    }\n    return id\n  }\n\n  // SLOW PATH: Rejection sampling for non-power-of-2 alphabets\n  // Calculate mask: smallest power-of-2 minus 1 that covers alphabet size\n  const mask = (2 << (31 - Math.clz32((alphabetLen - 1) | 1))) - 1\n  // Calculate step: random bytes per batch (1.6x accounts for rejection)\n  const step = Math.ceil((1.6 * mask * size) / alphabetLen)\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 < alphabetLen) {\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,mEAGtB,EAAW,KACX,EAAe,mBAIrB,IAAIA,EACA,EAAa,EAEjB,SAAS,EAAS,EAAqB,CACrC,IAAM,EAAO,EAAQ,IACjB,CAAC,GAAQ,EAAK,OAAS,GACzB,EAAO,IAAI,WAAW,EAAK,CAC3B,OAAO,gBAAgB,EAAK,CAC5B,EAAa,GACJ,EAAa,EAAQ,EAAK,SACnC,OAAO,gBAAgB,EAAK,CAC5B,EAAa,GAEf,GAAc,EAsChB,SAAS,EAAiB,EAAwB,CAChD,GAAI,EAAS,OAAS,EACpB,MAAU,MAAM,8CAA8C,CAEhE,GAAI,EAAS,OAAS,IACpB,MAAU,MAAM,0CAA0C,CAE5D,IAAM,EAAO,IAAI,IACjB,IAAK,IAAM,KAAQ,EAAU,CAC3B,IAAM,EAAO,EAAK,WAAW,EAAE,CAC/B,GAAI,EAAO,IAAM,EAAO,IACtB,MAAU,MAAM,iEAAiE,CAEnF,GAAI,EAAK,IAAI,EAAK,CAChB,MAAU,MAAM,qCAAqC,EAAK,GAAG,CAE/D,EAAK,IAAI,EAAK,EAOlB,SAAS,EAAa,EAAoB,CACxC,GAAI,CAAC,OAAO,UAAU,EAAK,EAAI,EAAO,EACpC,MAAU,WAAW,sCAAsC,CAE7D,GAAI,EAAO,EACT,MAAU,WAAW,wBAAwB,IAAW,CAQ5D,SAAS,EAAS,EAAgD,CAGhE,GAAI,IAAkB,IAAA,GAAW,CAC/B,EAAS,GAAa,CACtB,IAAIC,EAAK,GACT,IAAK,IAAI,EAAI,EAAa,GAAc,EAAI,EAAY,IACtD,GAAM,EAAa,EAAM,GAAK,IAEhC,OAAOA,EAGT,IAAI,EAAO,GACP,EAAW,EACXC,EAeJ,GAbI,OAAO,GAAkB,SAC3B,EAAO,GAEP,EAAO,EAAc,MAAQ,GAC7B,EAAW,EAAc,UAAY,EACrC,EAAc,EAAc,OACxB,EAAc,WAAa,IAAA,IAC7B,EAAiB,EAAS,EAI9B,EAAa,EAAK,CAEd,IAAS,EAAG,MAAO,GAEvB,IAAM,EAAc,EAAS,OAI7B,GAAA,EAAK,EAAe,EAAc,GAAW,CAC3C,IAAMC,EAAO,EAAc,EAC3B,GAAI,GAAe,EAAY,OAAS,EACtC,MAAU,MAAM,mCAAmC,EAAK,SAAS,EAAY,SAAS,CAExF,IAAM,EAAQ,GAAa,SAAS,EAAG,EAAK,EAAI,WAAW,OAAO,gBAAgB,IAAI,WAAW,EAAK,CAAC,CACnGF,EAAK,GACT,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,IACxB,GAAM,EAAS,EAAM,GAAKE,GAE5B,OAAOF,EAKT,IAAM,GAAQ,GAAM,GAAK,KAAK,MAAO,EAAc,EAAK,EAAE,EAAK,EAEzD,EAAO,KAAK,KAAM,IAAM,EAAO,EAAQ,EAAY,CAErD,EAAK,GACL,EAAe,EAEnB,KAAO,EAAG,OAAS,GAAM,CACvB,IAAIG,EACJ,GAAI,EAAa,CACf,GAAI,EAAY,OAAS,EAAe,EACtC,MAAU,MACR,4CAA4C,EAAK,cAAc,EAAY,OAAS,IACrF,CAEH,EAAQ,EAAY,SAAS,EAAc,EAAe,EAAK,CAC/D,GAAgB,OAEhB,EAAQ,WAAW,OAAO,gBAAgB,IAAI,WAAW,EAAK,CAAC,CAGjE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,QAAU,EAAG,OAAS,EAAM,IAAK,CACzD,IAAM,EAAQ,EAAM,GAAK,EACrB,EAAQ,IACV,GAAM,EAAS,KAMrB,OAAO,EAOT,SAAS,EAAQ,EAA2B,CAC1C,OAAO,OAAO,GAAO,UAAY,EAAG,OAAS,GAAK,EAAa,KAAK,EAAG,CAMzE,MAAaC,EAAiB,OAAO,OAAO,EAAU,CACpD,UACD,CAAC"}

package/build/random-CPlgK_62.mjs

@@ -0,0 +1,2 @@
+const e=new Uint8Array(256);let t=256;function n(){t>240&&(crypto.getRandomValues(e),t=0);let n=t;return t+=16,e.subarray(n,t)}export{n as t};
+//# sourceMappingURL=random-CPlgK_62.mjs.map

package/build/{random-B5WWq7hM.mjs.map → random-CPlgK_62.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"random-B5WWq7hM.mjs","names":[],"sources":["../src/uuid/common/random.ts"],"sourcesContent":["// Simple, fast random byte pool for UUID generation.\n// Uses plain JavaScript for maximum performance - no Atomics overhead.\n// Thread safety is not needed for typical UUID use cases.\n\nconst POOL_SIZE = 256 // uuid npm uses 256 bytes\nconst rnds8Pool = new Uint8Array(POOL_SIZE)\nlet poolPtr = POOL_SIZE // Start exhausted to trigger first fill\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Uses a pre-filled pool to minimize crypto API calls.\n */\nexport function rng(): Uint8Array {\n  if (poolPtr > POOL_SIZE - 16) {\n    crypto.getRandomValues(rnds8Pool)\n    poolPtr = 0\n  }\n  // Return a view - consumed synchronously within the same v7 call\n  const start = poolPtr\n  poolPtr += 16\n  return rnds8Pool.subarray(start, poolPtr)\n}\n\n/**\n * Fill the provided buffer with random bytes from the pool.\n */\nexport function randomBytes(out: Uint8Array): void {\n  const count = out.length\n  if (poolPtr > POOL_SIZE - count) {\n    crypto.getRandomValues(rnds8Pool)\n    poolPtr = 0\n  }\n  out.set(rnds8Pool.subarray(poolPtr, poolPtr + count))\n  poolPtr += count\n}\n"],"mappings":";AAIA,MAAM,YAAY;AAClB,MAAM,YAAY,IAAI,WAAW,UAAU;AAC3C,IAAI,UAAU;;;;;AAMd,SAAgB,MAAkB;AAChC,KAAI,UAAU,YAAY,IAAI;AAC5B,SAAO,gBAAgB,UAAU;AACjC,YAAU;;CAGZ,MAAM,QAAQ;AACd,YAAW;AACX,QAAO,UAAU,SAAS,OAAO,QAAQ"}
+{"version":3,"file":"random-CPlgK_62.mjs","names":[],"sources":["../src/uuid/common/random.ts"],"sourcesContent":["// Simple, fast random byte pool for UUID generation.\n// Uses plain JavaScript for maximum performance - no Atomics overhead.\n// Thread safety is not needed for typical UUID use cases.\n\nconst POOL_SIZE = 256 // uuid npm uses 256 bytes\nconst rnds8Pool = new Uint8Array(POOL_SIZE)\nlet poolPtr = POOL_SIZE // Start exhausted to trigger first fill\n\n/**\n * Generate 16 bytes of cryptographically strong random data.\n * Uses a pre-filled pool to minimize crypto API calls.\n */\nexport function rng(): Uint8Array {\n  if (poolPtr > POOL_SIZE - 16) {\n    crypto.getRandomValues(rnds8Pool)\n    poolPtr = 0\n  }\n  // Return a view - consumed synchronously within the same v7 call\n  const start = poolPtr\n  poolPtr += 16\n  return rnds8Pool.subarray(start, poolPtr)\n}\n\n/**\n * Fill the provided buffer with random bytes from the pool.\n */\nexport function randomBytes(out: Uint8Array): void {\n  const count = out.length\n  if (poolPtr > POOL_SIZE - count) {\n    crypto.getRandomValues(rnds8Pool)\n    poolPtr = 0\n  }\n  out.set(rnds8Pool.subarray(poolPtr, poolPtr + count))\n  poolPtr += count\n}\n"],"mappings":"AAIA,MACM,EAAY,IAAI,WAAW,IAAU,CAC3C,IAAI,EAAU,IAMd,SAAgB,GAAkB,CAC5B,EAAU,MACZ,OAAO,gBAAgB,EAAU,CACjC,EAAU,GAGZ,IAAM,EAAQ,EAEd,MADA,IAAW,GACJ,EAAU,SAAS,EAAO,EAAQ"}