@tier0/node-red-contrib-opcda-client 1.0.5 → 1.0.7

package/node_modules/random/dist/random.js

@@ -0,0 +1,529 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RNGFactory = exports.RNG = undefined;
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _owLite = require('ow-lite');
+
+var _owLite2 = _interopRequireDefault(_owLite);
+
+var _rng = require('./rng');
+
+var _rng2 = _interopRequireDefault(_rng);
+
+var _rngFactory = require('./rng-factory');
+
+var _rngFactory2 = _interopRequireDefault(_rngFactory);
+
+var _uniform2 = require('./distributions/uniform');
+
+var _uniform3 = _interopRequireDefault(_uniform2);
+
+var _uniformInt2 = require('./distributions/uniform-int');
+
+var _uniformInt3 = _interopRequireDefault(_uniformInt2);
+
+var _uniformBoolean2 = require('./distributions/uniform-boolean');
+
+var _uniformBoolean3 = _interopRequireDefault(_uniformBoolean2);
+
+var _normal2 = require('./distributions/normal');
+
+var _normal3 = _interopRequireDefault(_normal2);
+
+var _logNormal2 = require('./distributions/log-normal');
+
+var _logNormal3 = _interopRequireDefault(_logNormal2);
+
+var _bernoulli2 = require('./distributions/bernoulli');
+
+var _bernoulli3 = _interopRequireDefault(_bernoulli2);
+
+var _binomial2 = require('./distributions/binomial');
+
+var _binomial3 = _interopRequireDefault(_binomial2);
+
+var _geometric2 = require('./distributions/geometric');
+
+var _geometric3 = _interopRequireDefault(_geometric2);
+
+var _poisson2 = require('./distributions/poisson');
+
+var _poisson3 = _interopRequireDefault(_poisson2);
+
+var _exponential2 = require('./distributions/exponential');
+
+var _exponential3 = _interopRequireDefault(_exponential2);
+
+var _irwinHall2 = require('./distributions/irwin-hall');
+
+var _irwinHall3 = _interopRequireDefault(_irwinHall2);
+
+var _bates2 = require('./distributions/bates');
+
+var _bates3 = _interopRequireDefault(_bates2);
+
+var _pareto2 = require('./distributions/pareto');
+
+var _pareto3 = _interopRequireDefault(_pareto2);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+exports.RNG = _rng2.default;
+exports.RNGFactory = _rngFactory2.default;
+
+/**
+ * Seedable random number generator supporting many common distributions.
+ *
+ * Defaults to Math.random as its underlying pseudorandom number generator.
+ *
+ * @name Random
+ * @class
+ *
+ * @param {RNG|function} [rng=Math.random] - Underlying pseudorandom number generator.
+ */
+
+var Random = function () {
+  function Random(rng) {
+    _classCallCheck(this, Random);
+
+    if (rng) (0, _owLite2.default)(rng, _owLite2.default.object.instanceOf(_rng2.default));
+
+    this._cache = {};
+    this.use(rng);
+  }
+
+  /**
+   * @member {RNG} Underlying pseudo-random number generator
+   */
+
+
+  _createClass(Random, [{
+    key: 'clone',
+
+
+    /**
+     * Creates a new `Random` instance, optionally specifying parameters to
+     * set a new seed.
+     *
+     * @see RNG.clone
+     *
+     * @param {string} [seed] - Optional seed for new RNG.
+     * @param {object} [opts] - Optional config for new RNG options.
+     * @return {Random}
+     */
+    value: function clone() {
+      if (arguments.length) {
+        return new Random(_rngFactory2.default.apply(undefined, arguments));
+      } else {
+        return new Random(this.rng.clone());
+      }
+    }
+
+    /**
+     * Sets the underlying pseudorandom number generator used via
+     * either an instance of `seedrandom`, a custom instance of RNG
+     * (for PRNG plugins), or a string specifying the PRNG to use
+     * along with an optional `seed` and `opts` to initialize the
+     * RNG.
+     *
+     * @example
+     * const random = require('random')
+     *
+     * random.use('example_seedrandom_string')
+     * // or
+     * random.use(seedrandom('kittens'))
+     * // or
+     * random.use(Math.random)
+     *
+     * @param {...*} args
+     */
+
+  }, {
+    key: 'use',
+    value: function use() {
+      this._rng = _rngFactory2.default.apply(undefined, arguments);
+    }
+
+    /**
+     * Patches `Math.random` with this Random instance's PRNG.
+     */
+
+  }, {
+    key: 'patch',
+    value: function patch() {
+      if (this._patch) {
+        throw new Error('Math.random already patched');
+      }
+
+      this._patch = Math.random;
+      Math.random = this.uniform();
+    }
+
+    /**
+     * Restores a previously patched `Math.random` to its original value.
+     */
+
+  }, {
+    key: 'unpatch',
+    value: function unpatch() {
+      if (this._patch) {
+        Math.random = this._patch;
+        delete this._patch;
+      }
+    }
+
+    // --------------------------------------------------------------------------
+    // Uniform utility functions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Convenience wrapper around `this.rng.next()`
+     *
+     * Returns a floating point number in [0, 1).
+     *
+     * @return {number}
+     */
+
+  }, {
+    key: 'next',
+    value: function next() {
+      return this._rng.next();
+    }
+
+    /**
+     * Samples a uniform random floating point number, optionally specifying
+     * lower and upper bounds.
+     *
+     * Convence wrapper around `random.uniform()`
+     *
+     * @param {number} [min=0] - Lower bound (float, inclusive)
+     * @param {number} [max=1] - Upper bound (float, exclusive)
+     * @return {number}
+     */
+
+  }, {
+    key: 'float',
+    value: function float(min, max) {
+      return this.uniform(min, max)();
+    }
+
+    /**
+     * Samples a uniform random integer, optionally specifying lower and upper
+     * bounds.
+     *
+     * Convence wrapper around `random.uniformInt()`
+     *
+     * @param {number} [min=0] - Lower bound (integer, inclusive)
+     * @param {number} [max=1] - Upper bound (integer, inclusive)
+     * @return {number}
+     */
+
+  }, {
+    key: 'int',
+    value: function int(min, max) {
+      return this.uniformInt(min, max)();
+    }
+
+    /**
+     * Samples a uniform random integer, optionally specifying lower and upper
+     * bounds.
+     *
+     * Convence wrapper around `random.uniformInt()`
+     *
+     * @alias `random.int`
+     *
+     * @param {number} [min=0] - Lower bound (integer, inclusive)
+     * @param {number} [max=1] - Upper bound (integer, inclusive)
+     * @return {number}
+     */
+
+  }, {
+    key: 'integer',
+    value: function integer(min, max) {
+      return this.uniformInt(min, max)();
+    }
+
+    /**
+     * Samples a uniform random boolean value.
+     *
+     * Convence wrapper around `random.uniformBoolean()`
+     *
+     * @alias `random.boolean`
+     *
+     * @return {boolean}
+     */
+
+  }, {
+    key: 'bool',
+    value: function bool() {
+      return this.uniformBoolean()();
+    }
+
+    /**
+     * Samples a uniform random boolean value.
+     *
+     * Convence wrapper around `random.uniformBoolean()`
+     *
+     * @return {boolean}
+     */
+
+  }, {
+    key: 'boolean',
+    value: function boolean() {
+      return this.uniformBoolean()();
+    }
+
+    // --------------------------------------------------------------------------
+    // Uniform distributions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Generates a [Continuous uniform distribution](https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)).
+     *
+     * @param {number} [min=0] - Lower bound (float, inclusive)
+     * @param {number} [max=1] - Upper bound (float, exclusive)
+     * @return {function}
+     */
+
+  }, {
+    key: 'uniform',
+    value: function uniform(min, max) {
+      return this._memoize('uniform', _uniform3.default, min, max);
+    }
+
+    /**
+     * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution).
+     *
+     * @param {number} [min=0] - Lower bound (integer, inclusive)
+     * @param {number} [max=1] - Upper bound (integer, inclusive)
+     * @return {function}
+     */
+
+  }, {
+    key: 'uniformInt',
+    value: function uniformInt(min, max) {
+      return this._memoize('uniformInt', _uniformInt3.default, min, max);
+    }
+
+    /**
+     * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution),
+     * with two possible outcomes, `true` or `false.
+     *
+     * This method is analogous to flipping a coin.
+     *
+     * @return {function}
+     */
+
+  }, {
+    key: 'uniformBoolean',
+    value: function uniformBoolean() {
+      return this._memoize('uniformBoolean', _uniformBoolean3.default);
+    }
+
+    // --------------------------------------------------------------------------
+    // Normal distributions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Generates a [Normal distribution](https://en.wikipedia.org/wiki/Normal_distribution).
+     *
+     * @param {number} [mu=0] - Mean
+     * @param {number} [sigma=1] - Standard deviation
+     * @return {function}
+     */
+
+  }, {
+    key: 'normal',
+    value: function normal(mu, sigma) {
+      return (0, _normal3.default)(this, mu, sigma);
+    }
+
+    /**
+     * Generates a [Log-normal distribution](https://en.wikipedia.org/wiki/Log-normal_distribution).
+     *
+     * @param {number} [mu=0] - Mean of underlying normal distribution
+     * @param {number} [sigma=1] - Standard deviation of underlying normal distribution
+     * @return {function}
+     */
+
+  }, {
+    key: 'logNormal',
+    value: function logNormal(mu, sigma) {
+      return (0, _logNormal3.default)(this, mu, sigma);
+    }
+
+    // --------------------------------------------------------------------------
+    // Bernoulli distributions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Generates a [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution).
+     *
+     * @param {number} [p=0.5] - Success probability of each trial.
+     * @return {function}
+     */
+
+  }, {
+    key: 'bernoulli',
+    value: function bernoulli(p) {
+      return (0, _bernoulli3.default)(this, p);
+    }
+
+    /**
+     * Generates a [Binomial distribution](https://en.wikipedia.org/wiki/Binomial_distribution).
+     *
+     * @param {number} [n=1] - Number of trials.
+     * @param {number} [p=0.5] - Success probability of each trial.
+     * @return {function}
+     */
+
+  }, {
+    key: 'binomial',
+    value: function binomial(n, p) {
+      return (0, _binomial3.default)(this, n, p);
+    }
+
+    /**
+     * Generates a [Geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution).
+     *
+     * @param {number} [p=0.5] - Success probability of each trial.
+     * @return {function}
+     */
+
+  }, {
+    key: 'geometric',
+    value: function geometric(p) {
+      return (0, _geometric3.default)(this, p);
+    }
+
+    // --------------------------------------------------------------------------
+    // Poisson distributions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Generates a [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution).
+     *
+     * @param {number} [lambda=1] - Mean (lambda > 0)
+     * @return {function}
+     */
+
+  }, {
+    key: 'poisson',
+    value: function poisson(lambda) {
+      return (0, _poisson3.default)(this, lambda);
+    }
+
+    /**
+     * Generates an [Exponential distribution](https://en.wikipedia.org/wiki/Exponential_distribution).
+     *
+     * @param {number} [lambda=1] - Inverse mean (lambda > 0)
+     * @return {function}
+     */
+
+  }, {
+    key: 'exponential',
+    value: function exponential(lambda) {
+      return (0, _exponential3.default)(this, lambda);
+    }
+
+    // --------------------------------------------------------------------------
+    // Misc distributions
+    // --------------------------------------------------------------------------
+
+    /**
+     * Generates an [Irwin Hall distribution](https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution).
+     *
+     * @param {number} [n=1] - Number of uniform samples to sum (n >= 0)
+     * @return {function}
+     */
+
+  }, {
+    key: 'irwinHall',
+    value: function irwinHall(n) {
+      return (0, _irwinHall3.default)(this, n);
+    }
+
+    /**
+     * Generates a [Bates distribution](https://en.wikipedia.org/wiki/Bates_distribution).
+     *
+     * @param {number} [n=1] - Number of uniform samples to average (n >= 1)
+     * @return {function}
+     */
+
+  }, {
+    key: 'bates',
+    value: function bates(n) {
+      return (0, _bates3.default)(this, n);
+    }
+
+    /**
+     * Generates a [Pareto distribution](https://en.wikipedia.org/wiki/Pareto_distribution).
+     *
+     * @param {number} [alpha=1] - Alpha
+     * @return {function}
+     */
+
+  }, {
+    key: 'pareto',
+    value: function pareto(alpha) {
+      return (0, _pareto3.default)(this, alpha);
+    }
+
+    // --------------------------------------------------------------------------
+    // Internal
+    // --------------------------------------------------------------------------
+
+    /**
+     * Memoizes distributions to ensure they're only created when necessary.
+     *
+     * Returns a thunk which that returns independent, identically distributed
+     * samples from the specified distribution.
+     *
+     * @private
+     *
+     * @param {string} label - Name of distribution
+     * @param {function} getter - Function which generates a new distribution
+     * @param {...*} args - Distribution-specific arguments
+     *
+     * @return {function}
+     */
+
+  }, {
+    key: '_memoize',
+    value: function _memoize(label, getter) {
+      for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+
+      var key = '' + args.join(';');
+      var value = this._cache[label];
+
+      if (value === undefined || value.key !== key) {
+        value = { key: key, distribution: getter.apply(undefined, [this].concat(args)) };
+        this._cache[label] = value;
+      }
+
+      return value.distribution;
+    }
+  }, {
+    key: 'rng',
+    get: function get() {
+      return this._rng;
+    }
+  }]);
+
+  return Random;
+}();
+
+// defaults to Math.random as its RNG
+
+
+exports.default = new Random();
+//# sourceMappingURL=random.js.map

package/node_modules/random/dist/random.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/random.js"],"names":["RNG","RNGFactory","Random","rng","ow","object","instanceOf","_cache","use","length","clone","_rng","_patch","Error","Math","random","uniform","next","min","max","uniformInt","uniformBoolean","_memoize","mu","sigma","p","n","lambda","alpha","label","getter","args","key","join","value","undefined","distribution"],"mappings":";;;;;;;;;AAAA;;;;AAEA;;;;AACA;;;;AAEA;;;;AACA;;;;AACA;;;;AAEA;;;;AACA;;;;AAEA;;;;AACA;;;;AACA;;;;AAEA;;;;AACA;;;;AAEA;;;;AACA;;;;AACA;;;;;;;;QAESA,G,GAAAA,a;QAAKC,U,GAAAA,oB;;AAEd;;;;;;;;;;;IAUMC,M;AACJ,kBAAaC,GAAb,EAAkB;AAAA;;AAChB,QAAIA,GAAJ,EAAS,sBAAGA,GAAH,EAAQC,iBAAGC,MAAH,CAAUC,UAAV,CAAqBN,aAArB,CAAR;;AAET,SAAKO,MAAL,GAAc,EAAd;AACA,SAAKC,GAAL,CAASL,GAAT;AACD;;AAED;;;;;;;;;AAOA;;;;;;;;;;4BAUgB;AACd,UAAI,UAAKM,MAAT,EAAiB;AACf,eAAO,IAAIP,MAAJ,CAAWD,gDAAX,CAAP;AACD,OAFD,MAEO;AACL,eAAO,IAAIC,MAAJ,CAAW,KAAKC,GAAL,CAASO,KAAT,EAAX,CAAP;AACD;AACF;;AAED;;;;;;;;;;;;;;;;;;;;;0BAkBc;AACZ,WAAKC,IAAL,GAAYV,gDAAZ;AACD;;AAED;;;;;;4BAGS;AACP,UAAI,KAAKW,MAAT,EAAiB;AACf,cAAM,IAAIC,KAAJ,CAAU,6BAAV,CAAN;AACD;;AAED,WAAKD,MAAL,GAAcE,KAAKC,MAAnB;AACAD,WAAKC,MAAL,GAAc,KAAKC,OAAL,EAAd;AACD;;AAED;;;;;;8BAGW;AACT,UAAI,KAAKJ,MAAT,EAAiB;AACfE,aAAKC,MAAL,GAAc,KAAKH,MAAnB;AACA,eAAO,KAAKA,MAAZ;AACD;AACF;;AAED;AACA;AACA;;AAEA;;;;;;;;;;2BAOQ;AACN,aAAO,KAAKD,IAAL,CAAUM,IAAV,EAAP;AACD;;AAED;;;;;;;;;;;;;0BAUOC,G,EAAKC,G,EAAK;AACf,aAAO,KAAKH,OAAL,CAAaE,GAAb,EAAkBC,GAAlB,GAAP;AACD;;AAED;;;;;;;;;;;;;wBAUKD,G,EAAKC,G,EAAK;AACb,aAAO,KAAKC,UAAL,CAAgBF,GAAhB,EAAqBC,GAArB,GAAP;AACD;;AAED;;;;;;;;;;;;;;;4BAYSD,G,EAAKC,G,EAAK;AACjB,aAAO,KAAKC,UAAL,CAAgBF,GAAhB,EAAqBC,GAArB,GAAP;AACD;;AAED;;;;;;;;;;;;2BASQ;AACN,aAAO,KAAKE,cAAL,IAAP;AACD;;AAED;;;;;;;;;;8BAOW;AACT,aAAO,KAAKA,cAAL,IAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;;4BAOSH,G,EAAKC,G,EAAK;AACjB,aAAO,KAAKG,QAAL,CAAc,SAAd,EAAyBN,iBAAzB,EAAkCE,GAAlC,EAAuCC,GAAvC,CAAP;AACD;;AAED;;;;;;;;;;+BAOYD,G,EAAKC,G,EAAK;AACpB,aAAO,KAAKG,QAAL,CAAc,YAAd,EAA4BF,oBAA5B,EAAwCF,GAAxC,EAA6CC,GAA7C,CAAP;AACD;;AAED;;;;;;;;;;;qCAQkB;AAChB,aAAO,KAAKG,QAAL,CAAc,gBAAd,EAAgCD,wBAAhC,CAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;;2BAOQE,E,EAAIC,K,EAAO;AACjB,aAAO,sBAAO,IAAP,EAAaD,EAAb,EAAiBC,KAAjB,CAAP;AACD;;AAED;;;;;;;;;;8BAOWD,E,EAAIC,K,EAAO;AACpB,aAAO,yBAAU,IAAV,EAAgBD,EAAhB,EAAoBC,KAApB,CAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;8BAMWC,C,EAAG;AACZ,aAAO,yBAAU,IAAV,EAAgBA,CAAhB,CAAP;AACD;;AAED;;;;;;;;;;6BAOUC,C,EAAGD,C,EAAG;AACd,aAAO,wBAAS,IAAT,EAAeC,CAAf,EAAkBD,CAAlB,CAAP;AACD;;AAED;;;;;;;;;8BAMWA,C,EAAG;AACZ,aAAO,yBAAU,IAAV,EAAgBA,CAAhB,CAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;4BAMSE,M,EAAQ;AACf,aAAO,uBAAQ,IAAR,EAAcA,MAAd,CAAP;AACD;;AAED;;;;;;;;;gCAMaA,M,EAAQ;AACnB,aAAO,2BAAY,IAAZ,EAAkBA,MAAlB,CAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;8BAMWD,C,EAAG;AACZ,aAAO,yBAAU,IAAV,EAAgBA,CAAhB,CAAP;AACD;;AAED;;;;;;;;;0BAMOA,C,EAAG;AACR,aAAO,qBAAM,IAAN,EAAYA,CAAZ,CAAP;AACD;;AAED;;;;;;;;;2BAMQE,K,EAAO;AACb,aAAO,sBAAO,IAAP,EAAaA,KAAb,CAAP;AACD;;AAED;AACA;AACA;;AAEA;;;;;;;;;;;;;;;;;6BAcUC,K,EAAOC,M,EAAiB;AAAA,wCAANC,IAAM;AAANA,YAAM;AAAA;;AAChC,UAAMC,WAASD,KAAKE,IAAL,CAAU,GAAV,CAAf;AACA,UAAIC,QAAQ,KAAK3B,MAAL,CAAYsB,KAAZ,CAAZ;;AAEA,UAAIK,UAAUC,SAAV,IAAuBD,MAAMF,GAAN,KAAcA,GAAzC,EAA8C;AAC5CE,gBAAQ,EAAEF,QAAF,EAAOI,cAAcN,yBAAO,IAAP,SAAgBC,IAAhB,EAArB,EAAR;AACA,aAAKxB,MAAL,CAAYsB,KAAZ,IAAqBK,KAArB;AACD;;AAED,aAAOA,MAAME,YAAb;AACD;;;wBA9UU;AACT,aAAO,KAAKzB,IAAZ;AACD;;;;;;AA+UH;;;kBACe,IAAIT,MAAJ,E","file":"random.js","sourcesContent":["import ow from 'ow-lite'\n\nimport RNG from './rng'\nimport RNGFactory from './rng-factory'\n\nimport uniform from './distributions/uniform'\nimport uniformInt from './distributions/uniform-int'\nimport uniformBoolean from './distributions/uniform-boolean'\n\nimport normal from './distributions/normal'\nimport logNormal from './distributions/log-normal'\n\nimport bernoulli from './distributions/bernoulli'\nimport binomial from './distributions/binomial'\nimport geometric from './distributions/geometric'\n\nimport poisson from './distributions/poisson'\nimport exponential from './distributions/exponential'\n\nimport irwinHall from './distributions/irwin-hall'\nimport bates from './distributions/bates'\nimport pareto from './distributions/pareto'\n\nexport { RNG, RNGFactory }\n\n/**\n * Seedable random number generator supporting many common distributions.\n *\n * Defaults to Math.random as its underlying pseudorandom number generator.\n *\n * @name Random\n * @class\n *\n * @param {RNG|function} [rng=Math.random] - Underlying pseudorandom number generator.\n */\nclass Random {\n  constructor (rng) {\n    if (rng) ow(rng, ow.object.instanceOf(RNG))\n\n    this._cache = { }\n    this.use(rng)\n  }\n\n  /**\n   * @member {RNG} Underlying pseudo-random number generator\n   */\n  get rng () {\n    return this._rng\n  }\n\n  /**\n   * Creates a new `Random` instance, optionally specifying parameters to\n   * set a new seed.\n   *\n   * @see RNG.clone\n   *\n   * @param {string} [seed] - Optional seed for new RNG.\n   * @param {object} [opts] - Optional config for new RNG options.\n   * @return {Random}\n   */\n  clone (...args) {\n    if (args.length) {\n      return new Random(RNGFactory(...args))\n    } else {\n      return new Random(this.rng.clone())\n    }\n  }\n\n  /**\n   * Sets the underlying pseudorandom number generator used via\n   * either an instance of `seedrandom`, a custom instance of RNG\n   * (for PRNG plugins), or a string specifying the PRNG to use\n   * along with an optional `seed` and `opts` to initialize the\n   * RNG.\n   *\n   * @example\n   * const random = require('random')\n   *\n   * random.use('example_seedrandom_string')\n   * // or\n   * random.use(seedrandom('kittens'))\n   * // or\n   * random.use(Math.random)\n   *\n   * @param {...*} args\n   */\n  use (...args) {\n    this._rng = RNGFactory(...args)\n  }\n\n  /**\n   * Patches `Math.random` with this Random instance's PRNG.\n   */\n  patch () {\n    if (this._patch) {\n      throw new Error('Math.random already patched')\n    }\n\n    this._patch = Math.random\n    Math.random = this.uniform()\n  }\n\n  /**\n   * Restores a previously patched `Math.random` to its original value.\n   */\n  unpatch () {\n    if (this._patch) {\n      Math.random = this._patch\n      delete this._patch\n    }\n  }\n\n  // --------------------------------------------------------------------------\n  // Uniform utility functions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Convenience wrapper around `this.rng.next()`\n   *\n   * Returns a floating point number in [0, 1).\n   *\n   * @return {number}\n   */\n  next () {\n    return this._rng.next()\n  }\n\n  /**\n   * Samples a uniform random floating point number, optionally specifying\n   * lower and upper bounds.\n   *\n   * Convence wrapper around `random.uniform()`\n   *\n   * @param {number} [min=0] - Lower bound (float, inclusive)\n   * @param {number} [max=1] - Upper bound (float, exclusive)\n   * @return {number}\n   */\n  float (min, max) {\n    return this.uniform(min, max)()\n  }\n\n  /**\n   * Samples a uniform random integer, optionally specifying lower and upper\n   * bounds.\n   *\n   * Convence wrapper around `random.uniformInt()`\n   *\n   * @param {number} [min=0] - Lower bound (integer, inclusive)\n   * @param {number} [max=1] - Upper bound (integer, inclusive)\n   * @return {number}\n   */\n  int (min, max) {\n    return this.uniformInt(min, max)()\n  }\n\n  /**\n   * Samples a uniform random integer, optionally specifying lower and upper\n   * bounds.\n   *\n   * Convence wrapper around `random.uniformInt()`\n   *\n   * @alias `random.int`\n   *\n   * @param {number} [min=0] - Lower bound (integer, inclusive)\n   * @param {number} [max=1] - Upper bound (integer, inclusive)\n   * @return {number}\n   */\n  integer (min, max) {\n    return this.uniformInt(min, max)()\n  }\n\n  /**\n   * Samples a uniform random boolean value.\n   *\n   * Convence wrapper around `random.uniformBoolean()`\n   *\n   * @alias `random.boolean`\n   *\n   * @return {boolean}\n   */\n  bool () {\n    return this.uniformBoolean()()\n  }\n\n  /**\n   * Samples a uniform random boolean value.\n   *\n   * Convence wrapper around `random.uniformBoolean()`\n   *\n   * @return {boolean}\n   */\n  boolean () {\n    return this.uniformBoolean()()\n  }\n\n  // --------------------------------------------------------------------------\n  // Uniform distributions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Generates a [Continuous uniform distribution](https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)).\n   *\n   * @param {number} [min=0] - Lower bound (float, inclusive)\n   * @param {number} [max=1] - Upper bound (float, exclusive)\n   * @return {function}\n   */\n  uniform (min, max) {\n    return this._memoize('uniform', uniform, min, max)\n  }\n\n  /**\n   * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution).\n   *\n   * @param {number} [min=0] - Lower bound (integer, inclusive)\n   * @param {number} [max=1] - Upper bound (integer, inclusive)\n   * @return {function}\n   */\n  uniformInt (min, max) {\n    return this._memoize('uniformInt', uniformInt, min, max)\n  }\n\n  /**\n   * Generates a [Discrete uniform distribution](https://en.wikipedia.org/wiki/Discrete_uniform_distribution),\n   * with two possible outcomes, `true` or `false.\n   *\n   * This method is analogous to flipping a coin.\n   *\n   * @return {function}\n   */\n  uniformBoolean () {\n    return this._memoize('uniformBoolean', uniformBoolean)\n  }\n\n  // --------------------------------------------------------------------------\n  // Normal distributions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Generates a [Normal distribution](https://en.wikipedia.org/wiki/Normal_distribution).\n   *\n   * @param {number} [mu=0] - Mean\n   * @param {number} [sigma=1] - Standard deviation\n   * @return {function}\n   */\n  normal (mu, sigma) {\n    return normal(this, mu, sigma)\n  }\n\n  /**\n   * Generates a [Log-normal distribution](https://en.wikipedia.org/wiki/Log-normal_distribution).\n   *\n   * @param {number} [mu=0] - Mean of underlying normal distribution\n   * @param {number} [sigma=1] - Standard deviation of underlying normal distribution\n   * @return {function}\n   */\n  logNormal (mu, sigma) {\n    return logNormal(this, mu, sigma)\n  }\n\n  // --------------------------------------------------------------------------\n  // Bernoulli distributions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Generates a [Bernoulli distribution](https://en.wikipedia.org/wiki/Bernoulli_distribution).\n   *\n   * @param {number} [p=0.5] - Success probability of each trial.\n   * @return {function}\n   */\n  bernoulli (p) {\n    return bernoulli(this, p)\n  }\n\n  /**\n   * Generates a [Binomial distribution](https://en.wikipedia.org/wiki/Binomial_distribution).\n   *\n   * @param {number} [n=1] - Number of trials.\n   * @param {number} [p=0.5] - Success probability of each trial.\n   * @return {function}\n   */\n  binomial (n, p) {\n    return binomial(this, n, p)\n  }\n\n  /**\n   * Generates a [Geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution).\n   *\n   * @param {number} [p=0.5] - Success probability of each trial.\n   * @return {function}\n   */\n  geometric (p) {\n    return geometric(this, p)\n  }\n\n  // --------------------------------------------------------------------------\n  // Poisson distributions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Generates a [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution).\n   *\n   * @param {number} [lambda=1] - Mean (lambda > 0)\n   * @return {function}\n   */\n  poisson (lambda) {\n    return poisson(this, lambda)\n  }\n\n  /**\n   * Generates an [Exponential distribution](https://en.wikipedia.org/wiki/Exponential_distribution).\n   *\n   * @param {number} [lambda=1] - Inverse mean (lambda > 0)\n   * @return {function}\n   */\n  exponential (lambda) {\n    return exponential(this, lambda)\n  }\n\n  // --------------------------------------------------------------------------\n  // Misc distributions\n  // --------------------------------------------------------------------------\n\n  /**\n   * Generates an [Irwin Hall distribution](https://en.wikipedia.org/wiki/Irwin%E2%80%93Hall_distribution).\n   *\n   * @param {number} [n=1] - Number of uniform samples to sum (n >= 0)\n   * @return {function}\n   */\n  irwinHall (n) {\n    return irwinHall(this, n)\n  }\n\n  /**\n   * Generates a [Bates distribution](https://en.wikipedia.org/wiki/Bates_distribution).\n   *\n   * @param {number} [n=1] - Number of uniform samples to average (n >= 1)\n   * @return {function}\n   */\n  bates (n) {\n    return bates(this, n)\n  }\n\n  /**\n   * Generates a [Pareto distribution](https://en.wikipedia.org/wiki/Pareto_distribution).\n   *\n   * @param {number} [alpha=1] - Alpha\n   * @return {function}\n   */\n  pareto (alpha) {\n    return pareto(this, alpha)\n  }\n\n  // --------------------------------------------------------------------------\n  // Internal\n  // --------------------------------------------------------------------------\n\n  /**\n   * Memoizes distributions to ensure they're only created when necessary.\n   *\n   * Returns a thunk which that returns independent, identically distributed\n   * samples from the specified distribution.\n   *\n   * @private\n   *\n   * @param {string} label - Name of distribution\n   * @param {function} getter - Function which generates a new distribution\n   * @param {...*} args - Distribution-specific arguments\n   *\n   * @return {function}\n   */\n  _memoize (label, getter, ...args) {\n    const key = `${args.join(';')}`\n    let value = this._cache[label]\n\n    if (value === undefined || value.key !== key) {\n      value = { key, distribution: getter(this, ...args) }\n      this._cache[label] = value\n    }\n\n    return value.distribution\n  }\n}\n\n// defaults to Math.random as its RNG\nexport default new Random()\n"]}

package/node_modules/random/dist/rng-factory.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var _seedrandom = require('seedrandom');
+
+var _seedrandom2 = _interopRequireDefault(_seedrandom);
+
+var _rng = require('./rng');
+
+var _rng2 = _interopRequireDefault(_rng);
+
+var _function = require('./generators/function');
+
+var _function2 = _interopRequireDefault(_function);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+exports.default = function () {
+  for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+
+  var _args$ = args[0],
+      arg0 = _args$ === undefined ? 'default' : _args$,
+      rest = args.slice(1);
+
+
+  switch (typeof arg0 === 'undefined' ? 'undefined' : _typeof(arg0)) {
+    case 'object':
+      if (arg0 instanceof _rng2.default) {
+        return arg0;
+      }
+      break;
+
+    case 'function':
+      return new _function2.default(arg0);
+
+    case 'string':
+    case 'number':
+      return new _function2.default(_seedrandom2.default.apply(undefined, _toConsumableArray(rest)));
+  }
+
+  throw new Error('invalid RNG "' + arg0 + '"');
+};
+//# sourceMappingURL=rng-factory.js.map

package/node_modules/random/dist/rng-factory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rng-factory.js"],"names":["args","arg0","rest","RNG","RNGFunction","seedrandom","Error"],"mappings":";;;;;;;;AAAA;;;;AAEA;;;;AAEA;;;;;;;;kBAEe,YAAa;AAAA,oCAATA,IAAS;AAATA,QAAS;AAAA;;AAAA,eACUA,IADV;AAAA,MACnBC,IADmB,0BACZ,SADY;AAAA,MACEC,IADF,GACUF,IADV;;;AAG1B,iBAAeC,IAAf,yCAAeA,IAAf;AACE,SAAK,QAAL;AACE,UAAIA,gBAAgBE,aAApB,EAAyB;AACvB,eAAOF,IAAP;AACD;AACD;;AAEF,SAAK,UAAL;AACE,aAAO,IAAIG,kBAAJ,CAAgBH,IAAhB,CAAP;;AAEF,SAAK,QAAL;AACA,SAAK,QAAL;AACE,aAAO,IAAIG,kBAAJ,CAAgBC,yDAAcH,IAAd,EAAhB,CAAP;AAZJ;;AAeA,QAAM,IAAII,KAAJ,mBAA0BL,IAA1B,OAAN;AACD,C","file":"rng-factory.js","sourcesContent":["import seedrandom from 'seedrandom'\n\nimport RNG from './rng'\n\nimport RNGFunction from './generators/function'\n\nexport default (...args) => {\n  const [arg0 = 'default', ...rest] = args\n\n  switch (typeof arg0) {\n    case 'object':\n      if (arg0 instanceof RNG) {\n        return arg0\n      }\n      break\n\n    case 'function':\n      return new RNGFunction(arg0)\n\n    case 'string':\n    case 'number':\n      return new RNGFunction(seedrandom(...rest))\n  }\n\n  throw new Error(`invalid RNG \"${arg0}\"`)\n}\n"]}

package/node_modules/random/dist/rng.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var RNG = function () {
+  function RNG() {
+    _classCallCheck(this, RNG);
+  }
+
+  _createClass(RNG, [{
+    key: 'next',
+    value: function next() {
+      throw new Error('RNG.next must be overridden');
+    }
+  }, {
+    key: 'seed',
+    value: function seed(_seed, opts) {
+      throw new Error('RNG.seed must be overridden');
+    }
+  }, {
+    key: 'clone',
+    value: function clone(seed, opts) {
+      throw new Error('RNG.clone must be overridden');
+    }
+  }, {
+    key: '_seed',
+    value: function _seed(seed, opts) {
+      // TODO: add entropy and stuff
+
+      if (seed === (seed | 0)) {
+        return seed;
+      } else {
+        var strSeed = '' + seed;
+        var s = 0;
+
+        for (var k = 0; k < strSeed.length; ++k) {
+          s ^= strSeed.charCodeAt(k) | 0;
+        }
+
+        return s;
+      }
+    }
+  }, {
+    key: 'name',
+    get: function get() {
+      throw new Error('RNG.name must be overridden');
+    }
+  }]);
+
+  return RNG;
+}();
+
+exports.default = RNG;
+//# sourceMappingURL=rng.js.map

package/node_modules/random/dist/rng.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/rng.js"],"names":["RNG","Error","seed","opts","strSeed","s","k","length","charCodeAt"],"mappings":";;;;;;;;;;IAAqBA,G;;;;;;;2BAKX;AACN,YAAM,IAAIC,KAAJ,CAAU,6BAAV,CAAN;AACD;;;yBAEKC,K,EAAMC,I,EAAM;AAChB,YAAM,IAAIF,KAAJ,CAAU,6BAAV,CAAN;AACD;;;0BAEMC,I,EAAMC,I,EAAM;AACjB,YAAM,IAAIF,KAAJ,CAAU,8BAAV,CAAN;AACD;;;0BAEMC,I,EAAMC,I,EAAM;AACjB;;AAEA,UAAID,UAAUA,OAAO,CAAjB,CAAJ,EAAyB;AACvB,eAAOA,IAAP;AACD,OAFD,MAEO;AACL,YAAME,UAAU,KAAKF,IAArB;AACA,YAAIG,IAAI,CAAR;;AAEA,aAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIF,QAAQG,MAA5B,EAAoC,EAAED,CAAtC,EAAyC;AACvCD,eAAKD,QAAQI,UAAR,CAAmBF,CAAnB,IAAwB,CAA7B;AACD;;AAED,eAAOD,CAAP;AACD;AACF;;;wBA/BW;AACV,YAAM,IAAIJ,KAAJ,CAAU,6BAAV,CAAN;AACD;;;;;;kBAHkBD,G","file":"rng.js","sourcesContent":["export default class RNG {\n  get name () {\n    throw new Error('RNG.name must be overridden')\n  }\n\n  next () {\n    throw new Error('RNG.next must be overridden')\n  }\n\n  seed (seed, opts) {\n    throw new Error('RNG.seed must be overridden')\n  }\n\n  clone (seed, opts) {\n    throw new Error('RNG.clone must be overridden')\n  }\n\n  _seed (seed, opts) {\n    // TODO: add entropy and stuff\n\n    if (seed === (seed | 0)) {\n      return seed\n    } else {\n      const strSeed = '' + seed\n      let s = 0\n\n      for (let k = 0; k < strSeed.length; ++k) {\n        s ^= strSeed.charCodeAt(k) | 0\n      }\n\n      return s\n    }\n  }\n}\n"]}

package/node_modules/random/index.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('./dist/random').default