372 lines
9.2 KiB
JavaScript
372 lines
9.2 KiB
JavaScript
(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
|
|
'use strict';
|
|
module.exports = require('./lib/index');
|
|
window.shortid = module.exports;
|
|
|
|
},{"./lib/index":5}],2:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var randomFromSeed = require('./random/random-from-seed');
|
|
|
|
var ORIGINAL = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-';
|
|
var alphabet;
|
|
var previousSeed;
|
|
|
|
var shuffled;
|
|
|
|
function reset() {
|
|
shuffled = false;
|
|
}
|
|
|
|
function setCharacters(_alphabet_) {
|
|
if (!_alphabet_) {
|
|
if (alphabet !== ORIGINAL) {
|
|
alphabet = ORIGINAL;
|
|
reset();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (_alphabet_ === alphabet) {
|
|
return;
|
|
}
|
|
|
|
if (_alphabet_.length !== ORIGINAL.length) {
|
|
throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. You submitted ' + _alphabet_.length + ' characters: ' + _alphabet_);
|
|
}
|
|
|
|
var unique = _alphabet_.split('').filter(function(item, ind, arr){
|
|
return ind !== arr.lastIndexOf(item);
|
|
});
|
|
|
|
if (unique.length) {
|
|
throw new Error('Custom alphabet for shortid must be ' + ORIGINAL.length + ' unique characters. These characters were not unique: ' + unique.join(', '));
|
|
}
|
|
|
|
alphabet = _alphabet_;
|
|
reset();
|
|
}
|
|
|
|
function characters(_alphabet_) {
|
|
setCharacters(_alphabet_);
|
|
return alphabet;
|
|
}
|
|
|
|
function setSeed(seed) {
|
|
randomFromSeed.seed(seed);
|
|
if (previousSeed !== seed) {
|
|
reset();
|
|
previousSeed = seed;
|
|
}
|
|
}
|
|
|
|
function shuffle() {
|
|
if (!alphabet) {
|
|
setCharacters(ORIGINAL);
|
|
}
|
|
|
|
var sourceArray = alphabet.split('');
|
|
var targetArray = [];
|
|
var r = randomFromSeed.nextValue();
|
|
var characterIndex;
|
|
|
|
while (sourceArray.length > 0) {
|
|
r = randomFromSeed.nextValue();
|
|
characterIndex = Math.floor(r * sourceArray.length);
|
|
targetArray.push(sourceArray.splice(characterIndex, 1)[0]);
|
|
}
|
|
return targetArray.join('');
|
|
}
|
|
|
|
function getShuffled() {
|
|
if (shuffled) {
|
|
return shuffled;
|
|
}
|
|
shuffled = shuffle();
|
|
return shuffled;
|
|
}
|
|
|
|
/**
|
|
* lookup shuffled letter
|
|
* @param index
|
|
* @returns {string}
|
|
*/
|
|
function lookup(index) {
|
|
var alphabetShuffled = getShuffled();
|
|
return alphabetShuffled[index];
|
|
}
|
|
|
|
function get () {
|
|
return alphabet || ORIGINAL;
|
|
}
|
|
|
|
module.exports = {
|
|
get: get,
|
|
characters: characters,
|
|
seed: setSeed,
|
|
lookup: lookup,
|
|
shuffled: getShuffled
|
|
};
|
|
|
|
},{"./random/random-from-seed":8}],3:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var generate = require('./generate');
|
|
var alphabet = require('./alphabet');
|
|
|
|
// Ignore all milliseconds before a certain time to reduce the size of the date entropy without sacrificing uniqueness.
|
|
// This number should be updated every year or so to keep the generated id short.
|
|
// To regenerate `new Date() - 0` and bump the version. Always bump the version!
|
|
var REDUCE_TIME = 1567752802062;
|
|
|
|
// don't change unless we change the algos or REDUCE_TIME
|
|
// must be an integer and less than 16
|
|
var version = 7;
|
|
|
|
// Counter is used when shortid is called multiple times in one second.
|
|
var counter;
|
|
|
|
// Remember the last time shortid was called in case counter is needed.
|
|
var previousSeconds;
|
|
|
|
/**
|
|
* Generate unique id
|
|
* Returns string id
|
|
*/
|
|
function build(clusterWorkerId) {
|
|
var str = '';
|
|
|
|
var seconds = Math.floor((Date.now() - REDUCE_TIME) * 0.001);
|
|
|
|
if (seconds === previousSeconds) {
|
|
counter++;
|
|
} else {
|
|
counter = 0;
|
|
previousSeconds = seconds;
|
|
}
|
|
|
|
str = str + generate(version);
|
|
str = str + generate(clusterWorkerId);
|
|
if (counter > 0) {
|
|
str = str + generate(counter);
|
|
}
|
|
str = str + generate(seconds);
|
|
return str;
|
|
}
|
|
|
|
module.exports = build;
|
|
|
|
},{"./alphabet":2,"./generate":4}],4:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var alphabet = require('./alphabet');
|
|
var random = require('./random/random-byte');
|
|
var format = require('nanoid/format');
|
|
|
|
function generate(number) {
|
|
var loopCounter = 0;
|
|
var done;
|
|
|
|
var str = '';
|
|
|
|
while (!done) {
|
|
str = str + format(random, alphabet.get(), 1);
|
|
done = number < (Math.pow(16, loopCounter + 1 ) );
|
|
loopCounter++;
|
|
}
|
|
return str;
|
|
}
|
|
|
|
module.exports = generate;
|
|
|
|
},{"./alphabet":2,"./random/random-byte":7,"nanoid/format":10}],5:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var alphabet = require('./alphabet');
|
|
var build = require('./build');
|
|
var isValid = require('./is-valid');
|
|
|
|
// if you are using cluster or multiple servers use this to make each instance
|
|
// has a unique value for worker
|
|
// Note: I don't know if this is automatically set when using third
|
|
// party cluster solutions such as pm2.
|
|
var clusterWorkerId = require('./util/cluster-worker-id') || 0;
|
|
|
|
/**
|
|
* Set the seed.
|
|
* Highly recommended if you don't want people to try to figure out your id schema.
|
|
* exposed as shortid.seed(int)
|
|
* @param seed Integer value to seed the random alphabet. ALWAYS USE THE SAME SEED or you might get overlaps.
|
|
*/
|
|
function seed(seedValue) {
|
|
alphabet.seed(seedValue);
|
|
return module.exports;
|
|
}
|
|
|
|
/**
|
|
* Set the cluster worker or machine id
|
|
* exposed as shortid.worker(int)
|
|
* @param workerId worker must be positive integer. Number less than 16 is recommended.
|
|
* returns shortid module so it can be chained.
|
|
*/
|
|
function worker(workerId) {
|
|
clusterWorkerId = workerId;
|
|
return module.exports;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* sets new characters to use in the alphabet
|
|
* returns the shuffled alphabet
|
|
*/
|
|
function characters(newCharacters) {
|
|
if (newCharacters !== undefined) {
|
|
alphabet.characters(newCharacters);
|
|
}
|
|
|
|
return alphabet.shuffled();
|
|
}
|
|
|
|
/**
|
|
* Generate unique id
|
|
* Returns string id
|
|
*/
|
|
function generate() {
|
|
return build(clusterWorkerId);
|
|
}
|
|
|
|
// Export all other functions as properties of the generate function
|
|
module.exports = generate;
|
|
module.exports.generate = generate;
|
|
module.exports.seed = seed;
|
|
module.exports.worker = worker;
|
|
module.exports.characters = characters;
|
|
module.exports.isValid = isValid;
|
|
|
|
},{"./alphabet":2,"./build":3,"./is-valid":6,"./util/cluster-worker-id":9}],6:[function(require,module,exports){
|
|
'use strict';
|
|
var alphabet = require('./alphabet');
|
|
|
|
function isShortId(id) {
|
|
if (!id || typeof id !== 'string' || id.length < 6 ) {
|
|
return false;
|
|
}
|
|
|
|
var nonAlphabetic = new RegExp('[^' +
|
|
alphabet.get().replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&') +
|
|
']');
|
|
return !nonAlphabetic.test(id);
|
|
}
|
|
|
|
module.exports = isShortId;
|
|
|
|
},{"./alphabet":2}],7:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
var crypto = typeof window === 'object' && (window.crypto || window.msCrypto); // IE 11 uses window.msCrypto
|
|
|
|
var randomByte;
|
|
|
|
if (!crypto || !crypto.getRandomValues) {
|
|
randomByte = function(size) {
|
|
var bytes = [];
|
|
for (var i = 0; i < size; i++) {
|
|
bytes.push(Math.floor(Math.random() * 256));
|
|
}
|
|
return bytes;
|
|
};
|
|
} else {
|
|
randomByte = function(size) {
|
|
return crypto.getRandomValues(new Uint8Array(size));
|
|
};
|
|
}
|
|
|
|
module.exports = randomByte;
|
|
|
|
},{}],8:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
// Found this seed-based random generator somewhere
|
|
// Based on The Central Randomizer 1.3 (C) 1997 by Paul Houle (houle@msc.cornell.edu)
|
|
|
|
var seed = 1;
|
|
|
|
/**
|
|
* return a random number based on a seed
|
|
* @param seed
|
|
* @returns {number}
|
|
*/
|
|
function getNextValue() {
|
|
seed = (seed * 9301 + 49297) % 233280;
|
|
return seed/(233280.0);
|
|
}
|
|
|
|
function setSeed(_seed_) {
|
|
seed = _seed_;
|
|
}
|
|
|
|
module.exports = {
|
|
nextValue: getNextValue,
|
|
seed: setSeed
|
|
};
|
|
|
|
},{}],9:[function(require,module,exports){
|
|
'use strict';
|
|
|
|
module.exports = 0;
|
|
|
|
},{}],10:[function(require,module,exports){
|
|
/**
|
|
* Secure random string generator with custom alphabet.
|
|
*
|
|
* Alphabet must contain 256 symbols or less. Otherwise, the generator
|
|
* will not be secure.
|
|
*
|
|
* @param {generator} random The random bytes generator.
|
|
* @param {string} alphabet Symbols to be used in new random string.
|
|
* @param {size} size The number of symbols in new random string.
|
|
*
|
|
* @return {string} Random string.
|
|
*
|
|
* @example
|
|
* const format = require('nanoid/format')
|
|
*
|
|
* function random (size) {
|
|
* const result = []
|
|
* for (let i = 0; i < size; i++) {
|
|
* result.push(randomByte())
|
|
* }
|
|
* return result
|
|
* }
|
|
*
|
|
* format(random, "abcdef", 5) //=> "fbaef"
|
|
*
|
|
* @name format
|
|
* @function
|
|
*/
|
|
module.exports = function (random, alphabet, size) {
|
|
var mask = (2 << Math.log(alphabet.length - 1) / Math.LN2) - 1
|
|
var step = Math.ceil(1.6 * mask * size / alphabet.length)
|
|
size = +size
|
|
|
|
var id = ''
|
|
while (true) {
|
|
var bytes = random(step)
|
|
for (var i = 0; i < step; i++) {
|
|
var byte = bytes[i] & mask
|
|
if (alphabet[byte]) {
|
|
id += alphabet[byte]
|
|
if (id.length === size) return id
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @callback generator
|
|
* @param {number} bytes The number of bytes to generate.
|
|
* @return {number[]} Random bytes.
|
|
*/
|
|
|
|
},{}]},{},[1]);
|