@cloudglides/nox 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/nox",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",

package/src/core.browser.js

@@ -0,0 +1,10 @@
+export { rng, RNG } from './rng.browser.js';
+export { deterministic } from './presets.js';
+
+export { normal, exponential, uniform, poisson } from './utils/distributions.js';
+export { shuffle, pick, sample } from './utils/sequence.js';
+export { saveState, restoreState, cloneGenerator } from './utils/state.js';
+export { weightedPick, weightedSample, reservoirSample } from './utils/sampling.js';
+export { meanTest, varianceTest, kolmogorovSmirnovTest } from './utils/statistics.js';
+
+export { combined, clearCryptoCache } from './utils/entropy.browser.js';

package/src/index.browser.js

@@ -18,7 +18,7 @@ export {
   meanTest,
   varianceTest,
   kolmogorovSmirnovTest
-} from './core.js';
+} from './core.browser.js';
 
 export {
   Xorshift64,

package/src/rng.browser.js

@@ -0,0 +1,141 @@
+import { PCG64 } from './generators/index.js';
+import { combined } from './utils/entropy.browser.js';
+
+export class RNG {
+  constructor(generator = null, seed = null) {
+    if (generator === null) {
+      seed = seed || combined();
+      this.gen = new PCG64(seed);
+    } else if (typeof generator === 'function') {
+      this.gen = new generator(seed || combined());
+    } else if (typeof generator === 'object' && generator !== null) {
+      this.gen = generator;
+    } else {
+      throw new TypeError('Generator must be a constructor function or instance');
+    }
+  }
+
+  next() {
+    return this.gen.next();
+  }
+
+  nextInt(max = 2147483647) {
+    return this.gen.nextInt(max);
+  }
+
+  nextFloat() {
+    return this.gen.nextFloat();
+  }
+
+  int(min, max) {
+    if (typeof min !== 'number' || typeof max !== 'number') {
+      throw new TypeError('int() requires two number arguments');
+    }
+    if (!Number.isInteger(min) || !Number.isInteger(max)) {
+      throw new TypeError('int() arguments must be integers');
+    }
+    if (min > max) [min, max] = [max, min];
+    return Math.floor(this.nextFloat() * (max - min + 1)) + min;
+  }
+
+  bool(probability = 0.5) {
+    if (typeof probability !== 'number') {
+      throw new TypeError('probability must be a number');
+    }
+    if (probability < 0 || probability > 1) {
+      throw new RangeError('probability must be between 0 and 1');
+    }
+    return this.nextFloat() < probability;
+  }
+
+  range(min, max, step = 1) {
+    if (typeof min !== 'number' || typeof max !== 'number' || typeof step !== 'number') {
+      throw new TypeError('min, max, and step must be numbers');
+    }
+    if (!Number.isInteger(min) || !Number.isInteger(max) || !Number.isInteger(step)) {
+      throw new Error('min, max, and step must be integers');
+    }
+    if (step <= 0) {
+      throw new Error('step must be positive');
+    }
+    if (min > max) {
+      throw new Error('min must be less than or equal to max');
+    }
+
+    const count = Math.floor((max - min) / step) + 1;
+    const idx = this.nextInt(count);
+    return min + idx * step;
+  }
+
+  choice(arr) {
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new TypeError('choice() requires non-empty array');
+    }
+    return arr[this.nextInt(arr.length)];
+  }
+
+  batch(count, fn) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('fn must be a function');
+    }
+
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(fn(this, i));
+    }
+    return result;
+  }
+
+  floats(count) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextFloat();
+    }
+    return result;
+  }
+
+  ints(count, max = 2147483647) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextInt(max);
+    }
+    return result;
+  }
+
+  bools(count, probability = 0.5) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.bool(probability);
+    }
+    return result;
+  }
+}
+
+export const rng = () => new RNG();

package/src/utils/entropy.js

@@ -7,26 +7,22 @@ const isBrowser = typeof window !== 'undefined';
 let performanceImpl = typeof performance !== 'undefined' ? performance : null;
 let randomBytesImpl = null;
 
-// Avoid parsing require() for browser - use indirect method
-if (isNode) {
+// Only require in true Node environment
+if (isNode && !isBrowser) {
   try {
-    const getRequire = new Function('return require');
-    const req = getRequire();
-    const perf_hooks = req('perf_hooks');
-    performanceImpl = perf_hooks.performance;
+    // Avoid static analysis by constructing module name dynamically
+    const moduleName = ['perf', '_hooks'].join('');
+    performanceImpl = require(moduleName).performance;
   } catch {}
   
   try {
-    const getRequire = new Function('return require');
-    const req = getRequire();
-    const crypto_mod = req('crypto');
-    randomBytesImpl = crypto_mod.randomBytes;
+    randomBytesImpl = require('crypto').randomBytes;
   } catch {}
 }
 
 export const fromPerformance = () => {
   try {
-    if (performanceImpl && performanceImpl.now) {
+    if (performanceImpl && typeof performanceImpl.now === 'function') {
       const t = performanceImpl.now();
       return BigInt(Math.floor(t * 1000)) ^ BigInt(Math.floor(t * 1000000) % 1000000);
     }
@@ -38,7 +34,7 @@ export const fromPerformance = () => {
 
 export const fromMemory = () => {
   try {
-    if (isNode && typeof process !== 'undefined' && process.memoryUsage) {
+    if (isNode && !isBrowser && typeof process !== 'undefined' && process.memoryUsage) {
       const mem = process.memoryUsage();
       const total = mem.heapUsed + mem.external + mem.heapTotal;
       return BigInt(Math.floor(total)) ^ BigInt(Date.now());
@@ -64,7 +60,7 @@ export const fromCrypto = (bytes = 8) => {
       for (let i = 0; i < buf.length; i++) {
         val = (val << 8n) | BigInt(buf[i]);
       }
-    } else if (isBrowser && typeof crypto !== 'undefined' && crypto.getRandomValues) {
+    } else if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
       const arr = new Uint8Array(Math.max(bytes, 8));
       crypto.getRandomValues(arr);
       for (let i = 0; i < arr.length; i++) {