⛄ Sync 2026-04-23 20:32:35

luci-base/htdocs/luci-static/resources/tools/prng.js

@@ -0,0 +1,183 @@
+'use strict';
+
+var s = [0x0000, 0x0000, 0x0000, 0x0000];
+
+/**
+ * Multiply two 64-bit values represented as arrays of four 16-bit words.
+ *
+ * Arrays use little-endian word order (least-significant 16-bit word first).
+ * The result is truncated to the lower 64 bits and returned as a 4-element
+ * array of 16-bit words.
+ *
+ * @param {Array<number>} a - Multiplicand (4 × 16-bit words, little-endian)
+ * @param {Array<number>} b - Multiplier  (4 × 16-bit words, little-endian)
+ * @returns {Array<number>} Product as 4 × 16-bit words (little-endian)
+ */
+function mul(a, b) {
+	var r = [0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000];
+
+	for (var j = 0; j < 4; j++) {
+		var k = 0;
+		for (var i = 0; i < 4; i++) {
+			var t = a[i] * b[j] + r[i+j] + k;
+			r[i+j] = t & 0xffff;
+			k = t >>> 16;
+		}
+		r[j+4] = k;
+	}
+
+	r.length = 4;
+
+	return r;
+}
+
+/**
+ * Add a small integer to a 64-bit value represented as four 16-bit words.
+ *
+ * Treats `a` as a little-endian 64-bit value (4 × 16-bit words). Adds the
+ * integer `n` to the least-significant word and propagates carry across
+ * subsequent 16-bit words. The result is truncated to 64 bits and returned
+ * as a 4-element array of 16-bit words (little-endian).
+ *
+ * @param {Array<number>} a - Addend as 4 × 16-bit words (little-endian)
+ * @param {number} n - Value to add (integer carry)
+ * @returns {Array<number>} Sum as 4 × 16-bit words (little-endian)
+ */
+function add(a, n) {
+	var r = [0x0000, 0x0000, 0x0000, 0x0000],
+	    k = n;
+
+	for (var i = 0; i < 4; i++) {
+		var t = a[i] + k;
+		r[i] = t & 0xffff;
+		k = t >>> 16;
+	}
+
+	return r;
+}
+
+/**
+ * Shift a 64-bit value (4 × 16-bit words, little-endian) right by `n` bits.
+ *
+ * The input array is treated as little-endian 16-bit words. Bits shifted out
+ * on the right are discarded; the returned array contains the lower 64-bit
+ * result after the logical right shift.
+ *
+ * @param {Array<number>} a - Source value as 4 × 16-bit words (little-endian)
+ * @param {number} n - Number of bits to shift right (non-negative integer)
+ * @returns {Array<number>} Shifted value as 4 × 16-bit words (little-endian)
+ */
+function shr(a, n) {
+	var r = [a[0], a[1], a[2], a[3], 0x0000],
+	    i = 4,
+	    k = 0;
+
+	for (; n > 16; n -= 16, i--)
+		for (var j = 0; j < 4; j++)
+			r[j] = r[j+1];
+
+	for (; i > 0; i--) {
+		var s = r[i-1];
+		r[i-1] = (s >>> n) | k;
+		k = ((s & ((1 << n) - 1)) << (16 - n));
+	}
+
+	r.length = 4;
+
+	return r;
+}
+
+return L.Class.extend({
+	/**
+	 * Seed the PRNG state.
+	 *
+	 * The seed is treated as a 32-bit integer; the lower 16 bits are stored
+	 * in `s[0]`, the upper 16 bits in `s[1]`. `s[2]` and `s[3]` are zeroed.
+	 *
+	 * @param {number} n - Seed value (32-bit integer)
+	 * @returns {void}
+	 */
+	seed: function(n) {
+		n = (n - 1)|0;
+		s[0] = n & 0xffff;
+		s[1] = n >>> 16;
+		s[2] = 0;
+		s[3] = 0;
+	},
+
+	/**
+	 * Produce the next PRNG 32-bit integer.
+	 *
+	 * Advances the internal state and returns a 32-bit pseudo-random integer
+	 * derived from the current state.
+	 *
+	 * @returns {number} 32-bit pseudo-random integer (JS number)
+	 */
+	int: function() {
+		s = mul(s, [0x7f2d, 0x4c95, 0xf42d, 0x5851]);
+		s = add(s, 1);
+
+		var r = shr(s, 33);
+		return (r[1] << 16) | r[0];
+	},
+
+	/**
+	 * Return a pseudo-random value.
+	 *
+	 * Overloads:
+	 * - get() -> number in [0, 1]
+	 * - get(upper) -> integer in [1, upper]
+	 * - get(lower, upper) -> integer in [lower, upper]
+	 *
+	 * @param {number} [lower=0] - Lower bound (when two args supplied)
+	 * @param {number} [upper=0] - Upper bound (when one or two args supplied)
+	 * @returns {number} Random value (float in [0,1] or integer in requested range)
+	 */
+	get: function() {
+		var r = (this.int() % 0x7fffffff) / 0x7fffffff, l, u;
+
+		switch (arguments.length) {
+		case 0:
+			return r;
+
+		case 1:
+			l = 1;
+			u = arguments[0]|0;
+			break;
+
+		case 2:
+			l = arguments[0]|0;
+			u = arguments[1]|0;
+			break;
+		}
+
+		return Math.floor(r * (u - l + 1)) + l;
+	},
+
+	/**
+	 * Derive a deterministic hex color from an input string.
+	 *
+	 * The color is produced by seeding the PRNG from a string-derived
+	 * hash and producing RGB components. Returns a `#rrggbb` hex string.
+	 *
+	 * @param {string} string - Input string used to derive the color
+	 * @returns {string} Hex color string in `#rrggbb` format
+	 */
+	derive_color: function(string) {
+		this.seed(parseInt(sfh(string), 16));
+
+		var r = this.get(128),
+		    g = this.get(128),
+		    min = 0,
+		    max = 128;
+
+		if ((r + g) < 128)
+			min = 128 - r - g;
+		else
+			max = 255 - r - g;
+
+		var b = min + Math.floor(this.get() * (max - min));
+
+		return '#%02x%02x%02x'.format(0xff - r, 0xff - g, 0xff - b);
+	}
+});