@cloudglides/nox 1.1.0 → 1.1.2

package/src/rng.js

@@ -61,7 +61,7 @@ export class RNG {
     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;
@@ -84,7 +84,7 @@ export class RNG {
     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));
@@ -99,7 +99,7 @@ export class RNG {
     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();
@@ -114,7 +114,7 @@ export class RNG {
     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);
@@ -129,7 +129,7 @@ export class RNG {
     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);
@@ -139,3 +139,4 @@ export class RNG {
 }
 
 export const rng = () => new RNG();
+

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

@@ -1,19 +1,46 @@
-import { performance } from 'perf_hooks';
-import { randomBytes } from 'crypto';
-
 let cryptoCache = null;
 let cryptoCacheTime = 0;
 
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+const isBrowser = typeof window !== 'undefined';
+
+let performanceImpl = typeof performance !== 'undefined' ? performance : null;
+let randomBytesImpl = null;
+
+// Only require in true Node environment
+if (isNode && !isBrowser) {
+  try {
+    // Avoid static analysis by constructing module name dynamically
+    const moduleName = ['perf', '_hooks'].join('');
+    performanceImpl = require(moduleName).performance;
+  } catch {}
+  
+  try {
+    randomBytesImpl = require('crypto').randomBytes;
+  } catch {}
+}
+
 export const fromPerformance = () => {
-  const t = performance.now();
-  return BigInt(Math.floor(t * 1000)) ^ BigInt(Math.floor(t * 1000000) % 1000000);
+  try {
+    if (performanceImpl && typeof performanceImpl.now === 'function') {
+      const t = performanceImpl.now();
+      return BigInt(Math.floor(t * 1000)) ^ BigInt(Math.floor(t * 1000000) % 1000000);
+    }
+  } catch {
+    // fallback
+  }
+  return BigInt(Date.now());
 };
 
 export const fromMemory = () => {
-  if (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());
+  try {
+    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());
+    }
+  } catch {
+    // fallback
   }
   return BigInt(Date.now());
 };
@@ -21,14 +48,26 @@ export const fromMemory = () => {
 export const fromCrypto = (bytes = 8) => {
   try {
     const now = Date.now();
+    
     if (cryptoCache && (now - cryptoCacheTime) < 100) {
       return cryptoCache;
     }
     
-    const buf = randomBytes(Math.max(bytes, 8));
     let val = 0n;
-    for (let i = 0; i < buf.length; i++) {
-      val = (val << 8n) | BigInt(buf[i]);
+    
+    if (randomBytesImpl) {
+      const buf = randomBytesImpl(Math.max(bytes, 8));
+      for (let i = 0; i < buf.length; i++) {
+        val = (val << 8n) | BigInt(buf[i]);
+      }
+    } 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++) {
+        val = (val << 8n) | BigInt(arr[i]);
+      }
+    } else {
+      return BigInt(Math.random() * Number.MAX_SAFE_INTEGER);
     }
     
     cryptoCache = val;