tsparticles 1.40.2 → 1.41.3

package/umd/Options/Classes/Particles/Number/Density.js

@@ -0,0 +1,43 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Density = void 0;
+    class Density {
+        constructor() {
+            this.enable = false;
+            this.area = 800;
+            this.factor = 1000;
+        }
+        get value_area() {
+            return this.area;
+        }
+        set value_area(value) {
+            this.area = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            const area = (_a = data.area) !== null && _a !== void 0 ? _a : data.value_area;
+            if (area !== undefined) {
+                this.area = area;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+        }
+    }
+    exports.Density = Density;
+});

package/umd/Options/Classes/Particles/Number/ParticlesNumber.d.ts

@@ -0,0 +1,13 @@
+import { Density } from "./Density";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticlesNumber } from "../../../Interfaces/Particles/Number/IParticlesNumber";
+import type { RecursivePartial } from "../../../../Types";
+export declare class ParticlesNumber implements IParticlesNumber, IOptionLoader<IParticlesNumber> {
+    get max(): number;
+    set max(value: number);
+    density: Density;
+    limit: number;
+    value: number;
+    constructor();
+    load(data?: RecursivePartial<IParticlesNumber>): void;
+}

package/umd/Options/Classes/Particles/Number/ParticlesNumber.js

@@ -0,0 +1,42 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Density"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ParticlesNumber = void 0;
+    const Density_1 = require("./Density");
+    class ParticlesNumber {
+        constructor() {
+            this.density = new Density_1.Density();
+            this.limit = 0;
+            this.value = 100;
+        }
+        get max() {
+            return this.limit;
+        }
+        set max(value) {
+            this.limit = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            this.density.load(data.density);
+            const limit = (_a = data.limit) !== null && _a !== void 0 ? _a : data.max;
+            if (limit !== undefined) {
+                this.limit = limit;
+            }
+            if (data.value !== undefined) {
+                this.value = data.value;
+            }
+        }
+    }
+    exports.ParticlesNumber = ParticlesNumber;
+});

package/umd/Options/Classes/Particles/Opacity/Opacity.d.ts

@@ -0,0 +1,12 @@
+import type { IOpacity } from "../../../Interfaces/Particles/Opacity/IOpacity";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import { OpacityAnimation } from "./OpacityAnimation";
+import type { RecursivePartial } from "../../../../Types";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class Opacity extends ValueWithRandom implements IOpacity, IOptionLoader<IOpacity> {
+    get anim(): OpacityAnimation;
+    set anim(value: OpacityAnimation);
+    animation: OpacityAnimation;
+    constructor();
+    load(data?: RecursivePartial<IOpacity>): void;
+}

package/umd/Options/Classes/Particles/Opacity/Opacity.js

@@ -0,0 +1,43 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./OpacityAnimation", "../../ValueWithRandom", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Opacity = void 0;
+    const OpacityAnimation_1 = require("./OpacityAnimation");
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    const Utils_1 = require("../../../../Utils");
+    class Opacity extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.animation = new OpacityAnimation_1.OpacityAnimation();
+            this.random.minimumValue = 0.1;
+            this.value = 1;
+        }
+        get anim() {
+            return this.animation;
+        }
+        set anim(value) {
+            this.animation = value;
+        }
+        load(data) {
+            var _a;
+            if (!data) {
+                return;
+            }
+            super.load(data);
+            const animation = (_a = data.animation) !== null && _a !== void 0 ? _a : data.anim;
+            if (animation !== undefined) {
+                this.animation.load(animation);
+                this.value = (0, Utils_1.setRangeValue)(this.value, this.animation.enable ? this.animation.minimumValue : undefined);
+            }
+        }
+    }
+    exports.Opacity = Opacity;
+});

package/umd/Options/Classes/Particles/Opacity/OpacityAnimation.d.ts

@@ -0,0 +1,14 @@
+import { DestroyType, StartValueType } from "../../../../Enums";
+import { AnimationOptions } from "../../AnimationOptions";
+import type { IOpacityAnimation } from "../../../Interfaces/Particles/Opacity/IOpacityAnimation";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../../Types";
+export declare class OpacityAnimation extends AnimationOptions implements IOpacityAnimation, IOptionLoader<IOpacityAnimation> {
+    get opacity_min(): number | undefined;
+    set opacity_min(value: number | undefined);
+    minimumValue?: number;
+    destroy: DestroyType | keyof typeof DestroyType;
+    startValue: StartValueType | keyof typeof StartValueType;
+    constructor();
+    load(data?: RecursivePartial<IOpacityAnimation>): void;
+}

package/umd/Options/Classes/Particles/Opacity/OpacityAnimation.js

@@ -0,0 +1,54 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../AnimationOptions"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OpacityAnimation = void 0;
+    const AnimationOptions_1 = require("../../AnimationOptions");
+    class OpacityAnimation extends AnimationOptions_1.AnimationOptions {
+        constructor() {
+            super();
+            this.destroy = "none";
+            this.enable = false;
+            this.speed = 2;
+            this.startValue = "random";
+            this.sync = false;
+        }
+        get opacity_min() {
+            return this.minimumValue;
+        }
+        set opacity_min(value) {
+            this.minimumValue = value;
+        }
+        load(data) {
+            var _a;
+            if (data === undefined) {
+                return;
+            }
+            super.load(data);
+            if (data.destroy !== undefined) {
+                this.destroy = data.destroy;
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            this.minimumValue = (_a = data.minimumValue) !== null && _a !== void 0 ? _a : data.opacity_min;
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.startValue !== undefined) {
+                this.startValue = data.startValue;
+            }
+            if (data.sync !== undefined) {
+                this.sync = data.sync;
+            }
+        }
+    }
+    exports.OpacityAnimation = OpacityAnimation;
+});

package/umd/Options/Classes/Particles/Orbit/Orbit.d.ts

@@ -0,0 +1,18 @@
+import { AnimationOptions } from "../../AnimationOptions";
+import type { IAnimatable } from "../../../Interfaces/IAnimatable";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IOrbit } from "../../../Interfaces/Particles/Orbit/IOrbit";
+import { OptionsColor } from "../../OptionsColor";
+import { OrbitRotation } from "./OrbitRotation";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Orbit implements IOrbit, IOptionLoader<IOrbit>, IAnimatable<AnimationOptions> {
+    animation: AnimationOptions;
+    enable: boolean;
+    opacity: number;
+    width: number;
+    color?: OptionsColor;
+    radius?: number;
+    rotation: OrbitRotation;
+    constructor();
+    load(data?: RecursivePartial<IOrbit>): void;
+}

package/umd/Options/Classes/Particles/Orbit/Orbit.js

@@ -0,0 +1,48 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../AnimationOptions", "../../OptionsColor", "./OrbitRotation"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Orbit = void 0;
+    const AnimationOptions_1 = require("../../AnimationOptions");
+    const OptionsColor_1 = require("../../OptionsColor");
+    const OrbitRotation_1 = require("./OrbitRotation");
+    class Orbit {
+        constructor() {
+            this.animation = new AnimationOptions_1.AnimationOptions();
+            this.enable = false;
+            this.opacity = 1;
+            this.rotation = new OrbitRotation_1.OrbitRotation();
+            this.width = 1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            this.animation.load(data.animation);
+            this.rotation.load(data.rotation);
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = data.opacity;
+            }
+            if (data.width !== undefined) {
+                this.width = data.width;
+            }
+            if (data.radius !== undefined) {
+                this.radius = data.radius;
+            }
+            if (data.color !== undefined) {
+                this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
+            }
+        }
+    }
+    exports.Orbit = Orbit;
+});

package/umd/Options/Classes/Particles/Orbit/OrbitRotation.d.ts

@@ -0,0 +1,7 @@
+import type { IValueWithRandom } from "../../../Interfaces/IValueWithRandom";
+import type { RecursivePartial } from "../../../../Types";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class OrbitRotation extends ValueWithRandom {
+    constructor();
+    load(data?: RecursivePartial<IValueWithRandom>): void;
+}

package/umd/Options/Classes/Particles/Orbit/OrbitRotation.js

@@ -0,0 +1,29 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.OrbitRotation = void 0;
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    class OrbitRotation extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.value = 45;
+            this.random.enable = false;
+            this.random.minimumValue = 0;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            super.load(data);
+        }
+    }
+    exports.OrbitRotation = OrbitRotation;
+});

package/umd/Options/Classes/Particles/ParticlesOptions.d.ts

@@ -0,0 +1,58 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../Types";
+import { AnimatableColor } from "../AnimatableColor";
+import { AnimatableGradient } from "../AnimatableGradient";
+import { Bounce } from "./Bounce/Bounce";
+import { Collisions } from "./Collisions/Collisions";
+import { Destroy } from "./Destroy/Destroy";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { IParticles } from "../../Interfaces/Particles/IParticles";
+import { Life } from "./Life/Life";
+import { Links } from "./Links/Links";
+import { Move } from "./Move/Move";
+import { Opacity } from "./Opacity/Opacity";
+import { Orbit } from "./Orbit/Orbit";
+import type { ParticlesGroups } from "../../../Types/ParticlesGroups";
+import { ParticlesNumber } from "./Number/ParticlesNumber";
+import { Repulse } from "./Repulse/Repulse";
+import { Roll } from "./Roll/Roll";
+import { Rotate } from "./Rotate/Rotate";
+import { Shadow } from "./Shadow";
+import { Shape } from "./Shape/Shape";
+import { Size } from "./Size/Size";
+import { Stroke } from "./Stroke";
+import { Tilt } from "./Tilt/Tilt";
+import { Twinkle } from "./Twinkle/Twinkle";
+import { Wobble } from "./Wobble/Wobble";
+import { ZIndex } from "./ZIndex/ZIndex";
+export declare class ParticlesOptions implements IParticles, IOptionLoader<IParticles> {
+    bounce: Bounce;
+    collisions: Collisions;
+    color: AnimatableColor;
+    destroy: Destroy;
+    gradient: SingleOrMultiple<AnimatableGradient>;
+    groups: ParticlesGroups;
+    life: Life;
+    links: Links;
+    move: Move;
+    number: ParticlesNumber;
+    opacity: Opacity;
+    orbit: Orbit;
+    reduceDuplicates: boolean;
+    repulse: Repulse;
+    roll: Roll;
+    rotate: Rotate;
+    shape: Shape;
+    size: Size;
+    shadow: Shadow;
+    stroke: SingleOrMultiple<Stroke>;
+    tilt: Tilt;
+    twinkle: Twinkle;
+    wobble: Wobble;
+    zIndex: ZIndex;
+    get line_linked(): Links;
+    set line_linked(value: Links);
+    get lineLinked(): Links;
+    set lineLinked(value: Links);
+    constructor();
+    load(data?: RecursivePartial<IParticles>): void;
+}

package/umd/Options/Classes/Particles/ParticlesOptions.js

@@ -0,0 +1,153 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../AnimatableColor", "../AnimatableGradient", "./Bounce/Bounce", "./Collisions/Collisions", "./Destroy/Destroy", "./Life/Life", "./Links/Links", "./Move/Move", "./Opacity/Opacity", "./Orbit/Orbit", "./Number/ParticlesNumber", "./Repulse/Repulse", "./Roll/Roll", "./Rotate/Rotate", "./Shadow", "./Shape/Shape", "./Size/Size", "./Stroke", "./Tilt/Tilt", "./Twinkle/Twinkle", "./Wobble/Wobble", "./ZIndex/ZIndex", "../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ParticlesOptions = void 0;
+    const AnimatableColor_1 = require("../AnimatableColor");
+    const AnimatableGradient_1 = require("../AnimatableGradient");
+    const Bounce_1 = require("./Bounce/Bounce");
+    const Collisions_1 = require("./Collisions/Collisions");
+    const Destroy_1 = require("./Destroy/Destroy");
+    const Life_1 = require("./Life/Life");
+    const Links_1 = require("./Links/Links");
+    const Move_1 = require("./Move/Move");
+    const Opacity_1 = require("./Opacity/Opacity");
+    const Orbit_1 = require("./Orbit/Orbit");
+    const ParticlesNumber_1 = require("./Number/ParticlesNumber");
+    const Repulse_1 = require("./Repulse/Repulse");
+    const Roll_1 = require("./Roll/Roll");
+    const Rotate_1 = require("./Rotate/Rotate");
+    const Shadow_1 = require("./Shadow");
+    const Shape_1 = require("./Shape/Shape");
+    const Size_1 = require("./Size/Size");
+    const Stroke_1 = require("./Stroke");
+    const Tilt_1 = require("./Tilt/Tilt");
+    const Twinkle_1 = require("./Twinkle/Twinkle");
+    const Wobble_1 = require("./Wobble/Wobble");
+    const ZIndex_1 = require("./ZIndex/ZIndex");
+    const Utils_1 = require("../../../Utils");
+    class ParticlesOptions {
+        constructor() {
+            this.bounce = new Bounce_1.Bounce();
+            this.collisions = new Collisions_1.Collisions();
+            this.color = new AnimatableColor_1.AnimatableColor();
+            this.destroy = new Destroy_1.Destroy();
+            this.gradient = [];
+            this.groups = {};
+            this.life = new Life_1.Life();
+            this.links = new Links_1.Links();
+            this.move = new Move_1.Move();
+            this.number = new ParticlesNumber_1.ParticlesNumber();
+            this.opacity = new Opacity_1.Opacity();
+            this.orbit = new Orbit_1.Orbit();
+            this.reduceDuplicates = false;
+            this.repulse = new Repulse_1.Repulse();
+            this.roll = new Roll_1.Roll();
+            this.rotate = new Rotate_1.Rotate();
+            this.shadow = new Shadow_1.Shadow();
+            this.shape = new Shape_1.Shape();
+            this.size = new Size_1.Size();
+            this.stroke = new Stroke_1.Stroke();
+            this.tilt = new Tilt_1.Tilt();
+            this.twinkle = new Twinkle_1.Twinkle();
+            this.wobble = new Wobble_1.Wobble();
+            this.zIndex = new ZIndex_1.ZIndex();
+        }
+        get line_linked() {
+            return this.links;
+        }
+        set line_linked(value) {
+            this.links = value;
+        }
+        get lineLinked() {
+            return this.links;
+        }
+        set lineLinked(value) {
+            this.links = value;
+        }
+        load(data) {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            if (data === undefined) {
+                return;
+            }
+            this.bounce.load(data.bounce);
+            this.color.load(AnimatableColor_1.AnimatableColor.create(this.color, data.color));
+            this.destroy.load(data.destroy);
+            this.life.load(data.life);
+            const links = (_b = (_a = data.links) !== null && _a !== void 0 ? _a : data.lineLinked) !== null && _b !== void 0 ? _b : data.line_linked;
+            if (links !== undefined) {
+                this.links.load(links);
+            }
+            if (data.groups !== undefined) {
+                for (const group in data.groups) {
+                    const item = data.groups[group];
+                    if (item !== undefined) {
+                        this.groups[group] = (0, Utils_1.deepExtend)((_c = this.groups[group]) !== null && _c !== void 0 ? _c : {}, item);
+                    }
+                }
+            }
+            this.move.load(data.move);
+            this.number.load(data.number);
+            this.opacity.load(data.opacity);
+            this.orbit.load(data.orbit);
+            if (data.reduceDuplicates !== undefined) {
+                this.reduceDuplicates = data.reduceDuplicates;
+            }
+            this.repulse.load(data.repulse);
+            this.roll.load(data.roll);
+            this.rotate.load(data.rotate);
+            this.shape.load(data.shape);
+            this.size.load(data.size);
+            this.shadow.load(data.shadow);
+            this.tilt.load(data.tilt);
+            this.twinkle.load(data.twinkle);
+            this.wobble.load(data.wobble);
+            this.zIndex.load(data.zIndex);
+            const collisions = (_e = (_d = data.move) === null || _d === void 0 ? void 0 : _d.collisions) !== null && _e !== void 0 ? _e : (_f = data.move) === null || _f === void 0 ? void 0 : _f.bounce;
+            if (collisions !== undefined) {
+                this.collisions.enable = collisions;
+            }
+            this.collisions.load(data.collisions);
+            const strokeToLoad = (_g = data.stroke) !== null && _g !== void 0 ? _g : (_h = data.shape) === null || _h === void 0 ? void 0 : _h.stroke;
+            if (strokeToLoad) {
+                if (strokeToLoad instanceof Array) {
+                    this.stroke = strokeToLoad.map((s) => {
+                        const tmp = new Stroke_1.Stroke();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    if (this.stroke instanceof Array) {
+                        this.stroke = new Stroke_1.Stroke();
+                    }
+                    this.stroke.load(strokeToLoad);
+                }
+            }
+            const gradientToLoad = data.gradient;
+            if (gradientToLoad) {
+                if (gradientToLoad instanceof Array) {
+                    this.gradient = gradientToLoad.map((s) => {
+                        const tmp = new AnimatableGradient_1.AnimatableGradient();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    if (this.gradient instanceof Array) {
+                        this.gradient = new AnimatableGradient_1.AnimatableGradient();
+                    }
+                    this.gradient.load(gradientToLoad);
+                }
+            }
+        }
+    }
+    exports.ParticlesOptions = ParticlesOptions;
+});

package/umd/Options/Classes/Particles/Repulse/Repulse.d.ts

@@ -0,0 +1,13 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulse } from "../../../Interfaces/Particles/Repulse/IRepulse";
+import type { RecursivePartial } from "../../../../Types";
+import { ValueWithRandom } from "../../ValueWithRandom";
+export declare class Repulse extends ValueWithRandom implements IRepulse, IOptionLoader<IRepulse> {
+    enabled: boolean;
+    distance: number;
+    duration: number;
+    factor: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IRepulse>): void;
+}

package/umd/Options/Classes/Particles/Repulse/Repulse.js

@@ -0,0 +1,46 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../../ValueWithRandom"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Repulse = void 0;
+    const ValueWithRandom_1 = require("../../ValueWithRandom");
+    class Repulse extends ValueWithRandom_1.ValueWithRandom {
+        constructor() {
+            super();
+            this.enabled = false;
+            this.distance = 1;
+            this.duration = 1;
+            this.factor = 1;
+            this.speed = 1;
+        }
+        load(data) {
+            super.load(data);
+            if (!data) {
+                return;
+            }
+            if (data.enabled !== undefined) {
+                this.enabled = data.enabled;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+        }
+    }
+    exports.Repulse = Repulse;
+});

package/umd/Options/Classes/Particles/Roll/Roll.d.ts

@@ -0,0 +1,16 @@
+import type { RangeValue, RecursivePartial } from "../../../../Types";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRoll } from "../../../Interfaces/Particles/Roll/IRoll";
+import { OptionsColor } from "../../OptionsColor";
+import { RollLight } from "./RollLight";
+import { RollMode } from "../../../../Enums";
+export declare class Roll implements IRoll, IOptionLoader<IRoll> {
+    backColor?: OptionsColor;
+    darken: RollLight;
+    enable: boolean;
+    enlighten: RollLight;
+    mode: RollMode | keyof typeof RollMode;
+    speed: RangeValue;
+    constructor();
+    load(data?: RecursivePartial<IRoll>): void;
+}