Generate a potential of _1 million_ random strings with _1 in a billion_ chance of repeat:

```js

const random = new Random()

const bits = Entropy.bits(1e6, 1e9)

`EntropyString` uses predefined `charset32` characters by default (see [Character Sets](#CharacterSets)). To get a random hexadecimal string with the same entropy `bits` as above:

```js

const random = new Random(charSet16)

const bits = Entropy.bits(1e6, 1e9)

Custom characters may be specified. Using uppercase hexadecimal characters:

```js

const random = new Random('0123456789ABCDEF')

const bits = Entropy.bits(1e6, 1e9)

Convenience functions `smallID`, `mediumID`, `largeID`, `sessionID` and `token` provide random strings for various predefined bits of entropy. For example, a small id represents a potential of 30 strings with a 1 in a million chance of repeat:

```js

const random = new Random()

const string = random.smallID()

Or, to generate an OWASP session ID:

```js

const random = new Random()

const string = random.sessionID()

Or perhaps you need an 256-bit token using [RFC 4648](https://tools.ietf.org/html/rfc4648#section-5) file system and URL safe characters:

```js

const random = new Random(charSet64)

Let's use `entropy-string` to help this developer generate 5 hexadecimal IDs from a pool of a potentail 10,000 IDs with a 1 in a milllion chance of a repeat:

```js

const bits = Entropy.bits(10000, 1000000)

const random = new Random(charSet16)

We'll start with using 32 characters. What 32 characters, you ask? The [Character Sets](#CharacterSets) section discusses the predefined characters available in `entropy-string` and the [Custom Characters](#CustomCharacters) section describes how you can use whatever characters you want. By default, `entropy-string` uses `charSet32` characters, so we don't need to pass that parameter into `new Random()`.

```js

const random = new Random()

const bits = Entropy.bits(10000, 1e6)

As another example, let's assume we need to ensure the names of a handful of items are unique. Let's say 30 items. And suppose we decide we can live with a 1 in 100,000 probability of collision (we're just futzing with some coding ideas). Using the predefined provided hex characters:

```js

const random = new Random(charSet16)

const bits = Entropy.bits(30, 100000)

Suppose we have a more extreme need. We want less than a 1 in a trillion chance that 10 billion base 32 strings repeat. Let's see, our total (10 billion) is 10<sup>10</sup> and our risk (1 trillion) is 10<sup>12</sup>, so:

```js

const random = new Random()

const bits = Entropy.bits(1e10, 1e12)

Finally, let say we're generating session IDs. Since session IDs are ephemeral, we aren't interested in uniqueness per se, but in ensuring our IDs aren't predictable since we can't have the bad guys guessing a valid session ID. In this case, we're using entropy as a measure of unpredictability of the IDs. Rather than calculate our entropy, we declare it as 128 bits (since we read on the OWASP web site that session IDs should be 128 bits).

```js

const random = new Random()

const string = random.string(128)

Since session ID are such an important need, `entropy-string` provides a convenience function for generating them:

```js

const random = new Random(charSet64)

const string = random.sessionID()

As we've seen in the previous sections, `entropy-string` provides predefined character sets. Let's see what's under the hood.

```js

const chars = charSet64.chars()

```

Being able to easily generate random strings is great, but what if you want to specify your own characters. For example, suppose you want to visualize flipping a coin to produce entropy of 10 bits.

```js

const random = new Random(charSet2)

let flips = random.string(10)

As another example, we saw in [Character Sets](#CharacterSets) the predefined hex characters for `charSet16` are lowercase. Suppose you like uppercase hexadecimal letters instead.

```js

const random = new Random('0123456789ABCDEF')

const string = random.string(48)

The last option above will throw an `EntropyStringError` if the characters string isn't appropriate for creating a `CharSet`.

```js

try {

const random = new Random('123456')

Compare that to the `entropy-string` scheme. For the example above, slicing off 5 bits at a time requires a total of 80 bits (10 bytes). Creating the same strings as above, `entropy-string` uses 80 bits of randomness per string with no wasted bits. In general, the `entropy-string` scheme can waste up to 7 bits per string, but that's the worst case scenario and that's *per string*, not *per character*!

```js

const random = new Random()

let string = random.string(80)

Suppose we want a string capable of 30 bits of entropy using 32 characters. We pass in 4 bytes to cover the 30 bits needed to generate six base 32 characters:

```js

const random = new Random()

const bytes = Buffer.from([250, 200, 150, 100])

```js

const random = new Random()

const bits = Entropy.bits(1e6,1e9)

var _createClass3 = _interopRequireDefault(_createClass2);

var CharSet = function () {

function CharSet(chars) {

throw new Error('Invalid chars: Must be string');

}

var length = chars.length;

if (![2, 4, 8, 16, 32, 64].includes(length)) {

throw new Error('Invalid char count: must be one of 2,4,8,16,32,64');

}

var bitsPerChar = Math.floor((0, _log2.default)(length));

// Ensure no repeated characters

var c = chars.charAt(i);

if (c === chars.charAt(j)) {

throw new Error('Characters not unique');

}

chars: chars,

bitsPerChar: bitsPerChar,

length: length,

};

propMap.set(this, privProps);

}

value: function length() {

return propMap.get(this).length;

}

}, {

key: 'bytesNeeded',

value: function bytesNeeded(entropyBits) {

exports.default = CharSet;

var charSet64 = exports.charSet64 = new CharSet('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_');

var charSet32 = exports.charSet32 = new CharSet('2346789bdfghjmnpqrtBDFGHJLMNPQRT');

var charSet16 = exports.charSet16 = new CharSet('0123456789abcdef');