(function () {

/* Imports */
var Meteor = Package.meteor.Meteor;
var _ = Package.underscore._;

/* Package-scope variables */
var Random;

(function () {

//////////////////////////////////////////////////////////////////////////////////////
//                                                                                  //
// packages/random/random.js                                                        //
//                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////
                                                                                    //
// We use cryptographically strong PRNGs (crypto.getRandomBytes() on the server,    // 1
// window.crypto.getRandomValues() in the browser) when available. If these         // 2
// PRNGs fail, we fall back to the Alea PRNG, which is not cryptographically        // 3
// strong, and we seed it with various sources such as the date, Math.random,       // 4
// and window size on the client.  When using crypto.getRandomValues(), our         // 5
// primitive is hexString(), from which we construct fraction(). When using         // 6
// window.crypto.getRandomValues() or alea, the primitive is fraction and we use    // 7
// that to construct hex string.                                                    // 8
                                                                                    // 9
if (Meteor.isServer)                                                                // 10
  var nodeCrypto = Npm.require('crypto');                                           // 11
                                                                                    // 12
// see http://baagoe.org/en/wiki/Better_random_numbers_for_javascript               // 13
// for a full discussion and Alea implementation.                                   // 14
var Alea = function () {                                                            // 15
  function Mash() {                                                                 // 16
    var n = 0xefc8249d;                                                             // 17
                                                                                    // 18
    var mash = function(data) {                                                     // 19
      data = data.toString();                                                       // 20
      for (var i = 0; i < data.length; i++) {                                       // 21
        n += data.charCodeAt(i);                                                    // 22
        var h = 0.02519603282416938 * n;                                            // 23
        n = h >>> 0;                                                                // 24
        h -= n;                                                                     // 25
        h *= n;                                                                     // 26
        n = h >>> 0;                                                                // 27
        h -= n;                                                                     // 28
        n += h * 0x100000000; // 2^32                                               // 29
      }                                                                             // 30
      return (n >>> 0) * 2.3283064365386963e-10; // 2^-32                           // 31
    };                                                                              // 32
                                                                                    // 33
    mash.version = 'Mash 0.9';                                                      // 34
    return mash;                                                                    // 35
  }                                                                                 // 36
                                                                                    // 37
  return (function (args) {                                                         // 38
    var s0 = 0;                                                                     // 39
    var s1 = 0;                                                                     // 40
    var s2 = 0;                                                                     // 41
    var c = 1;                                                                      // 42
                                                                                    // 43
    if (args.length == 0) {                                                         // 44
      args = [+new Date];                                                           // 45
    }                                                                               // 46
    var mash = Mash();                                                              // 47
    s0 = mash(' ');                                                                 // 48
    s1 = mash(' ');                                                                 // 49
    s2 = mash(' ');                                                                 // 50
                                                                                    // 51
    for (var i = 0; i < args.length; i++) {                                         // 52
      s0 -= mash(args[i]);                                                          // 53
      if (s0 < 0) {                                                                 // 54
        s0 += 1;                                                                    // 55
      }                                                                             // 56
      s1 -= mash(args[i]);                                                          // 57
      if (s1 < 0) {                                                                 // 58
        s1 += 1;                                                                    // 59
      }                                                                             // 60
      s2 -= mash(args[i]);                                                          // 61
      if (s2 < 0) {                                                                 // 62
        s2 += 1;                                                                    // 63
      }                                                                             // 64
    }                                                                               // 65
    mash = null;                                                                    // 66
                                                                                    // 67
    var random = function() {                                                       // 68
      var t = 2091639 * s0 + c * 2.3283064365386963e-10; // 2^-32                   // 69
      s0 = s1;                                                                      // 70
      s1 = s2;                                                                      // 71
      return s2 = t - (c = t | 0);                                                  // 72
    };                                                                              // 73
    random.uint32 = function() {                                                    // 74
      return random() * 0x100000000; // 2^32                                        // 75
    };                                                                              // 76
    random.fract53 = function() {                                                   // 77
      return random() +                                                             // 78
        (random() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53                // 79
    };                                                                              // 80
    random.version = 'Alea 0.9';                                                    // 81
    random.args = args;                                                             // 82
    return random;                                                                  // 83
                                                                                    // 84
  } (Array.prototype.slice.call(arguments)));                                       // 85
};                                                                                  // 86
                                                                                    // 87
var UNMISTAKABLE_CHARS = "23456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijkmnopqrstuvwxyz"; // 88
var BASE64_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" +         // 89
  "0123456789-_";                                                                   // 90
                                                                                    // 91
// If seeds are provided, then the alea PRNG will be used, since cryptographic      // 92
// PRNGs (Node crypto and window.crypto.getRandomValues) don't allow us to          // 93
// specify seeds. The caller is responsible for making sure to provide a seed       // 94
// for alea if a csprng is not available.                                           // 95
var RandomGenerator = function (seedArray) {                                        // 96
  var self = this;                                                                  // 97
  if (seedArray !== undefined)                                                      // 98
    self.alea = Alea.apply(null, seedArray);                                        // 99
};                                                                                  // 100
                                                                                    // 101
RandomGenerator.prototype.fraction = function () {                                  // 102
  var self = this;                                                                  // 103
  if (self.alea) {                                                                  // 104
    return self.alea();                                                             // 105
  } else if (nodeCrypto) {                                                          // 106
    var numerator = parseInt(self.hexString(8), 16);                                // 107
    return numerator * 2.3283064365386963e-10; // 2^-32                             // 108
  } else if (typeof window !== "undefined" && window.crypto &&                      // 109
             window.crypto.getRandomValues) {                                       // 110
    var array = new Uint32Array(1);                                                 // 111
    window.crypto.getRandomValues(array);                                           // 112
    return array[0] * 2.3283064365386963e-10; // 2^-32                              // 113
  } else {                                                                          // 114
    throw new Error('No random generator available');                               // 115
  }                                                                                 // 116
};                                                                                  // 117
                                                                                    // 118
RandomGenerator.prototype.hexString = function (digits) {                           // 119
  var self = this;                                                                  // 120
  if (nodeCrypto && ! self.alea) {                                                  // 121
    var numBytes = Math.ceil(digits / 2);                                           // 122
    var bytes;                                                                      // 123
    // Try to get cryptographically strong randomness. Fall back to                 // 124
    // non-cryptographically strong if not available.                               // 125
    try {                                                                           // 126
      bytes = nodeCrypto.randomBytes(numBytes);                                     // 127
    } catch (e) {                                                                   // 128
      // XXX should re-throw any error except insufficient entropy                  // 129
      bytes = nodeCrypto.pseudoRandomBytes(numBytes);                               // 130
    }                                                                               // 131
    var result = bytes.toString("hex");                                             // 132
    // If the number of digits is odd, we'll have generated an extra 4 bits         // 133
    // of randomness, so we need to trim the last digit.                            // 134
    return result.substring(0, digits);                                             // 135
  } else {                                                                          // 136
    var hexDigits = [];                                                             // 137
    for (var i = 0; i < digits; ++i) {                                              // 138
      hexDigits.push(self.choice("0123456789abcdef"));                              // 139
    }                                                                               // 140
    return hexDigits.join('');                                                      // 141
  }                                                                                 // 142
};                                                                                  // 143
                                                                                    // 144
RandomGenerator.prototype._randomString = function (charsCount,                     // 145
                                                    alphabet) {                     // 146
  var self = this;                                                                  // 147
  var digits = [];                                                                  // 148
  for (var i = 0; i < charsCount; i++) {                                            // 149
    digits[i] = self.choice(alphabet);                                              // 150
  }                                                                                 // 151
  return digits.join("");                                                           // 152
};                                                                                  // 153
                                                                                    // 154
RandomGenerator.prototype.id = function (charsCount) {                              // 155
  var self = this;                                                                  // 156
  // 17 characters is around 96 bits of entropy, which is the amount of             // 157
  // state in the Alea PRNG.                                                        // 158
  if (charsCount === undefined)                                                     // 159
    charsCount = 17;                                                                // 160
                                                                                    // 161
  return self._randomString(charsCount, UNMISTAKABLE_CHARS);                        // 162
};                                                                                  // 163
                                                                                    // 164
RandomGenerator.prototype.secret = function (charsCount) {                          // 165
  var self = this;                                                                  // 166
  // Default to 256 bits of entropy, or 43 characters at 6 bits per                 // 167
  // character.                                                                     // 168
  if (charsCount === undefined)                                                     // 169
    charsCount = 43;                                                                // 170
  return self._randomString(charsCount, BASE64_CHARS);                              // 171
};                                                                                  // 172
                                                                                    // 173
RandomGenerator.prototype.choice = function (arrayOrString) {                       // 174
  var index = Math.floor(this.fraction() * arrayOrString.length);                   // 175
  if (typeof arrayOrString === "string")                                            // 176
    return arrayOrString.substr(index, 1);                                          // 177
  else                                                                              // 178
    return arrayOrString[index];                                                    // 179
};                                                                                  // 180
                                                                                    // 181
// instantiate RNG.  Heuristically collect entropy from various sources when a      // 182
// cryptographic PRNG isn't available.                                              // 183
                                                                                    // 184
// client sources                                                                   // 185
var height = (typeof window !== 'undefined' && window.innerHeight) ||               // 186
      (typeof document !== 'undefined'                                              // 187
       && document.documentElement                                                  // 188
       && document.documentElement.clientHeight) ||                                 // 189
      (typeof document !== 'undefined'                                              // 190
       && document.body                                                             // 191
       && document.body.clientHeight) ||                                            // 192
      1;                                                                            // 193
                                                                                    // 194
var width = (typeof window !== 'undefined' && window.innerWidth) ||                 // 195
      (typeof document !== 'undefined'                                              // 196
       && document.documentElement                                                  // 197
       && document.documentElement.clientWidth) ||                                  // 198
      (typeof document !== 'undefined'                                              // 199
       && document.body                                                             // 200
       && document.body.clientWidth) ||                                             // 201
      1;                                                                            // 202
                                                                                    // 203
var agent = (typeof navigator !== 'undefined' && navigator.userAgent) || "";        // 204
                                                                                    // 205
if (nodeCrypto ||                                                                   // 206
    (typeof window !== "undefined" &&                                               // 207
     window.crypto && window.crypto.getRandomValues))                               // 208
  Random = new RandomGenerator();                                                   // 209
else                                                                                // 210
  Random = new RandomGenerator([new Date(), height, width, agent, Math.random()]);  // 211
                                                                                    // 212
Random.createWithSeeds = function () {                                              // 213
  if (arguments.length === 0) {                                                     // 214
    throw new Error('No seeds were provided');                                      // 215
  }                                                                                 // 216
  return new RandomGenerator(arguments);                                            // 217
};                                                                                  // 218
                                                                                    // 219
//////////////////////////////////////////////////////////////////////////////////////

}).call(this);






(function () {

//////////////////////////////////////////////////////////////////////////////////////
//                                                                                  //
// packages/random/deprecated.js                                                    //
//                                                                                  //
//////////////////////////////////////////////////////////////////////////////////////
                                                                                    //
// Before this package existed, we used to use this Meteor.uuid()                   // 1
// implementing the RFC 4122 v4 UUID. It is no longer documented                    // 2
// and will go away.                                                                // 3
// XXX COMPAT WITH 0.5.6                                                            // 4
Meteor.uuid = function () {                                                         // 5
  var HEX_DIGITS = "0123456789abcdef";                                              // 6
  var s = [];                                                                       // 7
  for (var i = 0; i < 36; i++) {                                                    // 8
    s[i] = Random.choice(HEX_DIGITS);                                               // 9
  }                                                                                 // 10
  s[14] = "4";                                                                      // 11
  s[19] = HEX_DIGITS.substr((parseInt(s[19],16) & 0x3) | 0x8, 1);                   // 12
  s[8] = s[13] = s[18] = s[23] = "-";                                               // 13
                                                                                    // 14
  var uuid = s.join("");                                                            // 15
  return uuid;                                                                      // 16
};                                                                                  // 17
                                                                                    // 18
//////////////////////////////////////////////////////////////////////////////////////

}).call(this);


/* Exports */
if (typeof Package === 'undefined') Package = {};
Package.random = {
  Random: Random
};

})();

//# sourceMappingURL=random.js.map