tsparticles 1.40.2 → 1.41.3

package/umd/Options/Classes/Interactivity/Modes/Repulse.js

@@ -0,0 +1,37 @@
+(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", "./RepulseBase", "./RepulseDiv"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Repulse = void 0;
+    const RepulseBase_1 = require("./RepulseBase");
+    const RepulseDiv_1 = require("./RepulseDiv");
+    class Repulse extends RepulseBase_1.RepulseBase {
+        load(data) {
+            super.load(data);
+            if ((data === null || data === void 0 ? void 0 : data.divs) === undefined) {
+                return;
+            }
+            if (data.divs instanceof Array) {
+                this.divs = data.divs.map((s) => {
+                    const tmp = new RepulseDiv_1.RepulseDiv();
+                    tmp.load(s);
+                    return tmp;
+                });
+            }
+            else {
+                if (this.divs instanceof Array || !this.divs) {
+                    this.divs = new RepulseDiv_1.RepulseDiv();
+                }
+                this.divs.load(data.divs);
+            }
+        }
+    }
+    exports.Repulse = Repulse;
+});

package/umd/Options/Classes/Interactivity/Modes/RepulseBase.d.ts

@@ -0,0 +1,14 @@
+import { EasingType } from "../../../../Enums";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulseBase } from "../../../Interfaces/Interactivity/Modes/IRepulseBase";
+import type { RecursivePartial } from "../../../../Types";
+export declare abstract class RepulseBase implements IRepulseBase, IOptionLoader<IRepulseBase> {
+    distance: number;
+    duration: number;
+    easing: EasingType;
+    factor: number;
+    maxSpeed: number;
+    speed: number;
+    constructor();
+    load(data?: RecursivePartial<IRepulseBase>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/RepulseBase.js

@@ -0,0 +1,47 @@
+(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.RepulseBase = void 0;
+    class RepulseBase {
+        constructor() {
+            this.distance = 200;
+            this.duration = 0.4;
+            this.factor = 100;
+            this.speed = 1;
+            this.maxSpeed = 50;
+            this.easing = "ease-out-quad";
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.distance !== undefined) {
+                this.distance = data.distance;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            if (data.easing !== undefined) {
+                this.easing = data.easing;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.speed !== undefined) {
+                this.speed = data.speed;
+            }
+            if (data.maxSpeed !== undefined) {
+                this.maxSpeed = data.maxSpeed;
+            }
+        }
+    }
+    exports.RepulseBase = RepulseBase;
+});

package/umd/Options/Classes/Interactivity/Modes/RepulseDiv.d.ts

@@ -0,0 +1,11 @@
+import type { RecursivePartial, SingleOrMultiple } from "../../../../Types";
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IRepulseDiv } from "../../../Interfaces/Interactivity/Modes/IRepulseDiv";
+import { RepulseBase } from "./RepulseBase";
+export declare class RepulseDiv extends RepulseBase implements IRepulseDiv, IOptionLoader<IRepulseDiv> {
+    get ids(): SingleOrMultiple<string>;
+    set ids(value: SingleOrMultiple<string>);
+    selectors: SingleOrMultiple<string>;
+    constructor();
+    load(data?: RecursivePartial<IRepulseDiv>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/RepulseDiv.js

@@ -0,0 +1,49 @@
+(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", "./RepulseBase"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RepulseDiv = void 0;
+    const RepulseBase_1 = require("./RepulseBase");
+    class RepulseDiv extends RepulseBase_1.RepulseBase {
+        constructor() {
+            super();
+            this.selectors = [];
+        }
+        get ids() {
+            if (this.selectors instanceof Array) {
+                return this.selectors.map((t) => t.replace("#", ""));
+            }
+            else {
+                return this.selectors.replace("#", "");
+            }
+        }
+        set ids(value) {
+            if (value instanceof Array) {
+                this.selectors = value.map(() => `#${value}`);
+            }
+            else {
+                this.selectors = `#${value}`;
+            }
+        }
+        load(data) {
+            super.load(data);
+            if (data === undefined) {
+                return;
+            }
+            if (data.ids !== undefined) {
+                this.ids = data.ids;
+            }
+            if (data.selectors !== undefined) {
+                this.selectors = data.selectors;
+            }
+        }
+    }
+    exports.RepulseDiv = RepulseDiv;
+});

package/umd/Options/Classes/Interactivity/Modes/Slow.d.ts

@@ -0,0 +1,11 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { ISlow } from "../../../Interfaces/Interactivity/Modes/ISlow";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Slow implements ISlow, IOptionLoader<ISlow> {
+    get active(): boolean;
+    set active(_value: boolean);
+    factor: number;
+    radius: number;
+    constructor();
+    load(data?: RecursivePartial<ISlow>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Slow.js

@@ -0,0 +1,36 @@
+(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.Slow = void 0;
+    class Slow {
+        constructor() {
+            this.factor = 3;
+            this.radius = 200;
+        }
+        get active() {
+            return false;
+        }
+        set active(_value) {
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.radius !== undefined) {
+                this.radius = data.radius;
+            }
+        }
+    }
+    exports.Slow = Slow;
+});

package/umd/Options/Classes/Interactivity/Modes/Trail.d.ts

@@ -0,0 +1,12 @@
+import type { IOptionLoader } from "../../../Interfaces/IOptionLoader";
+import type { IParticles } from "../../../Interfaces/Particles/IParticles";
+import type { ITrail } from "../../../Interfaces/Interactivity/Modes/ITrail";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Trail implements ITrail, IOptionLoader<ITrail> {
+    delay: number;
+    particles?: RecursivePartial<IParticles>;
+    pauseOnStop: boolean;
+    quantity: number;
+    constructor();
+    load(data?: RecursivePartial<ITrail>): void;
+}

package/umd/Options/Classes/Interactivity/Modes/Trail.js

@@ -0,0 +1,39 @@
+(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", "../../../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Trail = void 0;
+    const Utils_1 = require("../../../../Utils");
+    class Trail {
+        constructor() {
+            this.delay = 1;
+            this.pauseOnStop = false;
+            this.quantity = 1;
+        }
+        load(data) {
+            if (data === undefined) {
+                return;
+            }
+            if (data.delay !== undefined) {
+                this.delay = data.delay;
+            }
+            if (data.quantity !== undefined) {
+                this.quantity = data.quantity;
+            }
+            if (data.particles !== undefined) {
+                this.particles = (0, Utils_1.deepExtend)({}, data.particles);
+            }
+            if (data.pauseOnStop !== undefined) {
+                this.pauseOnStop = data.pauseOnStop;
+            }
+        }
+    }
+    exports.Trail = Trail;
+});

package/umd/Options/Classes/ManualParticle.d.ts

@@ -0,0 +1,10 @@
+import type { ICoordinates } from "../../Core";
+import type { IManualParticle } from "../Interfaces/IManualParticle";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IParticles } from "../Interfaces/Particles/IParticles";
+import type { RecursivePartial } from "../../Types";
+export declare class ManualParticle implements IManualParticle, IOptionLoader<IManualParticle> {
+    options?: RecursivePartial<IParticles>;
+    position?: ICoordinates;
+    load(data?: RecursivePartial<IManualParticle>): void;
+}

package/umd/Options/Classes/ManualParticle.js

@@ -0,0 +1,32 @@
+(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", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ManualParticle = void 0;
+    const Utils_1 = require("../../Utils");
+    class ManualParticle {
+        load(data) {
+            var _a, _b;
+            if (!data) {
+                return;
+            }
+            if (data.position !== undefined) {
+                this.position = {
+                    x: (_a = data.position.x) !== null && _a !== void 0 ? _a : 50,
+                    y: (_b = data.position.y) !== null && _b !== void 0 ? _b : 50,
+                };
+            }
+            if (data.options !== undefined) {
+                this.options = (0, Utils_1.deepExtend)({}, data.options);
+            }
+        }
+    }
+    exports.ManualParticle = ManualParticle;
+});

package/umd/Options/Classes/Motion/Motion.d.ts

@@ -0,0 +1,10 @@
+import type { IMotion } from "../../Interfaces/Motion/IMotion";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import { MotionReduce } from "./MotionReduce";
+import type { RecursivePartial } from "../../../Types";
+export declare class Motion implements IMotion, IOptionLoader<IMotion> {
+    disable: boolean;
+    reduce: MotionReduce;
+    constructor();
+    load(data?: RecursivePartial<IMotion>): void;
+}

package/umd/Options/Classes/Motion/Motion.js

@@ -0,0 +1,30 @@
+(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", "./MotionReduce"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Motion = void 0;
+    const MotionReduce_1 = require("./MotionReduce");
+    class Motion {
+        constructor() {
+            this.disable = false;
+            this.reduce = new MotionReduce_1.MotionReduce();
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.disable !== undefined) {
+                this.disable = data.disable;
+            }
+            this.reduce.load(data.reduce);
+        }
+    }
+    exports.Motion = Motion;
+});

package/umd/Options/Classes/Motion/MotionReduce.d.ts

@@ -0,0 +1,9 @@
+import type { IMotionReduce } from "../../Interfaces/Motion/IMotionReduce";
+import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
+import type { RecursivePartial } from "../../../Types";
+export declare class MotionReduce implements IMotionReduce, IOptionLoader<IMotionReduce> {
+    factor: number;
+    value: boolean;
+    constructor();
+    load(data?: RecursivePartial<IMotionReduce>): void;
+}

package/umd/Options/Classes/Motion/MotionReduce.js

@@ -0,0 +1,31 @@
+(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.MotionReduce = void 0;
+    class MotionReduce {
+        constructor() {
+            this.factor = 4;
+            this.value = true;
+        }
+        load(data) {
+            if (!data) {
+                return;
+            }
+            if (data.factor !== undefined) {
+                this.factor = data.factor;
+            }
+            if (data.value !== undefined) {
+                this.value = data.value;
+            }
+        }
+    }
+    exports.MotionReduce = MotionReduce;
+});

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

@@ -0,0 +1,48 @@
+import type { RangeValue, RecursivePartial } from "../../Types";
+import { Background } from "./Background/Background";
+import { BackgroundMask } from "./BackgroundMask/BackgroundMask";
+import type { Engine } from "../../engine";
+import { FullScreen } from "./FullScreen/FullScreen";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IOptions } from "../Interfaces/IOptions";
+import { Interactivity } from "./Interactivity/Interactivity";
+import { ManualParticle } from "./ManualParticle";
+import { Motion } from "./Motion/Motion";
+import { ParticlesOptions } from "./Particles/ParticlesOptions";
+import { Responsive } from "./Responsive";
+import { Theme } from "./Theme/Theme";
+export declare class Options implements IOptions, IOptionLoader<IOptions> {
+    #private;
+    get fps_limit(): number;
+    set fps_limit(value: number);
+    get retina_detect(): boolean;
+    set retina_detect(value: boolean);
+    get backgroundMode(): FullScreen;
+    set backgroundMode(value: FullScreen);
+    autoPlay: boolean;
+    background: Background;
+    backgroundMask: BackgroundMask;
+    detectRetina: boolean;
+    duration: RangeValue;
+    fpsLimit: number;
+    fullScreen: FullScreen;
+    interactivity: Interactivity;
+    manualParticles: ManualParticle[];
+    motion: Motion;
+    particles: ParticlesOptions;
+    pauseOnBlur: boolean;
+    pauseOnOutsideViewport: boolean;
+    preset?: string | string[];
+    style: RecursivePartial<CSSStyleDeclaration>;
+    responsive: Responsive[];
+    themes: Theme[];
+    zLayers: number;
+    defaultDarkTheme?: string;
+    defaultLightTheme?: string;
+    [name: string]: unknown;
+    constructor(engine: Engine);
+    load(data?: RecursivePartial<IOptions>): void;
+    setTheme(name?: string): void;
+    setResponsive(width: number, pxRatio: number, defaultOptions: IOptions): number | undefined;
+    private importPreset;
+}

package/umd/Options/Classes/Options.js

@@ -0,0 +1,184 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+(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", "./Background/Background", "./BackgroundMask/BackgroundMask", "./FullScreen/FullScreen", "./Interactivity/Interactivity", "./ManualParticle", "./Motion/Motion", "./Particles/ParticlesOptions", "./Responsive", "./Theme/Theme", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _Options_instances, _Options_engine, _Options_findDefaultTheme;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Options = void 0;
+    const Background_1 = require("./Background/Background");
+    const BackgroundMask_1 = require("./BackgroundMask/BackgroundMask");
+    const FullScreen_1 = require("./FullScreen/FullScreen");
+    const Interactivity_1 = require("./Interactivity/Interactivity");
+    const ManualParticle_1 = require("./ManualParticle");
+    const Motion_1 = require("./Motion/Motion");
+    const ParticlesOptions_1 = require("./Particles/ParticlesOptions");
+    const Responsive_1 = require("./Responsive");
+    const Theme_1 = require("./Theme/Theme");
+    const Utils_1 = require("../../Utils");
+    class Options {
+        constructor(engine) {
+            _Options_instances.add(this);
+            _Options_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _Options_engine, engine, "f");
+            this.autoPlay = true;
+            this.background = new Background_1.Background();
+            this.backgroundMask = new BackgroundMask_1.BackgroundMask();
+            this.fullScreen = new FullScreen_1.FullScreen();
+            this.detectRetina = true;
+            this.duration = 0;
+            this.fpsLimit = 120;
+            this.interactivity = new Interactivity_1.Interactivity();
+            this.manualParticles = [];
+            this.motion = new Motion_1.Motion();
+            this.particles = new ParticlesOptions_1.ParticlesOptions();
+            this.pauseOnBlur = true;
+            this.pauseOnOutsideViewport = true;
+            this.responsive = [];
+            this.style = {};
+            this.themes = [];
+            this.zLayers = 100;
+        }
+        get fps_limit() {
+            return this.fpsLimit;
+        }
+        set fps_limit(value) {
+            this.fpsLimit = value;
+        }
+        get retina_detect() {
+            return this.detectRetina;
+        }
+        set retina_detect(value) {
+            this.detectRetina = value;
+        }
+        get backgroundMode() {
+            return this.fullScreen;
+        }
+        set backgroundMode(value) {
+            this.fullScreen.load(value);
+        }
+        load(data) {
+            var _a, _b, _c, _d, _e;
+            if (data === undefined) {
+                return;
+            }
+            if (data.preset !== undefined) {
+                if (data.preset instanceof Array) {
+                    for (const preset of data.preset) {
+                        this.importPreset(preset);
+                    }
+                }
+                else {
+                    this.importPreset(data.preset);
+                }
+            }
+            if (data.autoPlay !== undefined) {
+                this.autoPlay = data.autoPlay;
+            }
+            const detectRetina = (_a = data.detectRetina) !== null && _a !== void 0 ? _a : data.retina_detect;
+            if (detectRetina !== undefined) {
+                this.detectRetina = detectRetina;
+            }
+            if (data.duration !== undefined) {
+                this.duration = data.duration;
+            }
+            const fpsLimit = (_b = data.fpsLimit) !== null && _b !== void 0 ? _b : data.fps_limit;
+            if (fpsLimit !== undefined) {
+                this.fpsLimit = fpsLimit;
+            }
+            if (data.pauseOnBlur !== undefined) {
+                this.pauseOnBlur = data.pauseOnBlur;
+            }
+            if (data.pauseOnOutsideViewport !== undefined) {
+                this.pauseOnOutsideViewport = data.pauseOnOutsideViewport;
+            }
+            if (data.zLayers !== undefined) {
+                this.zLayers = data.zLayers;
+            }
+            this.background.load(data.background);
+            const fullScreen = (_c = data.fullScreen) !== null && _c !== void 0 ? _c : data.backgroundMode;
+            if (typeof fullScreen === "boolean") {
+                this.fullScreen.enable = fullScreen;
+            }
+            else {
+                this.fullScreen.load(fullScreen);
+            }
+            this.backgroundMask.load(data.backgroundMask);
+            this.interactivity.load(data.interactivity);
+            if (data.manualParticles !== undefined) {
+                this.manualParticles = data.manualParticles.map((t) => {
+                    const tmp = new ManualParticle_1.ManualParticle();
+                    tmp.load(t);
+                    return tmp;
+                });
+            }
+            this.motion.load(data.motion);
+            this.particles.load(data.particles);
+            this.style = (0, Utils_1.deepExtend)(this.style, data.style);
+            __classPrivateFieldGet(this, _Options_engine, "f").plugins.loadOptions(this, data);
+            if (data.responsive !== undefined) {
+                for (const responsive of data.responsive) {
+                    const optResponsive = new Responsive_1.Responsive();
+                    optResponsive.load(responsive);
+                    this.responsive.push(optResponsive);
+                }
+            }
+            this.responsive.sort((a, b) => a.maxWidth - b.maxWidth);
+            if (data.themes !== undefined) {
+                for (const theme of data.themes) {
+                    const optTheme = new Theme_1.Theme();
+                    optTheme.load(theme);
+                    this.themes.push(optTheme);
+                }
+            }
+            this.defaultDarkTheme = (_d = __classPrivateFieldGet(this, _Options_instances, "m", _Options_findDefaultTheme).call(this, "dark")) === null || _d === void 0 ? void 0 : _d.name;
+            this.defaultLightTheme = (_e = __classPrivateFieldGet(this, _Options_instances, "m", _Options_findDefaultTheme).call(this, "light")) === null || _e === void 0 ? void 0 : _e.name;
+        }
+        setTheme(name) {
+            if (name) {
+                const chosenTheme = this.themes.find((theme) => theme.name === name);
+                if (chosenTheme) {
+                    this.load(chosenTheme.options);
+                }
+            }
+            else {
+                const mediaMatch = typeof matchMedia !== "undefined" && matchMedia("(prefers-color-scheme: dark)"), clientDarkMode = mediaMatch && mediaMatch.matches, defaultTheme = __classPrivateFieldGet(this, _Options_instances, "m", _Options_findDefaultTheme).call(this, clientDarkMode ? "dark" : "light");
+                if (defaultTheme) {
+                    this.load(defaultTheme.options);
+                }
+            }
+        }
+        setResponsive(width, pxRatio, defaultOptions) {
+            this.load(defaultOptions);
+            const responsiveOptions = this.responsive.find((t) => t.mode === "screen" && screen
+                ? t.maxWidth * pxRatio > screen.availWidth
+                : t.maxWidth * pxRatio > width);
+            this.load(responsiveOptions === null || responsiveOptions === void 0 ? void 0 : responsiveOptions.options);
+            return responsiveOptions === null || responsiveOptions === void 0 ? void 0 : responsiveOptions.maxWidth;
+        }
+        importPreset(preset) {
+            this.load(__classPrivateFieldGet(this, _Options_engine, "f").plugins.getPreset(preset));
+        }
+    }
+    exports.Options = Options;
+    _Options_engine = new WeakMap(), _Options_instances = new WeakSet(), _Options_findDefaultTheme = function _Options_findDefaultTheme(mode) {
+        var _a;
+        return ((_a = this.themes.find((theme) => theme.default.value && theme.default.mode === mode)) !== null && _a !== void 0 ? _a : this.themes.find((theme) => theme.default.value && theme.default.mode === "any"));
+    };
+});

package/umd/Options/Classes/OptionsColor.d.ts

@@ -0,0 +1,10 @@
+import type { IHsl, IHsv, IRgb, IValueColor } from "../../Core/Interfaces";
+import type { RecursivePartial, SingleOrMultiple } from "../../Types";
+import type { IOptionLoader } from "../Interfaces/IOptionLoader";
+import type { IOptionsColor } from "../Interfaces/IOptionsColor";
+export declare class OptionsColor implements IOptionsColor, IOptionLoader<IOptionsColor> {
+    value: SingleOrMultiple<SingleOrMultiple<string> | IValueColor | IRgb | IHsl | IHsv>;
+    constructor();
+    static create(source?: OptionsColor, data?: SingleOrMultiple<string> | RecursivePartial<IOptionsColor>): OptionsColor;
+    load(data?: RecursivePartial<IOptionsColor>): void;
+}