Changeset 0c6b92a for imaps-frontend/node_modules/nanoid/async
- Timestamp:
- 12/12/24 17:06:06 (6 weeks ago)
- Branches:
- main
- Children:
- 79a0317
- Parents:
- d565449
- Location:
- imaps-frontend/node_modules/nanoid/async
- Files:
-
- 5 edited
Legend:
- Unmodified
- Added
- Removed
-
TabularUnified imaps-frontend/node_modules/nanoid/async/index.browser.cjs ¶
rd565449 r0c6b92a 1 1 let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes)) 2 2 3 let customAlphabet = (alphabet, defaultSize = 21) => { 4 // First, a bitmask is necessary to generate the ID. The bitmask makes bytes 5 // values closer to the alphabet size. The bitmask calculates the closest 6 // `2^31 - 1` number, which exceeds the alphabet size. 7 // For example, the bitmask for the alphabet size 30 is 31 (00011111). 8 // `Math.clz32` is not used, because it is not available in browsers. 3 9 let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 10 // Though, the bitmask solution is not perfect since the bytes exceeding 11 // the alphabet size are refused. Therefore, to reliably generate the ID, 12 // the random bytes redundancy has to be satisfied. 13 14 // Note: every hardware random generator call is performance expensive, 15 // because the system call for entropy collection takes a lot of time. 16 // So, to avoid additional system calls, extra bytes are requested in advance. 17 18 // Next, a step determines how many random bytes to generate. 19 // The number of random bytes gets decided upon the ID size, mask, 20 // alphabet size, and magic number 1.6 (using 1.6 peaks at performance 21 // according to benchmarks). 22 23 // `-~f => Math.ceil(f)` if f is a float 24 // `-~i => i + 1` if i is an integer 4 25 let step = -~((1.6 * mask * defaultSize) / alphabet.length) 26 5 27 return async (size = defaultSize) => { 6 28 let id = '' 7 29 while (true) { 8 30 let bytes = crypto.getRandomValues(new Uint8Array(step)) 9 let i = step 31 // A compact alternative for `for (var i = 0; i < step; i++)`. 32 let i = step | 0 10 33 while (i--) { 34 // Adding `|| ''` refuses a random byte that exceeds the alphabet size. 11 35 id += alphabet[bytes[i] & mask] || '' 12 36 if (id.length === size) return id … … 15 39 } 16 40 } 41 17 42 let nanoid = async (size = 21) => { 18 43 let id = '' 19 let bytes = crypto.getRandomValues(new Uint8Array(size)) 44 let bytes = crypto.getRandomValues(new Uint8Array((size |= 0))) 45 46 // A compact alternative for `for (var i = 0; i < step; i++)`. 20 47 while (size--) { 48 // It is incorrect to use bytes exceeding the alphabet size. 49 // The following mask reduces the random byte in the 0-255 value 50 // range to the 0-63 value range. Therefore, adding hacks, such 51 // as empty string fallback or magic numbers, is unneccessary because 52 // the bitmask trims bytes down to the alphabet size. 21 53 let byte = bytes[size] & 63 22 54 if (byte < 36) { 55 // `0-9a-z` 23 56 id += byte.toString(36) 24 57 } else if (byte < 62) { 58 // `A-Z` 25 59 id += (byte - 26).toString(36).toUpperCase() 26 60 } else if (byte < 63) { … … 32 66 return id 33 67 } 68 34 69 module.exports = { nanoid, customAlphabet, random } -
TabularUnified imaps-frontend/node_modules/nanoid/async/index.browser.js ¶
rd565449 r0c6b92a 1 1 let random = async bytes => crypto.getRandomValues(new Uint8Array(bytes)) 2 2 3 let customAlphabet = (alphabet, defaultSize = 21) => { 4 // First, a bitmask is necessary to generate the ID. The bitmask makes bytes 5 // values closer to the alphabet size. The bitmask calculates the closest 6 // `2^31 - 1` number, which exceeds the alphabet size. 7 // For example, the bitmask for the alphabet size 30 is 31 (00011111). 8 // `Math.clz32` is not used, because it is not available in browsers. 3 9 let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1 10 // Though, the bitmask solution is not perfect since the bytes exceeding 11 // the alphabet size are refused. Therefore, to reliably generate the ID, 12 // the random bytes redundancy has to be satisfied. 13 14 // Note: every hardware random generator call is performance expensive, 15 // because the system call for entropy collection takes a lot of time. 16 // So, to avoid additional system calls, extra bytes are requested in advance. 17 18 // Next, a step determines how many random bytes to generate. 19 // The number of random bytes gets decided upon the ID size, mask, 20 // alphabet size, and magic number 1.6 (using 1.6 peaks at performance 21 // according to benchmarks). 22 23 // `-~f => Math.ceil(f)` if f is a float 24 // `-~i => i + 1` if i is an integer 4 25 let step = -~((1.6 * mask * defaultSize) / alphabet.length) 26 5 27 return async (size = defaultSize) => { 6 28 let id = '' 7 29 while (true) { 8 30 let bytes = crypto.getRandomValues(new Uint8Array(step)) 9 let i = step 31 // A compact alternative for `for (var i = 0; i < step; i++)`. 32 let i = step | 0 10 33 while (i--) { 34 // Adding `|| ''` refuses a random byte that exceeds the alphabet size. 11 35 id += alphabet[bytes[i] & mask] || '' 12 36 if (id.length === size) return id … … 15 39 } 16 40 } 41 17 42 let nanoid = async (size = 21) => { 18 43 let id = '' 19 let bytes = crypto.getRandomValues(new Uint8Array(size)) 44 let bytes = crypto.getRandomValues(new Uint8Array((size |= 0))) 45 46 // A compact alternative for `for (var i = 0; i < step; i++)`. 20 47 while (size--) { 48 // It is incorrect to use bytes exceeding the alphabet size. 49 // The following mask reduces the random byte in the 0-255 value 50 // range to the 0-63 value range. Therefore, adding hacks, such 51 // as empty string fallback or magic numbers, is unneccessary because 52 // the bitmask trims bytes down to the alphabet size. 21 53 let byte = bytes[size] & 63 22 54 if (byte < 36) { 55 // `0-9a-z` 23 56 id += byte.toString(36) 24 57 } else if (byte < 62) { 58 // `A-Z` 25 59 id += (byte - 26).toString(36).toUpperCase() 26 60 } else if (byte < 63) { … … 32 66 return id 33 67 } 68 34 69 export { nanoid, customAlphabet, random } -
TabularUnified imaps-frontend/node_modules/nanoid/async/index.cjs ¶
rd565449 r0c6b92a 1 1 let crypto = require('crypto') 2 2 3 let { urlAlphabet } = require('../url-alphabet/index.cjs') 4 5 // `crypto.randomFill()` is a little faster than `crypto.randomBytes()`, 6 // because it is possible to use in combination with `Buffer.allocUnsafe()`. 3 7 let random = bytes => 4 8 new Promise((resolve, reject) => { 9 // `Buffer.allocUnsafe()` is faster because it doesn’t flush the memory. 10 // Memory flushing is unnecessary since the buffer allocation itself resets 11 // the memory with the new bytes. 5 12 crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => { 6 13 if (err) { … … 11 18 }) 12 19 }) 20 13 21 let customAlphabet = (alphabet, defaultSize = 21) => { 22 // First, a bitmask is necessary to generate the ID. The bitmask makes bytes 23 // values closer to the alphabet size. The bitmask calculates the closest 24 // `2^31 - 1` number, which exceeds the alphabet size. 25 // For example, the bitmask for the alphabet size 30 is 31 (00011111). 14 26 let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 27 // Though, the bitmask solution is not perfect since the bytes exceeding 28 // the alphabet size are refused. Therefore, to reliably generate the ID, 29 // the random bytes redundancy has to be satisfied. 30 31 // Note: every hardware random generator call is performance expensive, 32 // because the system call for entropy collection takes a lot of time. 33 // So, to avoid additional system calls, extra bytes are requested in advance. 34 35 // Next, a step determines how many random bytes to generate. 36 // The number of random bytes gets decided upon the ID size, mask, 37 // alphabet size, and magic number 1.6 (using 1.6 peaks at performance 38 // according to benchmarks). 15 39 let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) 40 16 41 let tick = (id, size = defaultSize) => 17 42 random(step).then(bytes => { 43 // A compact alternative for `for (var i = 0; i < step; i++)`. 18 44 let i = step 19 45 while (i--) { 46 // Adding `|| ''` refuses a random byte that exceeds the alphabet size. 20 47 id += alphabet[bytes[i] & mask] || '' 21 if (id.length === size) return id48 if (id.length >= size) return id 22 49 } 23 50 return tick(id, size) 24 51 }) 52 25 53 return size => tick('', size) 26 54 } 55 27 56 let nanoid = (size = 21) => 28 random( size).then(bytes => {57 random((size |= 0)).then(bytes => { 29 58 let id = '' 59 // A compact alternative for `for (var i = 0; i < step; i++)`. 30 60 while (size--) { 61 // It is incorrect to use bytes exceeding the alphabet size. 62 // The following mask reduces the random byte in the 0-255 value 63 // range to the 0-63 value range. Therefore, adding hacks, such 64 // as empty string fallback or magic numbers, is unneccessary because 65 // the bitmask trims bytes down to the alphabet size. 31 66 id += urlAlphabet[bytes[size] & 63] 32 67 } 33 68 return id 34 69 }) 70 35 71 module.exports = { nanoid, customAlphabet, random } -
TabularUnified imaps-frontend/node_modules/nanoid/async/index.js ¶
rd565449 r0c6b92a 1 1 import crypto from 'crypto' 2 2 3 import { urlAlphabet } from '../url-alphabet/index.js' 4 5 // `crypto.randomFill()` is a little faster than `crypto.randomBytes()`, 6 // because it is possible to use in combination with `Buffer.allocUnsafe()`. 3 7 let random = bytes => 4 8 new Promise((resolve, reject) => { 9 // `Buffer.allocUnsafe()` is faster because it doesn’t flush the memory. 10 // Memory flushing is unnecessary since the buffer allocation itself resets 11 // the memory with the new bytes. 5 12 crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => { 6 13 if (err) { … … 11 18 }) 12 19 }) 20 13 21 let customAlphabet = (alphabet, defaultSize = 21) => { 22 // First, a bitmask is necessary to generate the ID. The bitmask makes bytes 23 // values closer to the alphabet size. The bitmask calculates the closest 24 // `2^31 - 1` number, which exceeds the alphabet size. 25 // For example, the bitmask for the alphabet size 30 is 31 (00011111). 14 26 let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 27 // Though, the bitmask solution is not perfect since the bytes exceeding 28 // the alphabet size are refused. Therefore, to reliably generate the ID, 29 // the random bytes redundancy has to be satisfied. 30 31 // Note: every hardware random generator call is performance expensive, 32 // because the system call for entropy collection takes a lot of time. 33 // So, to avoid additional system calls, extra bytes are requested in advance. 34 35 // Next, a step determines how many random bytes to generate. 36 // The number of random bytes gets decided upon the ID size, mask, 37 // alphabet size, and magic number 1.6 (using 1.6 peaks at performance 38 // according to benchmarks). 15 39 let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) 40 16 41 let tick = (id, size = defaultSize) => 17 42 random(step).then(bytes => { 43 // A compact alternative for `for (var i = 0; i < step; i++)`. 18 44 let i = step 19 45 while (i--) { 46 // Adding `|| ''` refuses a random byte that exceeds the alphabet size. 20 47 id += alphabet[bytes[i] & mask] || '' 21 if (id.length === size) return id48 if (id.length >= size) return id 22 49 } 23 50 return tick(id, size) 24 51 }) 52 25 53 return size => tick('', size) 26 54 } 55 27 56 let nanoid = (size = 21) => 28 random( size).then(bytes => {57 random((size |= 0)).then(bytes => { 29 58 let id = '' 59 // A compact alternative for `for (var i = 0; i < step; i++)`. 30 60 while (size--) { 61 // It is incorrect to use bytes exceeding the alphabet size. 62 // The following mask reduces the random byte in the 0-255 value 63 // range to the 0-63 value range. Therefore, adding hacks, such 64 // as empty string fallback or magic numbers, is unneccessary because 65 // the bitmask trims bytes down to the alphabet size. 31 66 id += urlAlphabet[bytes[size] & 63] 32 67 } 33 68 return id 34 69 }) 70 35 71 export { nanoid, customAlphabet, random } -
TabularUnified imaps-frontend/node_modules/nanoid/async/index.native.js ¶
rd565449 r0c6b92a 1 1 import { getRandomBytesAsync } from 'expo-random' 2 2 3 import { urlAlphabet } from '../url-alphabet/index.js' 4 3 5 let random = getRandomBytesAsync 6 4 7 let customAlphabet = (alphabet, defaultSize = 21) => { 8 // First, a bitmask is necessary to generate the ID. The bitmask makes bytes 9 // values closer to the alphabet size. The bitmask calculates the closest 10 // `2^31 - 1` number, which exceeds the alphabet size. 11 // For example, the bitmask for the alphabet size 30 is 31 (00011111). 5 12 let mask = (2 << (31 - Math.clz32((alphabet.length - 1) | 1))) - 1 13 // Though, the bitmask solution is not perfect since the bytes exceeding 14 // the alphabet size are refused. Therefore, to reliably generate the ID, 15 // the random bytes redundancy has to be satisfied. 16 17 // Note: every hardware random generator call is performance expensive, 18 // because the system call for entropy collection takes a lot of time. 19 // So, to avoid additional system calls, extra bytes are requested in advance. 20 21 // Next, a step determines how many random bytes to generate. 22 // The number of random bytes gets decided upon the ID size, mask, 23 // alphabet size, and magic number 1.6 (using 1.6 peaks at performance 24 // according to benchmarks). 6 25 let step = Math.ceil((1.6 * mask * defaultSize) / alphabet.length) 26 7 27 let tick = (id, size = defaultSize) => 8 28 random(step).then(bytes => { 29 // A compact alternative for `for (var i = 0; i < step; i++)`. 9 30 let i = step 10 31 while (i--) { 32 // Adding `|| ''` refuses a random byte that exceeds the alphabet size. 11 33 id += alphabet[bytes[i] & mask] || '' 12 if (id.length === size) return id34 if (id.length >= size) return id 13 35 } 14 36 return tick(id, size) 15 37 }) 38 16 39 return size => tick('', size) 17 40 } 41 18 42 let nanoid = (size = 21) => 19 random( size).then(bytes => {43 random((size |= 0)).then(bytes => { 20 44 let id = '' 45 // A compact alternative for `for (var i = 0; i < step; i++)`. 21 46 while (size--) { 47 // It is incorrect to use bytes exceeding the alphabet size. 48 // The following mask reduces the random byte in the 0-255 value 49 // range to the 0-63 value range. Therefore, adding hacks, such 50 // as empty string fallback or magic numbers, is unneccessary because 51 // the bitmask trims bytes down to the alphabet size. 22 52 id += urlAlphabet[bytes[size] & 63] 23 53 } 24 54 return id 25 55 }) 56 26 57 export { nanoid, customAlphabet, random }
Note:
See TracChangeset
for help on using the changeset viewer.