toosoon-prng 1.0.0

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 120,
+  "trailingComma": "none",
+  "endOfLine": "auto"
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TOOSOON
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/controllers.d.ts

@@ -0,0 +1,160 @@
+import type { Gui, GuiController } from 'toosoon-gui';
+export declare enum PRNGControllerTypes {
+    Boolean = "Boolean",
+    Sign = "Sign",
+    Int = "Int",
+    Float = "Float",
+    HexColor = "HexColor",
+    Item = "Item",
+    ObjectProperty = "ObjectProperty",
+    Weights = "Weights"
+}
+export interface PRNGController<T = unknown> {
+    seed: string;
+    value: T;
+    addGUI(gui: Gui, min?: number, max?: number, step?: number): GuiController;
+    getValue(): T;
+    dispose(): void;
+}
+export interface PRNGGroupController<T = unknown> {
+    seed: string;
+    addGUI(gui: Gui, min?: number, max?: number, step?: number): Gui;
+    createController(index: number): PRNGController<T>;
+    getValueAt(index: number): T;
+    dispose(): void;
+}
+declare abstract class BasePRNGController<T> implements PRNGController<T> {
+    seed: string;
+    abstract value: T;
+    gui: GuiController;
+    constructor(seed: string);
+    abstract addGUI(gui: Gui, min?: number, max?: number, step?: number): GuiController;
+    abstract getValue(): T;
+    dispose(): void;
+}
+declare abstract class BasePRNGGroupController<T> implements PRNGGroupController<T> {
+    seed: string;
+    controllers: PRNGController<T>[];
+    gui: Gui;
+    guiArgs: {
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+    constructor(seed: string);
+    addGUI(gui: Gui, min?: number, max?: number, step?: number): Gui;
+    abstract createController(index: number): PRNGController<T>;
+    getValueAt(index: number): T;
+    dispose(): void;
+}
+export declare class BooleanController extends BasePRNGController<boolean> {
+    value: boolean;
+    probability: number;
+    constructor(seed: string, probability?: number);
+    addGUI(gui: Gui): GuiController;
+    getValue(): boolean;
+}
+export declare class SignController extends BasePRNGController<number> {
+    value: number;
+    probability: number;
+    constructor(seed: string, probability?: number);
+    addGUI(gui: Gui): GuiController;
+    getValue(): number;
+}
+export declare class IntController extends BasePRNGController<number> {
+    value: number;
+    min: number;
+    max: number;
+    constructor(seed: string, min?: number, max?: number);
+    addGUI(gui: Gui, min: number, max: number, step?: number): GuiController;
+    getValue(): number;
+}
+export declare class FloatController extends BasePRNGController<number> {
+    value: number;
+    min: number;
+    max: number;
+    constructor(seed: string, min?: number, max?: number);
+    addGUI(gui: Gui, min: number, max: number, step?: number): GuiController;
+    getValue(): number;
+}
+export declare class HexColorController extends BasePRNGController<string> {
+    value: string;
+    constructor(seed: string);
+    addGUI(gui: Gui): GuiController;
+    getValue(): string;
+}
+export declare class ItemController<T = unknown> extends BasePRNGController<T> {
+    value: T;
+    items: T[];
+    constructor(seed: string, items: T[]);
+    addGUI(gui: Gui): GuiController;
+    getValue(): T;
+}
+export declare class ObjectPropertyController<T = unknown> extends BasePRNGController<T> {
+    value: T;
+    object: Object;
+    constructor(seed: string, object: Object);
+    addGUI(gui: Gui): GuiController;
+    getValue(): T;
+}
+type WeightsItems<T> = Array<{
+    weight: number;
+    value: T;
+}>;
+export declare class WeightsController<T = unknown> extends BasePRNGController<T> {
+    value: T;
+    items: WeightsItems<T>;
+    weights: number[];
+    constructor(seed: string, items: WeightsItems<T>);
+    addGUI(gui: Gui): GuiController;
+    getValue(): T;
+}
+export declare class BooleanGroupController extends BasePRNGGroupController<boolean> {
+    probability: number;
+    controllers: BooleanController[];
+    constructor(seed: string, probability: number);
+    createController(index: number): BooleanController;
+}
+export declare class SignGroupController extends BasePRNGGroupController<number> {
+    probability: number;
+    controllers: SignController[];
+    constructor(seed: string, probability: number);
+    createController(index: number): SignController;
+}
+export declare class IntGroupController extends BasePRNGGroupController<number> {
+    min: number;
+    max: number;
+    controllers: IntController[];
+    constructor(seed: string, min: number, max: number);
+    createController(index: number): IntController;
+}
+export declare class FloatGroupController extends BasePRNGGroupController<number> {
+    min: number;
+    max: number;
+    controllers: FloatController[];
+    constructor(seed: string, min: number, max: number);
+    createController(index: number): FloatController;
+}
+export declare class HexColorGroupController extends BasePRNGGroupController<string> {
+    controllers: HexColorController[];
+    createController(index: number): HexColorController;
+}
+export declare class ItemGroupController<T = unknown> extends BasePRNGGroupController<T> {
+    items: T[];
+    controllers: ItemController<T>[];
+    constructor(seed: string, items: T[]);
+    createController(index: number): ItemController<T>;
+}
+export declare class ObjectPropertyGroupController<T = unknown> extends BasePRNGGroupController<T> {
+    object: Object;
+    controllers: ObjectPropertyController<T>[];
+    constructor(seed: string, object: Object);
+    createController(index: number): ObjectPropertyController<T>;
+}
+export declare class WeightsGroupController<T = unknown> extends BasePRNGGroupController<T> {
+    items: WeightsItems<T>;
+    controllers: WeightsController<T>[];
+    constructor(seed: string, items: WeightsItems<T>);
+    createController(index: number): WeightsController<T>;
+}
+export {};

package/lib/controllers.js

@@ -0,0 +1,382 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeightsGroupController = exports.ObjectPropertyGroupController = exports.ItemGroupController = exports.HexColorGroupController = exports.FloatGroupController = exports.IntGroupController = exports.SignGroupController = exports.BooleanGroupController = exports.WeightsController = exports.ObjectPropertyController = exports.ItemController = exports.HexColorController = exports.FloatController = exports.IntController = exports.SignController = exports.BooleanController = exports.PRNGControllerTypes = void 0;
+var prng_1 = __importDefault(require("./prng"));
+var PRNGControllerTypes;
+(function (PRNGControllerTypes) {
+    PRNGControllerTypes["Boolean"] = "Boolean";
+    PRNGControllerTypes["Sign"] = "Sign";
+    PRNGControllerTypes["Int"] = "Int";
+    PRNGControllerTypes["Float"] = "Float";
+    PRNGControllerTypes["HexColor"] = "HexColor";
+    PRNGControllerTypes["Item"] = "Item";
+    PRNGControllerTypes["ObjectProperty"] = "ObjectProperty";
+    PRNGControllerTypes["Weights"] = "Weights";
+})(PRNGControllerTypes || (exports.PRNGControllerTypes = PRNGControllerTypes = {}));
+// *********************
+// Abstract controllers
+// *********************
+var BasePRNGController = /** @class */ (function () {
+    function BasePRNGController(seed) {
+        this.seed = seed;
+        prng_1.default.addController(this);
+    }
+    BasePRNGController.prototype.dispose = function () {
+        var _a;
+        prng_1.default.removeController(this);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.destroy();
+    };
+    return BasePRNGController;
+}());
+var BasePRNGGroupController = /** @class */ (function () {
+    function BasePRNGGroupController(seed) {
+        this.controllers = [];
+        this.seed = seed;
+    }
+    BasePRNGGroupController.prototype.addGUI = function (gui, min, max, step) {
+        this.gui = gui.addFolder(this.seed).close();
+        this.guiArgs = { min: min, max: max, step: step };
+        return this.gui;
+    };
+    BasePRNGGroupController.prototype.getValueAt = function (index) {
+        var controller = this.controllers[index];
+        if (!controller) {
+            controller = this.createController(index);
+            if (this.gui) {
+                controller
+                    .addGUI(this.gui, this.guiArgs.min, this.guiArgs.max, this.guiArgs.step)
+                    .name("".concat(this.seed, "-").concat(index));
+            }
+            this.controllers[index] = controller;
+        }
+        return controller.value;
+    };
+    BasePRNGGroupController.prototype.dispose = function () {
+        var _a;
+        this.controllers.forEach(function (controller) { return controller.dispose(); });
+        this.controllers = [];
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.destroy();
+    };
+    return BasePRNGGroupController;
+}());
+// *********************
+// Controllers
+// *********************
+var BooleanController = /** @class */ (function (_super) {
+    __extends(BooleanController, _super);
+    function BooleanController(seed, probability) {
+        if (probability === void 0) { probability = 0.5; }
+        var _this = _super.call(this, seed) || this;
+        _this.probability = probability;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    BooleanController.prototype.addGUI = function (gui) {
+        this.gui = gui.add(this, 'value').name(this.seed);
+        return this.gui;
+    };
+    BooleanController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomBoolean(this.seed, this.probability);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return BooleanController;
+}(BasePRNGController));
+exports.BooleanController = BooleanController;
+var SignController = /** @class */ (function (_super) {
+    __extends(SignController, _super);
+    function SignController(seed, probability) {
+        if (probability === void 0) { probability = 0.5; }
+        var _this = _super.call(this, seed) || this;
+        _this.probability = probability;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    SignController.prototype.addGUI = function (gui) {
+        this.gui = gui.add(this, 'value', [-1, 1]).name(this.seed);
+        return this.gui;
+    };
+    SignController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomSign(this.seed, this.probability);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return SignController;
+}(BasePRNGController));
+exports.SignController = SignController;
+var IntController = /** @class */ (function (_super) {
+    __extends(IntController, _super);
+    function IntController(seed, min, max) {
+        if (min === void 0) { min = 0; }
+        if (max === void 0) { max = 1; }
+        var _this = _super.call(this, seed) || this;
+        _this.min = min;
+        _this.max = max;
+        _this.value = prng_1.default.randomInt(_this.seed, min, max);
+        return _this;
+    }
+    IntController.prototype.addGUI = function (gui, min, max, step) {
+        if (step === void 0) { step = 1; }
+        this.gui = gui.add(this, 'value', min, max, step).name(this.seed);
+        return this.gui;
+    };
+    IntController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomInt(this.seed, this.min, this.max);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return IntController;
+}(BasePRNGController));
+exports.IntController = IntController;
+var FloatController = /** @class */ (function (_super) {
+    __extends(FloatController, _super);
+    function FloatController(seed, min, max) {
+        if (min === void 0) { min = 0; }
+        if (max === void 0) { max = 1; }
+        var _this = _super.call(this, seed) || this;
+        _this.min = min;
+        _this.max = max;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    FloatController.prototype.addGUI = function (gui, min, max, step) {
+        if (step === void 0) { step = 0.01; }
+        this.gui = gui.add(this, 'value', min, max, step).name(this.seed);
+        return this.gui;
+    };
+    FloatController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomFloat(this.seed, this.min, this.max);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return FloatController;
+}(BasePRNGController));
+exports.FloatController = FloatController;
+var HexColorController = /** @class */ (function (_super) {
+    __extends(HexColorController, _super);
+    function HexColorController(seed) {
+        var _this = _super.call(this, seed) || this;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    HexColorController.prototype.addGUI = function (gui) {
+        this.gui = gui.addColor(this, 'value').name(this.seed);
+        return this.gui;
+    };
+    HexColorController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomHexColor(this.seed);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return HexColorController;
+}(BasePRNGController));
+exports.HexColorController = HexColorController;
+var ItemController = /** @class */ (function (_super) {
+    __extends(ItemController, _super);
+    function ItemController(seed, items) {
+        var _this = _super.call(this, seed) || this;
+        _this.items = items;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    ItemController.prototype.addGUI = function (gui) {
+        this.gui = gui.add(this, 'value', this.items).name(this.seed);
+        return this.gui;
+    };
+    ItemController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomItem(this.seed, this.items);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return ItemController;
+}(BasePRNGController));
+exports.ItemController = ItemController;
+var ObjectPropertyController = /** @class */ (function (_super) {
+    __extends(ObjectPropertyController, _super);
+    function ObjectPropertyController(seed, object) {
+        var _this = _super.call(this, seed) || this;
+        _this.object = object;
+        _this.value = _this.getValue();
+        return _this;
+    }
+    ObjectPropertyController.prototype.addGUI = function (gui) {
+        this.gui = gui.add(this, 'value', this.object).name(this.seed);
+        return this.gui;
+    };
+    ObjectPropertyController.prototype.getValue = function () {
+        var _a;
+        this.value = prng_1.default.randomObjectProperty(this.seed, this.object);
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return ObjectPropertyController;
+}(BasePRNGController));
+exports.ObjectPropertyController = ObjectPropertyController;
+var WeightsController = /** @class */ (function (_super) {
+    __extends(WeightsController, _super);
+    function WeightsController(seed, items) {
+        var _this = _super.call(this, seed) || this;
+        _this.items = items;
+        _this.weights = _this.items.map(function (item) { return item.weight; });
+        _this.value = _this.getValue();
+        return _this;
+    }
+    WeightsController.prototype.addGUI = function (gui) {
+        this.gui = gui
+            .add(this, 'value', this.items.map(function (item) { return item.value; }))
+            .name(this.seed);
+        return this.gui;
+    };
+    WeightsController.prototype.getValue = function () {
+        var _a;
+        var index = prng_1.default.randomIndex(this.seed, this.weights);
+        this.value = this.items[index].value;
+        (_a = this.gui) === null || _a === void 0 ? void 0 : _a.updateDisplay();
+        return this.value;
+    };
+    return WeightsController;
+}(BasePRNGController));
+exports.WeightsController = WeightsController;
+// *********************
+// Group Controllers
+// *********************
+var BooleanGroupController = /** @class */ (function (_super) {
+    __extends(BooleanGroupController, _super);
+    function BooleanGroupController(seed, probability) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.probability = probability;
+        return _this;
+    }
+    BooleanGroupController.prototype.createController = function (index) {
+        return new BooleanController("".concat(this.seed, "-").concat(index), this.probability);
+    };
+    return BooleanGroupController;
+}(BasePRNGGroupController));
+exports.BooleanGroupController = BooleanGroupController;
+var SignGroupController = /** @class */ (function (_super) {
+    __extends(SignGroupController, _super);
+    function SignGroupController(seed, probability) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.probability = probability;
+        return _this;
+    }
+    SignGroupController.prototype.createController = function (index) {
+        return new SignController("".concat(this.seed, "-").concat(index), this.probability);
+    };
+    return SignGroupController;
+}(BasePRNGGroupController));
+exports.SignGroupController = SignGroupController;
+var IntGroupController = /** @class */ (function (_super) {
+    __extends(IntGroupController, _super);
+    function IntGroupController(seed, min, max) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.min = min;
+        _this.max = max;
+        return _this;
+    }
+    IntGroupController.prototype.createController = function (index) {
+        return new IntController("".concat(this.seed, "-").concat(index), this.min, this.max);
+    };
+    return IntGroupController;
+}(BasePRNGGroupController));
+exports.IntGroupController = IntGroupController;
+var FloatGroupController = /** @class */ (function (_super) {
+    __extends(FloatGroupController, _super);
+    function FloatGroupController(seed, min, max) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.min = min;
+        _this.max = max;
+        return _this;
+    }
+    FloatGroupController.prototype.createController = function (index) {
+        return new FloatController("".concat(this.seed, "-").concat(index), this.min, this.max);
+    };
+    return FloatGroupController;
+}(BasePRNGGroupController));
+exports.FloatGroupController = FloatGroupController;
+var HexColorGroupController = /** @class */ (function (_super) {
+    __extends(HexColorGroupController, _super);
+    function HexColorGroupController() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.controllers = [];
+        return _this;
+    }
+    // constructor(seed: string) {
+    //   super(seed);
+    // }
+    HexColorGroupController.prototype.createController = function (index) {
+        return new HexColorController("".concat(this.seed, "-").concat(index));
+    };
+    return HexColorGroupController;
+}(BasePRNGGroupController));
+exports.HexColorGroupController = HexColorGroupController;
+var ItemGroupController = /** @class */ (function (_super) {
+    __extends(ItemGroupController, _super);
+    function ItemGroupController(seed, items) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.items = items;
+        return _this;
+    }
+    ItemGroupController.prototype.createController = function (index) {
+        return new ItemController("".concat(this.seed, "-").concat(index), this.items);
+    };
+    return ItemGroupController;
+}(BasePRNGGroupController));
+exports.ItemGroupController = ItemGroupController;
+var ObjectPropertyGroupController = /** @class */ (function (_super) {
+    __extends(ObjectPropertyGroupController, _super);
+    function ObjectPropertyGroupController(seed, object) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.object = object;
+        return _this;
+    }
+    ObjectPropertyGroupController.prototype.createController = function (index) {
+        return new ObjectPropertyController("".concat(this.seed, "-").concat(index), this.object);
+    };
+    return ObjectPropertyGroupController;
+}(BasePRNGGroupController));
+exports.ObjectPropertyGroupController = ObjectPropertyGroupController;
+var WeightsGroupController = /** @class */ (function (_super) {
+    __extends(WeightsGroupController, _super);
+    function WeightsGroupController(seed, items) {
+        var _this = _super.call(this, seed) || this;
+        _this.controllers = [];
+        _this.items = items;
+        return _this;
+    }
+    WeightsGroupController.prototype.createController = function (index) {
+        return new WeightsController("".concat(this.seed, "-").concat(index), this.items);
+    };
+    return WeightsGroupController;
+}(BasePRNGGroupController));
+exports.WeightsGroupController = WeightsGroupController;

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export { BooleanController, SignController, IntController, FloatController, HexColorController, ItemController, ObjectPropertyController, WeightsController, BooleanGroupController, SignGroupController, IntGroupController, FloatGroupController, HexColorGroupController, ItemGroupController, ObjectPropertyGroupController, WeightsGroupController } from './controllers';
+export { cyrb128, sfc32, mulberry32, jsf32, xoshiro128ss } from './utils';
+export type { PRNGControllerTypes, PRNGController, PRNGGroupController } from './controllers';
+export { default } from './prng';

package/lib/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.xoshiro128ss = exports.jsf32 = exports.mulberry32 = exports.sfc32 = exports.cyrb128 = exports.WeightsGroupController = exports.ObjectPropertyGroupController = exports.ItemGroupController = exports.HexColorGroupController = exports.FloatGroupController = exports.IntGroupController = exports.SignGroupController = exports.BooleanGroupController = exports.WeightsController = exports.ObjectPropertyController = exports.ItemController = exports.HexColorController = exports.FloatController = exports.IntController = exports.SignController = exports.BooleanController = void 0;
+var controllers_1 = require("./controllers");
+Object.defineProperty(exports, "BooleanController", { enumerable: true, get: function () { return controllers_1.BooleanController; } });
+Object.defineProperty(exports, "SignController", { enumerable: true, get: function () { return controllers_1.SignController; } });
+Object.defineProperty(exports, "IntController", { enumerable: true, get: function () { return controllers_1.IntController; } });
+Object.defineProperty(exports, "FloatController", { enumerable: true, get: function () { return controllers_1.FloatController; } });
+Object.defineProperty(exports, "HexColorController", { enumerable: true, get: function () { return controllers_1.HexColorController; } });
+Object.defineProperty(exports, "ItemController", { enumerable: true, get: function () { return controllers_1.ItemController; } });
+Object.defineProperty(exports, "ObjectPropertyController", { enumerable: true, get: function () { return controllers_1.ObjectPropertyController; } });
+Object.defineProperty(exports, "WeightsController", { enumerable: true, get: function () { return controllers_1.WeightsController; } });
+Object.defineProperty(exports, "BooleanGroupController", { enumerable: true, get: function () { return controllers_1.BooleanGroupController; } });
+Object.defineProperty(exports, "SignGroupController", { enumerable: true, get: function () { return controllers_1.SignGroupController; } });
+Object.defineProperty(exports, "IntGroupController", { enumerable: true, get: function () { return controllers_1.IntGroupController; } });
+Object.defineProperty(exports, "FloatGroupController", { enumerable: true, get: function () { return controllers_1.FloatGroupController; } });
+Object.defineProperty(exports, "HexColorGroupController", { enumerable: true, get: function () { return controllers_1.HexColorGroupController; } });
+Object.defineProperty(exports, "ItemGroupController", { enumerable: true, get: function () { return controllers_1.ItemGroupController; } });
+Object.defineProperty(exports, "ObjectPropertyGroupController", { enumerable: true, get: function () { return controllers_1.ObjectPropertyGroupController; } });
+Object.defineProperty(exports, "WeightsGroupController", { enumerable: true, get: function () { return controllers_1.WeightsGroupController; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "cyrb128", { enumerable: true, get: function () { return utils_1.cyrb128; } });
+Object.defineProperty(exports, "sfc32", { enumerable: true, get: function () { return utils_1.sfc32; } });
+Object.defineProperty(exports, "mulberry32", { enumerable: true, get: function () { return utils_1.mulberry32; } });
+Object.defineProperty(exports, "jsf32", { enumerable: true, get: function () { return utils_1.jsf32; } });
+Object.defineProperty(exports, "xoshiro128ss", { enumerable: true, get: function () { return utils_1.xoshiro128ss; } });
+var prng_1 = require("./prng");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(prng_1).default; } });

package/lib/prng.d.ts

@@ -0,0 +1,28 @@
+import { PRNGController } from './controllers';
+export declare enum PRNGMethod {
+    jsf32 = "jsf32",
+    mulberry32 = "mulberry32",
+    sfc32 = "sfc32",
+    xoshiro128ss = "xoshiro128**"
+}
+declare class PRNG {
+    seed: string;
+    method: PRNGMethod;
+    controllers: PRNGController[];
+    constructor(seed?: string);
+    addController(controller: PRNGController): void;
+    removeController(controller: PRNGController): void;
+    setSeed(seed: string): void;
+    setMethod(method: PRNGMethod): void;
+    random(seed: string): number;
+    randomBoolean(seed: string, probability?: number): boolean;
+    randomSign(seed: string, probability?: number): number;
+    randomInt(seed: string, min: number, max: number): number;
+    randomFloat(seed: string, min?: number, max?: number, precision?: number): number;
+    randomHexColor(seed: string): string;
+    randomItem<T = unknown>(seed: string, array?: T[]): T | undefined;
+    randomObjectProperty(seed: string, object: object): unknown | undefined;
+    randomIndex(seed: string, weights?: number[]): number;
+}
+declare const prng: PRNG;
+export default prng;