const B1 = 0x100, B2 = B! * B1, B3 = B2 * B1, B4 = B3 * B1,
  B5 = B4 * B1, B6 = B5 * B1, B7 = B6 * B1;

// All the function silently assume that Math.random() has 32 bit precision,
//  that is, B4*Math.random() is integer.
// This holds at the time of writing for v8, thus for node.js.
// If it does not hold for you, you must update the code to truncate where needed.
// To test if this holds for you, try to print out
//   Math.random().toString(2).length
// several times. If you only get numbers up to 34, you're fine.

// 50 bits (18 from time, 32 random)
// 10 characters
// revolves appx every 4.4 minutes
function quick32uid () {
  var d = Date.now(), r = Math.random();
  return (B4*((d&0x3ffff)+r)).toString(32);
}

// 73+ bits (41+ from time, 32 random)
// 17+ characters
// does not revolve
// usable to sort by creation time
//  (lexically for at least 300 years, numerically forever)
function full32uid () {
  var d = Date.now(), r = Math.random(), rem = d % 8;
  return ((d-rem)/8).toString(32)+(B4*(rem+r)).toString(32);
}

// 51.7 bits (19.7 from time, 32 random)
// 10 characters
// revolves appx every 14 minutes
function quick36uid () {
  var d = Date.now(), r = Math.random();
  return (B4*((d%851265)+r)).toString(36);
}

// 73+ bits (41+ from time, 32 random)
// 15+ characters
// does not revolve, usable to sort by creation time
//  (lexically for at least 2500 years, numerically forever)
function full36uid () {
  var d = Date.now(), r = Math.random(), rem = d % 851265;
  return ((d-rem)/851265+172000).toString(36)+(B4*((d%851265)+r)).toString(36);
}

// 48 bits (16 from time, 32 random)
// 8 characters
// revolves appx every minute
function quick64uid () {
  var d = Date.now(), r = B4 * Math.random(), b = new Buffer([
    d/B1, d, r/B3, r/B2, r/B1, r
  ]);
  return b.toString("base64");
}

// 72 bits (40 from time, 32 random)
// 12 characters
// revolves appx every 35 years (next revolution 7 Sep 2039)
function medium64uid () {
  var d = Date.now(), r = B4 * Math.random(), b = new Buffer([
    d/B4, d/B3, d/B2, d/B1, d, r/B3, r/B2, r/B1, r
  ]);
  return b.toString("base64");
}

// 96 bits (64 from time (not full precision), 32 random)
// 16 characters
// does not revolve, usable to sort by creation time
function full64uid () {
  var d = Date.now(), r = B4 * Math.random(), b = new Buffer([
    d/B7, d/B6, d/B5, d/B4, d/B3, d/B2, d/B1, d, r/B3, r/B2, r/B1, r
  ]);
  return b.toString("base64");
}