nanoid 3.1.19 → 3.1.23

package/README.md

@@ -47,7 +47,6 @@ Supports modern browsers, IE [with Babel], Node.js and React Native.
   * [Create React App](#create-react-app)
   * [React Native](#react-native)
   * [Rollup](#rollup)
-  * [Expo](#expo)
   * [PouchDB and CouchDB](#pouchdb-and-couchdb)
   * [Mongoose](#mongoose)
   * [ES Modules](#es-modules)
@@ -139,7 +138,7 @@ Test configuration: Dell XPS 2-in-1 7390, Fedora 32, Node.js 15.1.
   Tidelift will coordinate the fix and disclosure.
 
 [Secure random values (in Node.js)]: https://gist.github.com/joepie91/7105003c3b26e65efcea63f3db82dfba
-[better algorithm]:                  https://github.com/ai/nanoid/blob/master/index.js
+[better algorithm]:                  https://github.com/ai/nanoid/blob/main/index.js
 
 
 ## Usage
@@ -154,6 +153,12 @@ import { nanoid } from 'nanoid'
 model.id = nanoid() //=> "V1StGXR8_Z5jdHi6B-myT"
 ```
 
+In Node.js you can use CommonJS import:
+
+```js
+const { nanoid } = require('nanoid')
+```
+
 If you want to reduce the ID size (and increase collisions probability),
 you can pass the size as an argument.
 
@@ -192,22 +197,43 @@ import { nanoid } from 'nanoid'
 
 ### React
 
-**Do not** call `nanoid` in the `key` prop. In React, `key` should be consistent
-among renders.
+There’s currently no correct way to use nanoid for React `key` prop
+since it should be consistent among renders.
 
-This is the bad example:
+```jsx
+function Todos({todos}) {
+  return (
+    <ul>
+      {todos.map(todo => (
+        <li key={nanoid()}> /* DON’T DO IT */
+          {todo.text}
+        </li>
+      ))}
+    </ul>
+  )
+}
+```
+
+You should rather try to reach for stable id inside your list item.
 
 ```jsx
-<Item key={nanoid()} /> /* DON’T DO IT */
+const todoItems = todos.map((todo) =>
+  <li key={todo.id}>
+    {todo.text}
+  </li>
+)
 ```
 
-This is the good example (`id` will be generated only once):
+In case you don’t have stable ids you'd rather use index as `key`
+instead of `nanoid()`:
 
 ```jsx
-const Element = () => {
-  const [id] = React.useState(nanoid)
-  return <Item key={id} />
-}
+const todoItems = todos.map((text, index) =>
+  <li key={index}> /* Still not recommended but preferred over nanoid().
+                      Only do this if items have no stable IDs. */
+    {text}
+  </li>
+)
 ```
 
 If you want to use Nano ID in the `id` prop, you must set some string prefix
@@ -220,22 +246,21 @@ If you want to use Nano ID in the `id` prop, you must set some string prefix
 
 ### Create React App
 
-Create React App has [a problem](https://github.com/ai/nanoid/issues/205)
-with ES modules packages.
+Create React App < 4.0.0 had
+[a problem](https://github.com/ai/nanoid/issues/205) with ES modules packages.
 
 ```
 TypeError: (0 , _nanoid.nanoid) is not a function
 ```
 
-[Pull request](https://github.com/facebook/create-react-app/pull/8768) was sent,
-but it was still not released.
-
-Use Nano ID 2 `npm i nanoid@^2.0.0` until Create React App 4.0 release.
+Use Nano ID 2 `npm i nanoid@^2.0.0` if you're using a version below
+CRA 4.0.
 
 
 ### React Native
 
-React Native does not have built-in random generator.
+React Native does not have built-in random generator. The following polyfill
+works for plain React Native and Expo starting with `39.x`.
 
 1. Check [`react-native-get-random-values`] docs and install it.
 2. Import it before Nano ID.
@@ -252,39 +277,25 @@ For Expo framework see the next section.
 
 ### Rollup
 
-For Rollup you will need [`@rollup/plugin-replace`] to replace
+For Rollup you will need [`@rollup/plugin-node-resolve`] to bundle browser version
+of this library and [`@rollup/plugin-replace`] to replace
 `process.env.NODE_ENV`:
 
 ```js
   plugins: [
+    nodeResolve({
+      browser: true
+    }),
     replace({
-      'process.env.NODE_ENV': JSON.stringify(process.env.NODE)
+      'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV)
     })
   ]
 ```
 
+[`@rollup/plugin-node-resolve`]: https://github.com/rollup/plugins/tree/master/packages/node-resolve
 [`@rollup/plugin-replace`]: https://github.com/rollup/plugins/tree/master/packages/replace
 
 
-### Expo
-
-If you use Expo in React Native, you need a different workaround.
-
-1. Install [`expo-random`](https://www.npmjs.com/package/expo-random).
-2. Use `nanoid/async` instead of `nanoid`.
-3. Import `index.native.js` file directly.
-
-```js
-import { nanoid } from 'nanoid/async/index.native'
-
-async function createUser () {
-  user.id = await nanoid()
-}
-```
-
-[`expo-random`]: https://www.npmjs.com/package/expo-random
-
-
 ### PouchDB and CouchDB
 
 In PouchDB and CouchDB, IDs can’t start with an underscore `_`.
@@ -375,7 +386,7 @@ the same ID generator on the client and server side.
 * [C++](https://github.com/mcmikecreations/nanoid_cpp)
 * [Clojure and ClojureScript](https://github.com/zelark/nano-id)
 * [Crystal](https://github.com/mamantoha/nanoid.cr)
-* [Dart](https://github.com/pd4d10/nanoid-dart)
+* [Dart & Flutter](https://github.com/pd4d10/nanoid-dart)
 * [Deno](https://github.com/ianfabs/nanoid)
 * [Go](https://github.com/matoous/go-nanoid)
 * [Elixir](https://github.com/railsmechanic/nanoid)
@@ -383,6 +394,7 @@ the same ID generator on the client and server side.
 * [Janet](https://sr.ht/~statianzo/janet-nanoid/)
 * [Java](https://github.com/aventrix/jnanoid)
 * [Nim](https://github.com/icyphox/nanoid.nim)
+* [Perl](https://github.com/tkzwtks/Nanoid-perl)
 * [PHP](https://github.com/hidehalo/nanoid-php)
 * [Python](https://github.com/puyuan/py-nanoid)
   with [dictionaries](https://pypi.org/project/nanoid-dictionary)

package/async/index.browser.js

@@ -34,7 +34,6 @@ let customAlphabet = (alphabet, size) => {
       while (i--) {
         // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
         id += alphabet[bytes[i] & mask] || ''
-        // Return if id length equals size.
         if (id.length === size) return Promise.resolve(id)
       }
     }
@@ -68,4 +67,4 @@ let nanoid = (size = 21) => {
   return Promise.resolve(id)
 }
 
-module.exports = { nanoid, customAlphabet, random }
+export { nanoid, customAlphabet, random }

package/async/index.cjs

@@ -0,0 +1,71 @@
+let crypto = require('crypto')
+
+let { urlAlphabet } = require('../url-alphabet/index.cjs')
+
+// `crypto.randomFill()` is a little faster than `crypto.randomBytes()`,
+// because it is possible to use in combination with `Buffer.allocUnsafe()`.
+let random = bytes =>
+  new Promise((resolve, reject) => {
+    // `Buffer.allocUnsafe()` is faster because it doesn’t flush the memory.
+    // Memory flushing is unnecessary since the buffer allocation itself resets
+    // the memory with the new bytes.
+    crypto.randomFill(Buffer.allocUnsafe(bytes), (err, buf) => {
+      if (err) {
+        reject(err)
+      } else {
+        resolve(buf)
+      }
+    })
+  })
+
+let customAlphabet = (alphabet, size) => {
+  // 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)
+
+  let tick = id =>
+    random(step).then(bytes => {
+      // A compact alternative for `for (var 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
+      }
+      return tick(id)
+    })
+
+  return () => tick('')
+}
+
+let nanoid = (size = 21) =>
+  random(size).then(bytes => {
+    let id = ''
+    // A compact alternative for `for (var i = 0; i < step; 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, random }

package/async/index.d.ts

@@ -14,7 +14,7 @@
  * @param size Size of the ID. The default size is 21.
  * @returns A promise with a random string.
  */
-export function nanoid (size?: number): Promise<string>
+export function nanoid(size?: number): Promise<string>
 
 /**
  * A low-level function.
@@ -35,7 +35,7 @@ export function nanoid (size?: number): Promise<string>
  * })
  * ```
  */
-export function customAlphabet (
+export function customAlphabet(
   alphabet: string,
   size: number
 ): () => Promise<string>
@@ -53,4 +53,4 @@ export function customAlphabet (
  * @param bytes Size of the array.
  * @returns A promise with a random bytes array.
  */
-export function random (bytes: number): Promise<Uint8Array>
+export function random(bytes: number): Promise<Uint8Array>

package/async/index.js

@@ -1,6 +1,6 @@
-let crypto = require('crypto')
+import crypto from 'crypto'
 
-let { urlAlphabet } = require('../url-alphabet')
+import { urlAlphabet } from '../url-alphabet/index.js'
 
 // `crypto.randomFill()` is a little faster than `crypto.randomBytes()`,
 // because it is possible to use in combination with `Buffer.allocUnsafe()`.
@@ -45,7 +45,6 @@ let customAlphabet = (alphabet, size) => {
       while (i--) {
         // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
         id += alphabet[bytes[i] & mask] || ''
-        // Return if id length equals size.
         if (id.length === size) return id
       }
       return tick(id)
@@ -69,4 +68,4 @@ let nanoid = (size = 21) =>
     return id
   })
 
-module.exports = { nanoid, customAlphabet, random }
+export { nanoid, customAlphabet, random }

package/async/index.native.js

@@ -1,6 +1,6 @@
-let { getRandomBytesAsync } = require('expo-random')
+import { getRandomBytesAsync } from 'expo-random'
 
-let { urlAlphabet } = require('../url-alphabet')
+import { urlAlphabet } from '../url-alphabet/index.js'
 
 let random = getRandomBytesAsync
 
@@ -31,7 +31,6 @@ let customAlphabet = (alphabet, size) => {
       while (i--) {
         // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
         id += alphabet[bytes[i] & mask] || ''
-        // Return if id length equals size.
         if (id.length === size) return id
       }
       return tick(id)
@@ -55,4 +54,4 @@ let nanoid = (size = 21) =>
     return id
   })
 
-module.exports = { nanoid, customAlphabet, random }
+export { nanoid, customAlphabet, random }

package/async/package.json

@@ -0,0 +1,11 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": {
+    "./index.js": "./index.native.js"
+  },
+  "browser": {
+    "./index.js": "./index.browser.js"
+  }
+}

package/index.browser.js

@@ -1,7 +1,7 @@
 // This file replaces `index.js` in bundlers like webpack or Rollup,
 // according to `browser` config in `package.json`.
 
-let { urlAlphabet } = require('./url-alphabet')
+import { urlAlphabet } from './url-alphabet/index.js'
 
 if (process.env.NODE_ENV !== 'production') {
   // All bundlers will remove this block in the production bundle.
@@ -14,8 +14,7 @@ if (process.env.NODE_ENV !== 'production') {
       'React Native does not have a built-in secure random generator. ' +
         'If you don’t need unpredictable IDs use `nanoid/non-secure`. ' +
         'For secure IDs, import `react-native-get-random-values` ' +
-        'before Nano ID. If you use Expo, install `expo-random` ' +
-        'and use `nanoid/async`.'
+        'before Nano ID.'
     )
   }
   if (typeof msCrypto !== 'undefined' && typeof crypto === 'undefined') {
@@ -67,7 +66,6 @@ let customRandom = (alphabet, size, getRandom) => {
       while (j--) {
         // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
         id += alphabet[bytes[j] & mask] || ''
-        // Return if id length equals size.
         if (id.length === size) return id
       }
     }
@@ -103,4 +101,4 @@ let nanoid = (size = 21) => {
   return id
 }
 
-module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }

package/index.cjs

@@ -0,0 +1,80 @@
+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 }

package/index.d.ts

@@ -12,7 +12,7 @@
  * @param size Size of the ID. The default size is 21.
  * @returns A random string.
  */
-export function nanoid (size?: number): string
+export function nanoid(size?: number): string
 
 /**
  * Generate secure unique ID with custom alphabet.
@@ -30,7 +30,7 @@ export function nanoid (size?: number): string
  * nanoid() //=> "8ё56а"
  * ```
  */
-export function customAlphabet (alphabet: string, size: number): () => string
+export function customAlphabet(alphabet: string, size: number): () => string
 
 /**
  * Generate unique ID with custom random generator and alphabet.
@@ -57,7 +57,7 @@ export function customAlphabet (alphabet: string, size: number): () => string
  * @param random A random bytes generator.
  * @returns A random string generator.
  */
-export function customRandom (
+export function customRandom(
   alphabet: string,
   size: number,
   random: (bytes: number) => Uint8Array
@@ -68,7 +68,7 @@ export function customRandom (
  *
  * ```js
  * import { urlAlphabet } from 'nanoid'
- * const nanoid = customRandom(urlAlphabet, 10)
+ * const nanoid = customAlphabet(urlAlphabet, 10)
  * nanoid() //=> "Uakgb_J5m9"
  * ```
  */
@@ -85,4 +85,4 @@ export const urlAlphabet: string
  * @param bytes Size of the array.
  * @returns An array of random bytes.
  */
-export function random (bytes: number): Uint8Array
+export function random(bytes: number): Uint8Array

package/index.dev.js

@@ -0,0 +1,104 @@
+// This file replaces `index.js` in bundlers like webpack or Rollup,
+// according to `browser` config in `package.json`.
+
+import { urlAlphabet } from './url-alphabet/index.js'
+
+if (true) {
+  // All bundlers will remove this block in the production bundle.
+  if (
+    typeof navigator !== 'undefined' &&
+    navigator.product === 'ReactNative' &&
+    typeof crypto === 'undefined'
+  ) {
+    throw new Error(
+      'React Native does not have a built-in secure random generator. ' +
+        'If you don’t need unpredictable IDs use `nanoid/non-secure`. ' +
+        'For secure IDs, import `react-native-get-random-values` ' +
+        'before Nano ID.'
+    )
+  }
+  if (typeof msCrypto !== 'undefined' && typeof crypto === 'undefined') {
+    throw new Error(
+      'Import file with `if (!window.crypto) window.crypto = window.msCrypto`' +
+        ' before importing Nano ID to fix IE 11 support'
+    )
+  }
+  if (typeof crypto === 'undefined') {
+    throw new Error(
+      'Your browser does not have secure random generator. ' +
+        'If you don’t need unpredictable IDs, you can use nanoid/non-secure.'
+    )
+  }
+}
+
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+
+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).
+  // `Math.clz32` is not used, because it is not available in browsers.
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 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).
+
+  // `-~f => Math.ceil(f)` if f is a float
+  // `-~i => i + 1` if i is an integer
+  let step = -~((1.6 * mask * size) / alphabet.length)
+
+  return () => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      let j = step
+      while (j--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+
+let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random)
+
+let nanoid = (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array(size))
+
+  // A compact alternative for `for (var i = 0; i < step; 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.
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      // `0-9a-z`
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      // `A-Z`
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }

package/index.js

@@ -1,6 +1,6 @@
-let crypto = require('crypto')
+import crypto from 'crypto'
 
-let { urlAlphabet } = require('./url-alphabet')
+import { urlAlphabet } from './url-alphabet/index.js'
 
 // It is best to make fewer, larger requests to the crypto module to
 // avoid system call overhead. So, random numbers are generated in a
@@ -49,12 +49,11 @@ let customRandom = (alphabet, size, getRandom) => {
     let id = ''
     while (true) {
       let bytes = getRandom(step)
-      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      // 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] || ''
-        // Return if id length equals size.
         if (id.length === size) return id
       }
     }
@@ -66,7 +65,7 @@ let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random)
 let nanoid = (size = 21) => {
   let bytes = random(size)
   let id = ''
-  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  // 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
@@ -78,4 +77,4 @@ let nanoid = (size = 21) => {
   return id
 }
 
-module.exports = { nanoid, customAlphabet, customRandom, urlAlphabet, random }
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }

package/index.prod.js

@@ -0,0 +1,104 @@
+// This file replaces `index.js` in bundlers like webpack or Rollup,
+// according to `browser` config in `package.json`.
+
+import { urlAlphabet } from './url-alphabet/index.js'
+
+if (false) {
+  // All bundlers will remove this block in the production bundle.
+  if (
+    typeof navigator !== 'undefined' &&
+    navigator.product === 'ReactNative' &&
+    typeof crypto === 'undefined'
+  ) {
+    throw new Error(
+      'React Native does not have a built-in secure random generator. ' +
+        'If you don’t need unpredictable IDs use `nanoid/non-secure`. ' +
+        'For secure IDs, import `react-native-get-random-values` ' +
+        'before Nano ID.'
+    )
+  }
+  if (typeof msCrypto !== 'undefined' && typeof crypto === 'undefined') {
+    throw new Error(
+      'Import file with `if (!window.crypto) window.crypto = window.msCrypto`' +
+        ' before importing Nano ID to fix IE 11 support'
+    )
+  }
+  if (typeof crypto === 'undefined') {
+    throw new Error(
+      'Your browser does not have secure random generator. ' +
+        'If you don’t need unpredictable IDs, you can use nanoid/non-secure.'
+    )
+  }
+}
+
+let random = bytes => crypto.getRandomValues(new Uint8Array(bytes))
+
+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).
+  // `Math.clz32` is not used, because it is not available in browsers.
+  let mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 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).
+
+  // `-~f => Math.ceil(f)` if f is a float
+  // `-~i => i + 1` if i is an integer
+  let step = -~((1.6 * mask * size) / alphabet.length)
+
+  return () => {
+    let id = ''
+    while (true) {
+      let bytes = getRandom(step)
+      // A compact alternative for `for (var i = 0; i < step; i++)`.
+      let j = step
+      while (j--) {
+        // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
+        id += alphabet[bytes[j] & mask] || ''
+        if (id.length === size) return id
+      }
+    }
+  }
+}
+
+let customAlphabet = (alphabet, size) => customRandom(alphabet, size, random)
+
+let nanoid = (size = 21) => {
+  let id = ''
+  let bytes = crypto.getRandomValues(new Uint8Array(size))
+
+  // A compact alternative for `for (var i = 0; i < step; 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.
+    let byte = bytes[size] & 63
+    if (byte < 36) {
+      // `0-9a-z`
+      id += byte.toString(36)
+    } else if (byte < 62) {
+      // `A-Z`
+      id += (byte - 26).toString(36).toUpperCase()
+    } else if (byte < 63) {
+      id += '_'
+    } else {
+      id += '-'
+    }
+  }
+  return id
+}
+
+export { nanoid, customAlphabet, customRandom, urlAlphabet, random }

package/non-secure/index.cjs

@@ -0,0 +1,30 @@
+// This alphabet uses `A-Za-z0-9_-` symbols. The genetic algorithm helped
+// optimize the gzip compression for this alphabet.
+let urlAlphabet =
+  'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
+
+let customAlphabet = (alphabet, size) => {
+  return () => {
+    let id = ''
+    // A compact alternative for `for (var i = 0; i < step; i++)`.
+    let i = size
+    while (i--) {
+      // `| 0` is more compact and faster than `Math.floor()`.
+      id += alphabet[(Math.random() * alphabet.length) | 0]
+    }
+    return id
+  }
+}
+
+let nanoid = (size = 21) => {
+  let id = ''
+  // A compact alternative for `for (var i = 0; i < step; i++)`.
+  let i = size
+  while (i--) {
+    // `| 0` is more compact and faster than `Math.floor()`.
+    id += urlAlphabet[(Math.random() * 64) | 0]
+  }
+  return id
+}
+
+module.exports = { nanoid, customAlphabet }

package/non-secure/index.d.ts

@@ -10,7 +10,7 @@
  * @param size Size of the ID. The default size is 21.
  * @returns A random string.
  */
-export function nanoid (size?: number): string
+export function nanoid(size?: number): string
 
 /**
  * Generate URL-friendly unique ID based on the custom alphabet.
@@ -27,4 +27,4 @@ export function nanoid (size?: number): string
  * model.id = //=> "8ё56а"
  * ```
  */
-export function customAlphabet (alphabet: string, size: number): () => string
+export function customAlphabet(alphabet: string, size: number): () => string

package/non-secure/index.js

@@ -27,4 +27,4 @@ let nanoid = (size = 21) => {
   return id
 }
 
-module.exports = { nanoid, customAlphabet }
+export { nanoid, customAlphabet }

package/non-secure/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nanoid",
-  "version": "3.1.19",
+  "version": "3.1.23",
   "description": "A tiny (108 bytes), secure URL-friendly unique string ID generator",
   "keywords": [
     "uuid",
@@ -15,13 +15,47 @@
   "license": "MIT",
   "repository": "ai/nanoid",
   "browser": {
-    "./index.js": "./index.browser.js",
-    "./async/index.js": "./async/index.browser.js"
-  },
-  "react-native": {
-    "./async/index.js": "./async/index.native.js"
+    "./index.js": "./index.browser.js"
   },
+  "react-native": "index.js",
   "bin": "./bin/nanoid.cjs",
   "sideEffects": false,
-  "types": "./index.d.ts"
-}
+  "types": "./index.d.ts",
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "exports": {
+    ".": {
+      "browser": {
+        "development": "./index.dev.js",
+        "production": "./index.prod.js",
+        "default": "./index.prod.js"
+      },
+      "require": "./index.cjs",
+      "import": "./index.js",
+      "default": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./async/package.json": "./async/package.json",
+    "./async": {
+      "browser": "./async/index.browser.js",
+      "require": "./async/index.cjs",
+      "import": "./async/index.js",
+      "default": "./async/index.js"
+    },
+    "./non-secure/package.json": "./non-secure/package.json",
+    "./non-secure": {
+      "require": "./non-secure/index.cjs",
+      "import": "./non-secure/index.js",
+      "default": "./non-secure/index.js"
+    },
+    "./url-alphabet/package.json": "./url-alphabet/package.json",
+    "./url-alphabet": {
+      "require": "./url-alphabet/index.cjs",
+      "import": "./url-alphabet/index.js",
+      "default": "./url-alphabet/index.js"
+    },
+    "./index.d.ts": "./index.d.ts"
+  }
+}

package/url-alphabet/index.cjs

@@ -0,0 +1,6 @@
+// This alphabet uses `A-Za-z0-9_-` symbols. The genetic algorithm helped
+// optimize the gzip compression for this alphabet.
+let urlAlphabet =
+  'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
+
+module.exports = { urlAlphabet }

package/url-alphabet/index.js

@@ -3,4 +3,4 @@
 let urlAlphabet =
   'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW'
 
-module.exports = { urlAlphabet }
+export { urlAlphabet }

package/url-alphabet/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "main": "index.cjs",
+  "module": "index.js",
+  "react-native": "index.js"
+}

package/CHANGELOG.md

@@ -1,238 +0,0 @@
-# Change Log
-This project adheres to [Semantic Versioning](http://semver.org/).
-
-## 3.1.19
-* Reduce `customAlphabet` size (by Enrico Scherlies).
-
-## 3.1.18
-* Fixed `package.exports`.
-
-## 3.1.17
-* Added files without `process`.
-
-## 3.1.16
-* Speeded up Nano ID 4 times (by Peter Boyer).
-
-## 3.1.15
-* Fixed `package.types` path.
-
-## 3.1.14
-* Added `package.types`.
-
-## 3.1.13
-* Removed Node.js 15.0.0 with `randomFillSync` regression from `engines.node`.
-
-## 3.1.12
-* Improved IE 11 docs.
-
-## 3.1.11
-* Fixed asynchronous `customAlphabet` in browser (by @LoneRifle).
-
-## 3.1.10
-* Fix ES modules support.
-
-## 3.1.9
-* Try to fix React Native Expo support.
-
-## 3.1.8
-* Add React Native Expo support.
-
-## 3.1.7
-* Clean up code.
-
-## 3.1.6
-* Avoid `self` using.
-
-## 3.1.5
-* Improve IE docs and warning.
-
-## 3.1.4
-* Restrict old Node.js 13 by `engines.node` (by Cansin Yildiz).
-
-## 3.1.3
-* Fix ES modules issue with CLI.
-
-## 3.1.2
-* Add shebang to CLI.
-
-## 3.1.1
-* Fix CLI.
-
-## 3.1
-* Add `npx nanoid` CLI.
-
-## 3.0.2
-* Fix docs (by Dylan Irlbeck ).
-
-## 3.0.1
-* Fix React Native warning on `non-secure` import (by Jia Huang).
-
-## 3.0
-**Migration guide:** <https://github.com/ai/nanoid/releases/tag/3.0.0>
-* Move to ES2016 syntax. You need to use Babel for IE 11.
-* Move to named exports `import { nanoid } from 'nanoid'`.
-* Move `import url from 'nanoid/url'` to `import { urlAlphabet } from 'nanoid'`.
-* Replace `format()` to `customRandom()`.
-* Replace `generate()` to `customAlphabet()`.
-* Remove `async/format`.
-* Remove React Native support for `nanoid/async`.
-* Add `nanoid.js` to use directly in browser from CDN.
-* Add TypeScript type definitions.
-* Add ES modules support for bundlers, Node.js, and React Native.
-* Fix React Native support.
-* Reduce size.
-* Improve docs (by Dair Aidarkhanov).
-
-## 2.1.11
-* Reduce size (by Anton Evzhakov).
-
-## 2.1.10
-* Reduce size by 10% (by Anton Khlynovskiy).
-
-## 2.1.9
-* Reduce `format` and `async/format` size (by Dair Aidarkhanov).
-
-## 2.1.8
-* Improve React docs (by Nahum Zsilva).
-
-## 2.1.7
-* Reduce `index`, `async` and `non-secure` size (by @polemius).
-
-## 2.1.6
-* Reduce size (by Stas Lashmanov).
-* Return fast mask for Node.js.
-
-## 2.1.5
-* Reduce size (by Max Graey).
-* Fix IE support.
-
-## 2.1.4
-* Reduce `generate` size (by Vsevolod Rodionov).
-* Reduce `format` and `format` size (by Victor).
-* Reduce `async`, `non-secure` and `non-secure/generate` size.
-* Speed up `format` and `async/format` (by Max Graey).
-* Improve development process on Windows (by Stanislav Lashmanov).
-
-## 2.1.3
-* Improve performance (by Stephen Richardson).
-* Reduce size (by Stephen Richardson).
-
-## 2.1.2
-* Improve docs.
-
-## 2.1.1
-* Fix React Native support (by Shawn Hwei).
-
-## 2.1
-* Improve React Native support (by Sebastian Werner).
-
-## 2.0.4
-* Improve error text for React Native (by Sebastian Werner).
-
-## 2.0.3
-* Fix freeze on string in ID length.
-
-## 2.0.2
-* Improve docs (by Sylvanus Kateile and Mark Stosberg).
-
-## 2.0.1
-* Reduce npm package size.
-* Mark package as not having side effects (by @xiaody).
-
-## 2.0
-* Use `-` instead of `~` in default alphabet to by file name safe.
-* Add `nanoid/non-secure/generate`.
-
-## 1.3.4
-* Reduce `non-secure` size.
-* Add `async` callback type check.
-
-## 1.3.3
-* Fix `nanoid/async` performance regression.
-* Fix old Node.js `not seeded` issue in synchronous version too.
-
-## 1.3.2
-* Fix random generator `not seeded` issue of old Node.js.
-
-## 1.3.1
-* Reduce library size.
-
-## 1.3
-* Add `nanoid/async/format` and `nanoid/async/generate`.
-* Improve synchronous API performance.
-* Reduce `url` size (by Daniil Poroshin).
-* Improve React Native docs (by joelgetaction).
-
-## 1.2.6
-* Reduce library size (by rqrqrqrq).
-
-## 1.2.5
-* Fix Node.js 6.11.1 support (by Andrey Belym).
-
-## 1.2.4
-* Speed up Node.js secure generators (by Dmitriy Tsvettsikh).
-
-## 1.2.3
-* Fix JSDoc (by Hendry Sadrak).
-
-## 1.2.2
-* Fix distribution in `nanoid/non-secure` (by Eatall).
-
-## 1.2.1
-* Fix old Node.js support.
-
-## 1.2
-* Add `nanoid/async`.
-* Fix `nanoid/non-secure` JSDoc.
-* Add Chinese documentation (by Wenliang Dai).
-* Speed up and reduce size of `nanoid/non-secure` (by Ori Livni).
-
-## 1.1.1
-* Improve performance and reduce size of non-secure ID generator.
-
-## 1.1
-* Add non-secure ID generator.
-* Suggest to use non-secure ID generator for React Native developers.
-* Reduce size.
-
-## 1.0.7
-* Fix documentation.
-
-## 1.0.6
-* Fix documentation.
-
-## 1.0.5
-* Reduce `nanoid/index` size (by Anton Khlynovskiy).
-
-## 1.0.4
-* Reduce npm package size.
-
-## 1.0.3
-* Reduce npm package size.
-
-## 1.0.2
-* Fix Web Workers support (by Zachary Golba).
-
-## 1.0.1
-* Reduce `nanoid/index` size (by Anton Khlynovskiy).
-
-## 1.0
-* Use 21 symbols by default (by David Klebanoff).
-
-## 0.2.2
-* Reduce `nanoid/generate` size (by Anton Khlynovskiy).
-* Speed up Node.js random generator.
-
-## 0.2.1
-* Fix documentation (by Piper Chester).
-
-## 0.2
-* Add `size` argument to `nanoid()`.
-* Improve performance by 50%.
-* Reduce library size by 26% (by Vsevolod Rodionov and Oleg Mokhov).
-
-## 0.1.1
-* Reduce library size by 5%.
-
-## 0.1
-* Initial release.

package/bin/nanoid.test.js

@@ -1,11 +0,0 @@
-let { promisify } = require('util')
-let { join } = require('path')
-let child = require('child_process')
-
-let exec = promisify(child.exec)
-
-it('prints unique ID', async () => {
-  let { stdout, stderr } = await exec('node ' + join(__dirname, 'nanoid.cjs'))
-  expect(stderr).toEqual('')
-  expect(stdout).toMatch(/^[\w-]{21}\n$/)
-})