@lazy-random/df-uniform/dist/index.umd.development.cjs

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@lazy-random/expect'), require('@lazy-num/to-fixed-number'), require('@lazy-random/shared-lib')) :
	typeof define === 'function' && define.amd ? define(['exports', '@lazy-random/expect', '@lazy-num/to-fixed-number', '@lazy-random/shared-lib'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LazyRandomDfUniform = {}, global.expect, global.toFixedNumber, global.sharedLib));
})(this, (function (exports, expect, toFixedNumber, sharedLib) { 'use strict';

	function dfUniformFloat(random, min, max, fractionDigits) {
	  if (max === undefined) {
	    max = min === undefined ? 1 : min;
	    min = 0;
	  }
	  expect.expect(min).number.finite;
	  expect.expect(max).number.finite.gt(min);
	  let fn;
	  if (min === 0 && max === 1) {
	    fn = () => random.next();
	  } else if (min === 0) {
	    fn = () => {
	      return random.next() * max;
	    };
	  } else {
	    fn = () => {
	      return random.next() * (max - min) + min;
	    };
	  }
	  if (fractionDigits !== undefined) {
	    expect.expect(fractionDigits).integer.gte(0);
	    return () => {
	      return toFixedNumber.toFixedNumber(fn(), fractionDigits);
	    };
	  }
	  return fn;
	}

	function dfUniformInt(random, min, max) {
	  if (max === undefined) {
	    max = min === undefined ? 1 : min;
	    min = 0;
	  }
	  expect.expect(min).integer();
	  expect.expect(max).integer.gt(min);
	  //ow(min, ow.number.integer)
	  //ow(max, ow.number.integer.gt(min))
	  let fn = dfUniformFloat(random, min, max + 1);
	  return () => {
	    return Math.floor(fn());
	  };
	}

	function dfUniformBoolean(random, likelihood = 0.5) {
	  //ow(likelihood, ow.number.gt(0).lt(1))
	  expect.expect(likelihood).number.gt(0).lt(1);
	  return () => {
	    return random.next() >= likelihood;
	  };
	}

	function dfUniformByte(random, toStr) {
	  let fn = dfUniformInt(random, 0, 255);
	  if (typeof toStr !== 'undefined') {
	    expect.expect(toStr).boolean();
	  }
	  if (toStr) {
	    return () => sharedLib.stringifyByte(fn());
	  }
	  return fn;
	}

	function dfUniformBytes(random, size = 1, toStr) {
	  expect.expect(size).integer.gt(0);
	  const fn = dfUniformByte(random, toStr);
	  return () => {
	    let i = size;
	    let arr = [];
	    while (i--) {
	      arr[i] = fn();
	    }
	    return arr;
	  };
	}

	exports.dfUniformBoolean = dfUniformBoolean;
	exports.dfUniformByte = dfUniformByte;
	exports.dfUniformBytes = dfUniformBytes;
	exports.dfUniformFloat = dfUniformFloat;
	exports.dfUniformInt = dfUniformInt;

	Object.defineProperty(exports, '__esModule', { value: true });

}));
//# sourceMappingURL=index.umd.development.cjs.map