@wener/utils 1.1.56 → 1.1.58

package/lib/maths/createRandom.test.js

@@ -1,36 +1,278 @@
-import { expect, test } from "vitest";
-import { createRandom } from "./random.js";
-test("createRandom", function () {
-    var random = createRandom(0);
-    expect(random.random(100)).toBe(47);
-    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-    try {
-        for (var _iterator = random[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var a = _step.value;
-            expect(a).toBe(0.557133817113936);
-            break;
-        }
-    }
-    catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-    }
-    finally {
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr))
+        return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null)
+        return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { describe, expect, test } from "vitest";
+import { createRandom, resolveRandom } from "./random.js";
+describe("createRandom", function () {
+    test("deterministic with same seed", function () {
+        var r1 = createRandom(12345);
+        var r2 = createRandom(12345);
+        expect(r1.random()).toBe(r2.random());
+        expect(r1.randomInt(100)).toBe(r2.randomInt(100));
+    });
+    test("random() returns [0, 1)", function () {
+        var r = createRandom(0);
+        for (var i = 0; i < 100; i++) {
+            var v = r.random();
+            expect(v).toBeGreaterThanOrEqual(0);
+            expect(v).toBeLessThan(1);
+        }
+    });
+    test("random(a) returns [0, a)", function () {
+        var r = createRandom(42);
+        for (var i = 0; i < 100; i++) {
+            var v = r.random(50);
+            expect(v).toBeGreaterThanOrEqual(0);
+            expect(v).toBeLessThan(50);
+        }
+    });
+    test("random(a, b) returns [a, b)", function () {
+        var r = createRandom(42);
+        for (var i = 0; i < 100; i++) {
+            var v = r.random(10, 20);
+            expect(v).toBeGreaterThanOrEqual(10);
+            expect(v).toBeLessThan(20);
+        }
+    });
+    test("randomInt(max) returns [0, max]", function () {
+        var r = createRandom(42);
+        var results = new Set();
+        for (var i = 0; i < 1000; i++) {
+            var v = r.randomInt(5);
+            expect(v).toBeGreaterThanOrEqual(0);
+            expect(v).toBeLessThanOrEqual(5);
+            expect(Number.isInteger(v)).toBe(true);
+            results.add(v);
+        }
+        // should hit all values 0-5
+        expect(results.size).toBe(6);
+    });
+    test("randomInt(min, max) returns [min, max]", function () {
+        var r = createRandom(42);
+        var results = new Set();
+        for (var i = 0; i < 1000; i++) {
+            var v = r.randomInt(10, 15);
+            expect(v).toBeGreaterThanOrEqual(10);
+            expect(v).toBeLessThanOrEqual(15);
+            expect(Number.isInteger(v)).toBe(true);
+            results.add(v);
+        }
+        // should hit all values 10-15
+        expect(results.size).toBe(6);
+    });
+    test("shuffle", function () {
+        var r = createRandom(42);
+        var arr = [
+            1,
+            2,
+            3,
+            4,
+            5
+        ];
+        var shuffled = r.shuffle(_to_consumable_array(arr));
+        expect(shuffled).toHaveLength(5);
+        expect(shuffled.sort()).toEqual(arr);
+    });
+    test("sample", function () {
+        var r = createRandom(42);
+        var arr = [
+            1,
+            2,
+            3,
+            4,
+            5,
+            6,
+            7,
+            8,
+            9,
+            10
+        ];
+        var sampled = r.sample(arr, 3);
+        expect(sampled).toHaveLength(3);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // all sampled items should be from original array
+            for (var _iterator = sampled[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var v = _step.value;
+                expect(arr).toContain(v);
+            }
+        }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
+        finally {
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        // no duplicates
+        expect(new Set(sampled).size).toBe(3);
+    });
+    test("sample with n >= arr.length returns shuffled copy", function () {
+        var r = createRandom(42);
+        var arr = [
+            1,
+            2,
+            3
+        ];
+        var sampled = r.sample(arr, 5);
+        expect(sampled).toHaveLength(3);
+        expect(sampled.sort()).toEqual(arr);
+    });
+    test("pick", function () {
+        var r = createRandom(42);
+        var arr = [
+            1,
+            2,
+            3,
+            4,
+            5
+        ];
+        var picked = r.pick(arr);
+        expect(arr).toContain(picked);
+    });
+    test("reset restores initial state", function () {
+        var r = createRandom(42);
+        var first = r.random();
+        r.random();
+        r.random();
+        r.reset();
+        expect(r.random()).toBe(first);
+    });
+    test("reset with new seed", function () {
+        var r = createRandom(42);
+        r.reset(100);
+        var r2 = createRandom(100);
+        expect(r.random()).toBe(r2.random());
+    });
+    test("reset with string seed", function () {
+        var r = createRandom(42);
+        r.reset("hello");
+        var r2 = createRandom("hello");
+        expect(r.random()).toBe(r2.random());
+    });
+    test("seed property", function () {
+        var r = createRandom(12345);
+        expect(r.seed).toBe(12345);
+    });
+    test("string seed", function () {
+        var r1 = createRandom("test-seed");
+        var r2 = createRandom("test-seed");
+        expect(r1.random()).toBe(r2.random());
+    });
+    test("randomBytes(n) returns Uint8Array of length n", function () {
+        var r = createRandom(42);
+        var bytes = r.randomBytes(16);
+        expect(bytes).toBeInstanceOf(Uint8Array);
+        expect(bytes.length).toBe(16);
+    });
+    test("randomBytes fills provided buffer", function () {
+        var r = createRandom(42);
+        var buf = new Uint8Array(8);
+        var result = r.randomBytes(buf);
+        expect(result).toBe(buf);
+        // should not be all zeros
+        expect(buf.some(function (v) {
+            return v !== 0;
+        })).toBe(true);
+    });
+    test("randomBytes is deterministic", function () {
+        var r1 = createRandom(42);
+        var r2 = createRandom(42);
+        expect(r1.randomBytes(16)).toEqual(r2.randomBytes(16));
+    });
+    test("randomBytes handles non-multiple of 4", function () {
+        var r = createRandom(42);
+        var bytes1 = r.randomBytes(1);
+        expect(bytes1.length).toBe(1);
+        var r2 = createRandom(42);
+        var bytes5 = r2.randomBytes(5);
+        expect(bytes5.length).toBe(5);
+        var r3 = createRandom(42);
+        var bytes7 = r3.randomBytes(7);
+        expect(bytes7.length).toBe(7);
+    });
+    test("randomBytes produces values in range 0-255", function () {
+        var r = createRandom(42);
+        var bytes = r.randomBytes(1000);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
         try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-                _iterator.return();
+            for (var _iterator = bytes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+                var b = _step.value;
+                expect(b).toBeGreaterThanOrEqual(0);
+                expect(b).toBeLessThanOrEqual(255);
             }
         }
+        catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        }
         finally {
-            if (_didIteratorError) {
-                throw _iteratorError;
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            }
+            finally {
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
             }
         }
-    }
-    expect(random.randomBytes(4)).toEqual(Uint8Array.from([
-        163,
-        85,
-        196,
-        62
-    ]));
+    });
+});
+describe("resolveRandom", function () {
+    test("returns existing RNG", function () {
+        var r = createRandom(42);
+        expect(resolveRandom(r)).toBe(r);
+    });
+    test("creates RNG from number seed", function () {
+        var r = resolveRandom(42);
+        var r2 = createRandom(42);
+        expect(r.random()).toBe(r2.random());
+    });
+    test("creates RNG from string seed", function () {
+        var r = resolveRandom("test");
+        var r2 = createRandom("test");
+        expect(r.random()).toBe(r2.random());
+    });
 });

package/lib/maths/random.js

@@ -1,174 +1,188 @@
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
 }
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function() {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function resolveSeed() {
+    var seed = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Date.now();
+    var v = 0;
+    if (typeof seed === 'number') {
+        v = seed;
+    } else {
+        seed = String(seed);
+        for(var i = 0; i < seed.length; i++){
+            v = Math.imul(31, v) + seed.charCodeAt(i) | 0;
         }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
     }
+    // uint32
+    v = v >>> 0;
+    return v;
 }
-// LCG pseudo random
-export function createRandom() {
-    var _seed = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Date.now();
-    var seed = 0;
-    if (typeof _seed === 'string') {
-        for(var i = 0; i < _seed.length; i++){
-            seed = Math.imul(31, seed) + _seed.charCodeAt(i) | 0;
+export function createRandom(s) {
+    // seealso https://github.com/skeeto/rng-js/blob/master/rng.js
+    var initialSeed = resolveSeed(s);
+    var rng = createXorshift128plus(initialSeed);
+    var random = function(a, b) {
+        var r = rng.next();
+        if (a !== undefined && b !== undefined) {
+            return r * (b - a) + a;
         }
-    } else if (typeof _seed === 'number') {
-        seed = _seed;
-    }
-    // int32
-    seed = seed >>> 0;
-    // alternative 梅森旋转算法 (Mersenne Twister), Xorshift
-    // LCG
-    var m = 0x80000000; // 2^31
-    var a = 1664525;
-    var c = 1013904223;
-    var random = function(n) {
-        seed = (a * seed + c) % m;
-        var r = seed / m;
-        if (n) {
-            r = Math.floor(r * n);
+        if (a !== undefined) {
+            return r * a;
         }
         return r;
     };
-    var randomBytes = function(length) {
-        var bytes = new Uint8Array(length);
-        for(var i = 0; i < length; i++){
-            bytes[i] = Math.floor(random() * 256);
+    var randomInt = function(min, max) {
+        if (max === undefined) {
+            max = min;
+            min = 0;
         }
-        return bytes;
+        return Math.floor(random(min, max + 1));
     };
-    return _define_property({
-        random: random,
-        randomBytes: randomBytes
-    }, Symbol.iterator, function() {
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    if (!true) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        random()
-                    ];
-                case 1:
-                    _state.sent();
-                    return [
-                        3,
-                        0
-                    ];
-                case 2:
-                    return [
-                        2
-                    ];
+    var shuffle = function(arr) {
+        // Fisher-Yates shuffle
+        for(var i = arr.length - 1; i > 0; i--){
+            var j = randomInt(0, i);
+            var tmp = arr[i];
+            arr[i] = arr[j];
+            arr[j] = tmp;
+        }
+        return arr;
+    };
+    var sample = function(arr, n) {
+        if (n >= arr.length) {
+            return shuffle(_to_consumable_array(arr));
+        }
+        // 使用 partial Fisher-Yates
+        var copy = _to_consumable_array(arr);
+        var result = [];
+        for(var i = 0; i < n; i++){
+            var j = randomInt(i, copy.length - 1);
+            var tmp = copy[i];
+            copy[i] = copy[j];
+            copy[j] = tmp;
+            result.push(copy[i]);
+        }
+        return result;
+    };
+    var pick = function(arr) {
+        return arr[randomInt(0, arr.length - 1)];
+    };
+    var randomBytes = function(input) {
+        var buf = typeof input === 'number' ? new Uint8Array(input) : input;
+        var len = buf.length;
+        // 每次 nextInt32 产生 4 字节
+        var i = 0;
+        while(i + 4 <= len){
+            var v = rng.nextInt32();
+            buf[i] = v & 0xff;
+            buf[i + 1] = v >>> 8 & 0xff;
+            buf[i + 2] = v >>> 16 & 0xff;
+            buf[i + 3] = v >>> 24 & 0xff;
+            i += 4;
+        }
+        // 处理剩余字节
+        if (i < len) {
+            var v1 = rng.nextInt32();
+            for(var j = 0; i < len; i++, j++){
+                buf[i] = v1 >>> j * 8 & 0xff;
             }
-        });
-    });
+        }
+        return buf;
+    };
+    return {
+        random: random,
+        randomInt: randomInt,
+        randomBytes: randomBytes,
+        shuffle: shuffle,
+        sample: sample,
+        pick: pick,
+        reset: function(seed) {
+            return rng.reset(seed !== undefined ? resolveSeed(seed) : undefined);
+        },
+        get seed () {
+            return rng.seed;
+        }
+    };
+}
+export function resolveRandom() {
+    var r = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : Date.now();
+    if (typeof r !== 'string' && typeof r !== 'number') {
+        return r;
+    }
+    return createRandom(r);
+}
+/**
+ * xorshift128+ 算法
+ * 周期: 2^128 - 1，统计特性优于 LCG
+ * 参考: https://prng.di.unimi.it/
+ */ function createXorshift128plus(seed) {
+    var initialSeed = seed;
+    // 使用 SplitMix64 风格初始化两个状态
+    var s0 = seed >>> 0;
+    var s1 = seed * 1812433253 + 1 >>> 0;
+    // 确保状态非零
+    if (s0 === 0) s0 = 0xdeadbeef;
+    if (s1 === 0) s1 = 0xcafebabe;
+    var nextInt32 = function() {
+        // xorshift128+ 核心算法（32位简化版）
+        var x = s0;
+        var y = s1;
+        s0 = y;
+        x ^= x << 23;
+        x ^= x >>> 17;
+        x ^= y;
+        x ^= y >>> 26;
+        s1 = x >>> 0;
+        // 返回 uint32
+        return s0 + s1 >>> 0;
+    };
+    // 32 位精度 [0, 1)
+    var nextFloat = function() {
+        return nextInt32() / 0x100000000;
+    };
+    // 53 位精度 [0, 1)，两次迭代组合
+    var nextDouble = function() {
+        var hi = nextInt32() >>> 11; // 21 位
+        var lo = nextInt32(); // 32 位
+        return hi / (1 << 21) + lo / ((1 << 21) * 0x100000000);
+    };
+    var next = nextFloat;
+    var reset = function() {
+        var newSeed = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : initialSeed;
+        s0 = newSeed >>> 0;
+        s1 = newSeed * 1812433253 + 1 >>> 0;
+        if (s0 === 0) s0 = 0xdeadbeef;
+        if (s1 === 0) s1 = 0xcafebabe;
+    };
+    return {
+        next: next,
+        nextFloat: nextFloat,
+        nextDouble: nextDouble,
+        nextInt32: nextInt32,
+        reset: reset,
+        get seed () {
+            return initialSeed;
+        }
+    };
 }

package/lib/web/getGlobalThis.js

@@ -1,4 +1,3 @@
-var _this = this;
 /**
  * isomorphic globalThis
  *
@@ -13,6 +12,5 @@ var _this = this;
     if (typeof self !== 'undefined') return self;
     if (typeof window !== 'undefined') return window;
     if (typeof global !== 'undefined') return global;
-    if (typeof _this !== 'undefined') return _this;
     throw new Error('Unable to locate global `this`');
 };