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

'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);
	}
});