You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
272 lines
7.8 KiB
272 lines
7.8 KiB
// uuid.js |
|
// |
|
// Copyright (c) 2010-2012 Robert Kieffer |
|
// MIT License - http://opensource.org/licenses/mit-license.php |
|
|
|
/*global window, require, define */ |
|
(function(_window) { |
|
'use strict'; |
|
|
|
// Unique ID creation requires a high quality random # generator. We feature |
|
// detect to determine the best RNG source, normalizing to a function that |
|
// returns 128-bits of randomness, since that's what's usually required |
|
var _rng, _mathRNG, _nodeRNG, _whatwgRNG, _previousRoot; |
|
|
|
function setupBrowser() { |
|
// Allow for MSIE11 msCrypto |
|
var _crypto = _window.crypto || _window.msCrypto; |
|
|
|
if (!_rng && _crypto && _crypto.getRandomValues) { |
|
// WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto |
|
// |
|
// Moderately fast, high quality |
|
try { |
|
var _rnds8 = new Uint8Array(16); |
|
_whatwgRNG = _rng = function whatwgRNG() { |
|
_crypto.getRandomValues(_rnds8); |
|
return _rnds8; |
|
}; |
|
_rng(); |
|
} catch(e) {} |
|
} |
|
|
|
if (!_rng) { |
|
// Math.random()-based (RNG) |
|
// |
|
// If all else fails, use Math.random(). It's fast, but is of unspecified |
|
// quality. |
|
var _rnds = new Array(16); |
|
_mathRNG = _rng = function() { |
|
for (var i = 0, r; i < 16; i++) { |
|
if ((i & 0x03) === 0) { r = Math.random() * 0x100000000; } |
|
_rnds[i] = r >>> ((i & 0x03) << 3) & 0xff; |
|
} |
|
|
|
return _rnds; |
|
}; |
|
if ('undefined' !== typeof console && console.warn) { |
|
console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()"); |
|
} |
|
} |
|
} |
|
|
|
function setupNode() { |
|
// Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html |
|
// |
|
// Moderately fast, high quality |
|
if ('function' === typeof require) { |
|
try { |
|
var _rb = require('crypto').randomBytes; |
|
_nodeRNG = _rng = _rb && function() {return _rb(16);}; |
|
_rng(); |
|
} catch(e) {} |
|
} |
|
} |
|
|
|
if (_window) { |
|
setupBrowser(); |
|
} else { |
|
setupNode(); |
|
} |
|
|
|
// Buffer class to use |
|
var BufferClass = ('function' === typeof Buffer) ? Buffer : Array; |
|
|
|
// Maps for number <-> hex string conversion |
|
var _byteToHex = []; |
|
var _hexToByte = {}; |
|
for (var i = 0; i < 256; i++) { |
|
_byteToHex[i] = (i + 0x100).toString(16).substr(1); |
|
_hexToByte[_byteToHex[i]] = i; |
|
} |
|
|
|
// **`parse()` - Parse a UUID into it's component bytes** |
|
function parse(s, buf, offset) { |
|
var i = (buf && offset) || 0, ii = 0; |
|
|
|
buf = buf || []; |
|
s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) { |
|
if (ii < 16) { // Don't overflow! |
|
buf[i + ii++] = _hexToByte[oct]; |
|
} |
|
}); |
|
|
|
// Zero out remaining bytes if string was short |
|
while (ii < 16) { |
|
buf[i + ii++] = 0; |
|
} |
|
|
|
return buf; |
|
} |
|
|
|
// **`unparse()` - Convert UUID byte array (ala parse()) into a string** |
|
function unparse(buf, offset) { |
|
var i = offset || 0, bth = _byteToHex; |
|
return bth[buf[i++]] + bth[buf[i++]] + |
|
bth[buf[i++]] + bth[buf[i++]] + '-' + |
|
bth[buf[i++]] + bth[buf[i++]] + '-' + |
|
bth[buf[i++]] + bth[buf[i++]] + '-' + |
|
bth[buf[i++]] + bth[buf[i++]] + '-' + |
|
bth[buf[i++]] + bth[buf[i++]] + |
|
bth[buf[i++]] + bth[buf[i++]] + |
|
bth[buf[i++]] + bth[buf[i++]]; |
|
} |
|
|
|
// **`v1()` - Generate time-based UUID** |
|
// |
|
// Inspired by https://github.com/LiosK/UUID.js |
|
// and http://docs.python.org/library/uuid.html |
|
|
|
// random #'s we need to init node and clockseq |
|
var _seedBytes = _rng(); |
|
|
|
// Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1) |
|
var _nodeId = [ |
|
_seedBytes[0] | 0x01, |
|
_seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5] |
|
]; |
|
|
|
// Per 4.2.2, randomize (14 bit) clockseq |
|
var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff; |
|
|
|
// Previous uuid creation time |
|
var _lastMSecs = 0, _lastNSecs = 0; |
|
|
|
// See https://github.com/broofa/node-uuid for API details |
|
function v1(options, buf, offset) { |
|
var i = buf && offset || 0; |
|
var b = buf || []; |
|
|
|
options = options || {}; |
|
|
|
var clockseq = (options.clockseq != null) ? options.clockseq : _clockseq; |
|
|
|
// UUID timestamps are 100 nano-second units since the Gregorian epoch, |
|
// (1582-10-15 00:00). JSNumbers aren't precise enough for this, so |
|
// time is handled internally as 'msecs' (integer milliseconds) and 'nsecs' |
|
// (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00. |
|
var msecs = (options.msecs != null) ? options.msecs : new Date().getTime(); |
|
|
|
// Per 4.2.1.2, use count of uuid's generated during the current clock |
|
// cycle to simulate higher resolution clock |
|
var nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1; |
|
|
|
// Time since last uuid creation (in msecs) |
|
var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000; |
|
|
|
// Per 4.2.1.2, Bump clockseq on clock regression |
|
if (dt < 0 && options.clockseq == null) { |
|
clockseq = clockseq + 1 & 0x3fff; |
|
} |
|
|
|
// Reset nsecs if clock regresses (new clockseq) or we've moved onto a new |
|
// time interval |
|
if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) { |
|
nsecs = 0; |
|
} |
|
|
|
// Per 4.2.1.2 Throw error if too many uuids are requested |
|
if (nsecs >= 10000) { |
|
throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec'); |
|
} |
|
|
|
_lastMSecs = msecs; |
|
_lastNSecs = nsecs; |
|
_clockseq = clockseq; |
|
|
|
// Per 4.1.4 - Convert from unix epoch to Gregorian epoch |
|
msecs += 12219292800000; |
|
|
|
// `time_low` |
|
var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000; |
|
b[i++] = tl >>> 24 & 0xff; |
|
b[i++] = tl >>> 16 & 0xff; |
|
b[i++] = tl >>> 8 & 0xff; |
|
b[i++] = tl & 0xff; |
|
|
|
// `time_mid` |
|
var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff; |
|
b[i++] = tmh >>> 8 & 0xff; |
|
b[i++] = tmh & 0xff; |
|
|
|
// `time_high_and_version` |
|
b[i++] = tmh >>> 24 & 0xf | 0x10; // include version |
|
b[i++] = tmh >>> 16 & 0xff; |
|
|
|
// `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant) |
|
b[i++] = clockseq >>> 8 | 0x80; |
|
|
|
// `clock_seq_low` |
|
b[i++] = clockseq & 0xff; |
|
|
|
// `node` |
|
var node = options.node || _nodeId; |
|
for (var n = 0; n < 6; n++) { |
|
b[i + n] = node[n]; |
|
} |
|
|
|
return buf ? buf : unparse(b); |
|
} |
|
|
|
// **`v4()` - Generate random UUID** |
|
|
|
// See https://github.com/broofa/node-uuid for API details |
|
function v4(options, buf, offset) { |
|
// Deprecated - 'format' argument, as supported in v1.2 |
|
var i = buf && offset || 0; |
|
|
|
if (typeof(options) === 'string') { |
|
buf = (options === 'binary') ? new BufferClass(16) : null; |
|
options = null; |
|
} |
|
options = options || {}; |
|
|
|
var rnds = options.random || (options.rng || _rng)(); |
|
|
|
// Per 4.4, set bits for version and `clock_seq_hi_and_reserved` |
|
rnds[6] = (rnds[6] & 0x0f) | 0x40; |
|
rnds[8] = (rnds[8] & 0x3f) | 0x80; |
|
|
|
// Copy bytes to buffer, if provided |
|
if (buf) { |
|
for (var ii = 0; ii < 16; ii++) { |
|
buf[i + ii] = rnds[ii]; |
|
} |
|
} |
|
|
|
return buf || unparse(rnds); |
|
} |
|
|
|
// Export public API |
|
var uuid = v4; |
|
uuid.v1 = v1; |
|
uuid.v4 = v4; |
|
uuid.parse = parse; |
|
uuid.unparse = unparse; |
|
uuid.BufferClass = BufferClass; |
|
uuid._rng = _rng; |
|
uuid._mathRNG = _mathRNG; |
|
uuid._nodeRNG = _nodeRNG; |
|
uuid._whatwgRNG = _whatwgRNG; |
|
|
|
if (('undefined' !== typeof module) && module.exports) { |
|
// Publish as node.js module |
|
module.exports = uuid; |
|
} else if (typeof define === 'function' && define.amd) { |
|
// Publish as AMD module |
|
define(function() {return uuid;}); |
|
|
|
|
|
} else { |
|
// Publish as global (in browsers) |
|
_previousRoot = _window.uuid; |
|
|
|
// **`noConflict()` - (browser only) to reset global 'uuid' var** |
|
uuid.noConflict = function() { |
|
_window.uuid = _previousRoot; |
|
return uuid; |
|
}; |
|
|
|
_window.uuid = uuid; |
|
} |
|
})('undefined' !== typeof window ? window : null);
|
|
|