@cloudglides/nox 1.0.1 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudglides/nox",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",
@@ -8,6 +8,7 @@
   "exports": {
     ".": {
       "node": "./src/index.js",
+      "browser": "./src/index.browser.js",
       "default": "./src/index.js"
     }
   },

package/src/core.js

@@ -6,3 +6,5 @@ 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.js';

package/src/index.browser.js

@@ -0,0 +1,31 @@
+export {
+  rng,
+  RNG,
+  deterministic,
+  normal,
+  exponential,
+  uniform,
+  poisson,
+  shuffle,
+  pick,
+  sample,
+  saveState,
+  restoreState,
+  cloneGenerator,
+  weightedPick,
+  weightedSample,
+  reservoirSample,
+  meanTest,
+  varianceTest,
+  kolmogorovSmirnovTest
+} from './core.js';
+
+export {
+  Xorshift64,
+  Splitmix64,
+  PCG64,
+  MT19937,
+  Logistic,
+  Tent,
+  Mixer
+} from './generators/index.js';

package/src/presets.js

@@ -1,6 +1,13 @@
 import { RNG } from './rng.js';
 import { PCG64 } from './generators/index.js';
 
+// Use browser or node entropy
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+const entropyModule = isNode ? 
+  await import('./utils/entropy.js') : 
+  await import('./utils/entropy.browser.js');
+const { combined: entropyFunc } = entropyModule;
+
 export const deterministic = (seed) => {
   if (seed === null || seed === undefined) {
     throw new TypeError('Deterministic mode requires an explicit seed');

package/src/utils/entropy.browser.js

@@ -0,0 +1,63 @@
+let cryptoCache = null;
+let cryptoCacheTime = 0;
+
+export const fromPerformance = () => {
+  try {
+    if (typeof performance !== 'undefined' && performance.now) {
+      const t = performance.now();
+      return BigInt(Math.floor(t * 1000)) ^ BigInt(Math.floor(t * 1000000) % 1000000);
+    }
+  } catch {
+    // fallback
+  }
+  return BigInt(Date.now());
+};
+
+export const fromMemory = () => {
+  return BigInt(Date.now());
+};
+
+export const fromCrypto = (bytes = 8) => {
+  try {
+    const now = Date.now();
+    
+    if (cryptoCache && (now - cryptoCacheTime) < 100) {
+      return cryptoCache;
+    }
+    
+    let val = 0n;
+    
+    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++) {
+        val = (val << 8n) | BigInt(arr[i]);
+      }
+    } else {
+      return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
+    }
+    
+    cryptoCache = val;
+    cryptoCacheTime = now;
+    return val;
+  } catch {
+    return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
+  }
+};
+
+export const combined = () => {
+  const perf = fromPerformance();
+  const mem = fromMemory();
+  const crypto = fromCrypto();
+  
+  let mix = perf ^ mem ^ crypto;
+  mix = mix ^ (mix >> 33n);
+  mix = (mix * 0xff51afd7ed558ccdn) & ((1n << 64n) - 1n);
+  
+  return mix !== 0n ? mix : 1n;
+};
+
+export const clearCryptoCache = () => {
+  cryptoCache = null;
+  cryptoCacheTime = 0;
+};

package/src/utils/entropy.js

@@ -7,14 +7,19 @@ const isBrowser = typeof window !== 'undefined';
 let performanceImpl = typeof performance !== 'undefined' ? performance : null;
 let randomBytesImpl = null;
 
-if (isNode && typeof require !== 'undefined') {
+// Avoid parsing require() for browser - use indirect method
+if (isNode) {
   try {
-    const perf_hooks = require('perf_hooks');
+    const getRequire = new Function('return require');
+    const req = getRequire();
+    const perf_hooks = req('perf_hooks');
     performanceImpl = perf_hooks.performance;
   } catch {}
   
   try {
-    const crypto_mod = require('crypto');
+    const getRequire = new Function('return require');
+    const req = getRequire();
+    const crypto_mod = req('crypto');
     randomBytesImpl = crypto_mod.randomBytes;
   } catch {}
 }