�PNG  IHDR��;���IDATx��ܻn�0���K�� �)(�pA��� ���7�LeG{�� �§㻢|��ذaÆ 6lذaÆ 6lذaÆ 6lom��$^�y���ذag�5bÆ 6lذaÆ 6lذa{���� 6lذaÆ �`����}H�Fkm�,�m����Ӫ���ô�ô!� �x�|'ܢ˟;�E:���9�&ᶒ�}�{�v]�n&�6� �h��_��t�ڠ͵-ҫ���Z;��Z$�.�P���k�ž)�!��o���>}l�eQfJ�T��u і���چ��\��X=8��Rن4`Vw�l�>����n�G�^��i�s��"ms�$�u��i��?w�bs[m�6�K4���O���.�4��%����/����b�C%��t ��M�ז� �-l�G6�mrz2���s�%�9��s@���-�k�9�=���)������k�B5����\��+͂�Zsٲ ��Rn��~G���R���C����� �wIcI��n7jJ���hۛNCS|���j0��8y�iHKֶۛ�k�Ɉ+;Sz������L/��F�*\��Ԕ�#"5��m�2��[S��������=�g��n�a�P�e�ғ�L�� lذaÆ 6l�^k��̱aÆ 6lذaÆ 6lذa;���� �_��ذaÆ 6lذaÆ 6lذaÆ ���R���IEND�B` let crypto = require('crypto') let { urlAlphabet } = require('./url-alphabet/index.cjs') // It is best to make fewer, larger requests to the crypto module to // avoid system call overhead. So, random numbers are generated in a // pool. The pool is a Buffer that is larger than the initial random // request size by this multiplier. The pool is enlarged if subsequent // requests exceed the maximum buffer size. const POOL_SIZE_MULTIPLIER = 32 let pool, poolOffset let random = bytes => { if (!pool || pool.length < bytes) { pool = Buffer.allocUnsafe(bytes * POOL_SIZE_MULTIPLIER) crypto.randomFillSync(pool) poolOffset = 0 } else if (poolOffset + bytes > pool.length) { crypto.randomFillSync(pool) poolOffset = 0 } let res = pool.subarray(poolOffset, poolOffset + bytes) poolOffset += bytes return res } let customRandom = (alphabet, size, getRandom) => { // First, a bitmask is necessary to generate the ID. The bitmask makes bytes // values closer to the alphabet size. The bitmask calculates the closest // `2^31 - 1` number, which exceeds the alphabet size. // For example, the bitmask for the alphabet size 30 is 31 (00011111). let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 // Though, the bitmask solution is not perfect since the bytes exceeding // the alphabet size are refused. Therefore, to reliably generate the ID, // the random bytes redundancy has to be satisfied. // Note: every hardware random generator call is performance expensive, // because the system call for entropy collection takes a lot of time. // So, to avoid additional system calls, extra bytes are requested in advance. // Next, a step determines how many random bytes to generate. // The number of random bytes gets decided upon the ID size, mask, // alphabet size, and magic number 1.6 (using 1.6 peaks at performance // according to benchmarks). let step = Math.ceil((1.6 * mask * size) / alphabet.length) return () => { let id = '' while (true) { let bytes = getRandom(step) // A compact alternative for `for (let i = 0; i < step; i++)`. let i = step while (i--) { // Adding `|| ''` refuses a random byte that exceeds the alphabet size. id += alphabet[bytes[i] & mask] || '' if (id.length === size) return id } } } } let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random) let nanoid = (size = 21) => { let bytes = random(size) let id = '' // A compact alternative for `for (let i = 0; i < size; i++)`. while (size--) { // It is incorrect to use bytes exceeding the alphabet size. // The following mask reduces the random byte in the 0-255 value // range to the 0-63 value range. Therefore, adding hacks, such // as empty string fallback or magic numbers, is unneccessary because // the bitmask trims bytes down to the alphabet size. id += urlAlphabet[bytes[size] & 63] } return id } module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }