tsparticles 1.42.2 → 1.43.0

package/Interactions/Particles/Collisions/Collider.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collider = void 0;
-const Utils_1 = require("../../../Utils");
-const Core_1 = require("../../../Core");
-function bounce(p1, p2) {
-    (0, Utils_1.circleBounce)((0, Utils_1.circleBounceDataFromParticle)(p1), (0, Utils_1.circleBounceDataFromParticle)(p2));
-}
-function destroy(p1, p2) {
-    if (!p1.unbreakable && !p2.unbreakable) {
-        bounce(p1, p2);
-    }
-    if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
-        p1.destroy();
-    }
-    else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
-        p2.destroy();
-    }
-    else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
-        if (p1.getRadius() >= p2.getRadius()) {
-            p2.destroy();
-        }
-        else {
-            p1.destroy();
-        }
-    }
-}
-class Collider extends Core_1.ParticlesInteractorBase {
-    constructor(container) {
-        super(container);
-    }
-    isEnabled(particle) {
-        return particle.options.collisions.enable;
-    }
-    reset() {
-    }
-    async interact(p1) {
-        const container = this.container;
-        const pos1 = p1.getPosition();
-        const radius1 = p1.getRadius();
-        const query = container.particles.quadTree.queryCircle(pos1, radius1 * 2);
-        for (const p2 of query) {
-            if (p1 === p2 ||
-                !p2.options.collisions.enable ||
-                p1.options.collisions.mode !== p2.options.collisions.mode ||
-                p2.destroyed ||
-                p2.spawning) {
-                continue;
-            }
-            const pos2 = p2.getPosition();
-            if (Math.round(pos1.z) !== Math.round(pos2.z)) {
-                continue;
-            }
-            const dist = (0, Utils_1.getDistance)(pos1, pos2);
-            const radius2 = p2.getRadius();
-            const distP = radius1 + radius2;
-            if (dist <= distP) {
-                this.resolveCollision(p1, p2);
-            }
-        }
-    }
-    resolveCollision(p1, p2) {
-        switch (p1.options.collisions.mode) {
-            case "absorb": {
-                this.absorb(p1, p2);
-                break;
-            }
-            case "bounce": {
-                bounce(p1, p2);
-                break;
-            }
-            case "destroy": {
-                destroy(p1, p2);
-                break;
-            }
-        }
-    }
-    absorb(p1, p2) {
-        const container = this.container;
-        const fps = container.fpsLimit / 1000;
-        if (p1.getRadius() === undefined && p2.getRadius() !== undefined) {
-            p1.destroy();
-        }
-        else if (p1.getRadius() !== undefined && p2.getRadius() === undefined) {
-            p2.destroy();
-        }
-        else if (p1.getRadius() !== undefined && p2.getRadius() !== undefined) {
-            if (p1.getRadius() >= p2.getRadius()) {
-                const factor = (0, Utils_1.clamp)(p1.getRadius() / p2.getRadius(), 0, p2.getRadius()) * fps;
-                p1.size.value += factor;
-                p2.size.value -= factor;
-                if (p2.getRadius() <= container.retina.pixelRatio) {
-                    p2.size.value = 0;
-                    p2.destroy();
-                }
-            }
-            else {
-                const factor = (0, Utils_1.clamp)(p2.getRadius() / p1.getRadius(), 0, p1.getRadius()) * fps;
-                p1.size.value -= factor;
-                p2.size.value += factor;
-                if (p1.getRadius() <= container.retina.pixelRatio) {
-                    p1.size.value = 0;
-                    p1.destroy();
-                }
-            }
-        }
-    }
-}
-exports.Collider = Collider;

package/Interactions/Particles/Links/LinkInstance.d.ts

@@ -1,10 +0,0 @@
-import type { Container, IContainerPlugin, Particle } from "../../../Core";
-export declare class LinkInstance implements IContainerPlugin {
-    private readonly container;
-    constructor(container: Container);
-    particleCreated(particle: Particle): void;
-    particleDestroyed(particle: Particle): void;
-    drawParticle(context: CanvasRenderingContext2D, particle: Particle): void;
-    private drawLinkTriangle;
-    private drawLinkLine;
-}

package/Interactions/Particles/Links/LinkInstance.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LinkInstance = void 0;
-const Utils_1 = require("../../../Utils");
-class LinkInstance {
-    constructor(container) {
-        this.container = container;
-    }
-    particleCreated(particle) {
-        const linkParticle = particle;
-        linkParticle.links = [];
-    }
-    particleDestroyed(particle) {
-        const linkParticle = particle;
-        linkParticle.links = [];
-    }
-    drawParticle(context, particle) {
-        const linkParticle = particle;
-        const container = this.container;
-        const particles = container.particles;
-        const pOptions = particle.options;
-        if (linkParticle.links.length > 0) {
-            context.save();
-            const p1Links = linkParticle.links.filter((l) => {
-                const linkFreq = container.particles.getLinkFrequency(linkParticle, l.destination);
-                return linkFreq <= pOptions.links.frequency;
-            });
-            for (const link of p1Links) {
-                const p2 = link.destination;
-                if (pOptions.links.triangles.enable) {
-                    const links = p1Links.map((l) => l.destination);
-                    const vertices = p2.links.filter((t) => {
-                        const linkFreq = container.particles.getLinkFrequency(p2, t.destination);
-                        return linkFreq <= p2.options.links.frequency && links.indexOf(t.destination) >= 0;
-                    });
-                    if (vertices.length) {
-                        for (const vertex of vertices) {
-                            const p3 = vertex.destination;
-                            const triangleFreq = particles.getTriangleFrequency(linkParticle, p2, p3);
-                            if (triangleFreq > pOptions.links.triangles.frequency) {
-                                continue;
-                            }
-                            this.drawLinkTriangle(linkParticle, link, vertex);
-                        }
-                    }
-                }
-                if (link.opacity > 0 && container.retina.linksWidth > 0) {
-                    this.drawLinkLine(linkParticle, link);
-                }
-            }
-            context.restore();
-        }
-    }
-    drawLinkTriangle(p1, link1, link2) {
-        var _a;
-        const container = this.container;
-        const options = container.actualOptions;
-        const p2 = link1.destination;
-        const p3 = link2.destination;
-        const triangleOptions = p1.options.links.triangles;
-        const opacityTriangle = (_a = triangleOptions.opacity) !== null && _a !== void 0 ? _a : (link1.opacity + link2.opacity) / 2;
-        if (opacityTriangle <= 0) {
-            return;
-        }
-        const pos1 = p1.getPosition();
-        const pos2 = p2.getPosition();
-        const pos3 = p3.getPosition();
-        container.canvas.draw((ctx) => {
-            if ((0, Utils_1.getDistance)(pos1, pos2) > container.retina.linksDistance ||
-                (0, Utils_1.getDistance)(pos3, pos2) > container.retina.linksDistance ||
-                (0, Utils_1.getDistance)(pos3, pos1) > container.retina.linksDistance) {
-                return;
-            }
-            let colorTriangle = (0, Utils_1.colorToRgb)(triangleOptions.color);
-            if (!colorTriangle) {
-                const linksOptions = p1.options.links;
-                const linkColor = linksOptions.id !== undefined
-                    ? container.particles.linksColors.get(linksOptions.id)
-                    : container.particles.linksColor;
-                colorTriangle = (0, Utils_1.getLinkColor)(p1, p2, linkColor);
-            }
-            if (!colorTriangle) {
-                return;
-            }
-            (0, Utils_1.drawLinkTriangle)(ctx, pos1, pos2, pos3, options.backgroundMask.enable, options.backgroundMask.composite, colorTriangle, opacityTriangle);
-        });
-    }
-    drawLinkLine(p1, link) {
-        const container = this.container;
-        const options = container.actualOptions;
-        const p2 = link.destination;
-        let opacity = link.opacity;
-        const pos1 = p1.getPosition();
-        const pos2 = p2.getPosition();
-        container.canvas.draw((ctx) => {
-            var _a, _b;
-            let colorLine;
-            const twinkle = p1.options.twinkle.lines;
-            if (twinkle.enable) {
-                const twinkleFreq = twinkle.frequency;
-                const twinkleRgb = (0, Utils_1.colorToRgb)(twinkle.color);
-                const twinkling = Math.random() < twinkleFreq;
-                if (twinkling && twinkleRgb !== undefined) {
-                    colorLine = twinkleRgb;
-                    opacity = (0, Utils_1.getRangeValue)(twinkle.opacity);
-                }
-            }
-            if (!colorLine) {
-                const linksOptions = p1.options.links;
-                const linkColor = linksOptions.id !== undefined
-                    ? container.particles.linksColors.get(linksOptions.id)
-                    : container.particles.linksColor;
-                colorLine = (0, Utils_1.getLinkColor)(p1, p2, linkColor);
-            }
-            if (!colorLine) {
-                return;
-            }
-            const width = (_a = p1.retina.linksWidth) !== null && _a !== void 0 ? _a : container.retina.linksWidth;
-            const maxDistance = (_b = p1.retina.linksDistance) !== null && _b !== void 0 ? _b : container.retina.linksDistance;
-            (0, Utils_1.drawLinkLine)(ctx, width, pos1, pos2, maxDistance, container.canvas.size, p1.options.links.warp, options.backgroundMask.enable, options.backgroundMask.composite, colorLine, opacity, p1.options.links.shadow);
-        });
-    }
-}
-exports.LinkInstance = LinkInstance;

package/Interactions/Particles/Links/LinkParticle.d.ts

@@ -1,5 +0,0 @@
-import type { ILink } from "./ILink";
-import type { Particle } from "../../../Core";
-export declare type LinkParticle = Particle & {
-    links: ILink[];
-};

package/Interactions/Particles/Links/Linker.d.ts

@@ -1,10 +0,0 @@
-import { ParticlesInteractorBase } from "../../../Core";
-import type { Container, Particle } from "../../../Core";
-import type { LinkParticle } from "./LinkParticle";
-export declare class Linker extends ParticlesInteractorBase {
-    constructor(container: Container);
-    isEnabled(particle: Particle): boolean;
-    reset(): void;
-    interact(p1: LinkParticle): Promise<void>;
-    private setColor;
-}

package/Interactions/Particles/Links/Linker.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Linker = void 0;
-const Core_1 = require("../../../Core");
-const Utils_1 = require("../../../Utils");
-function getLinkDistance(pos1, pos2, optDistance, canvasSize, warp) {
-    let distance = (0, Utils_1.getDistance)(pos1, pos2);
-    if (!warp || distance <= optDistance) {
-        return distance;
-    }
-    const pos2NE = {
-        x: pos2.x - canvasSize.width,
-        y: pos2.y,
-    };
-    distance = (0, Utils_1.getDistance)(pos1, pos2NE);
-    if (distance <= optDistance) {
-        return distance;
-    }
-    const pos2SE = {
-        x: pos2.x - canvasSize.width,
-        y: pos2.y - canvasSize.height,
-    };
-    distance = (0, Utils_1.getDistance)(pos1, pos2SE);
-    if (distance <= optDistance) {
-        return distance;
-    }
-    const pos2SW = {
-        x: pos2.x,
-        y: pos2.y - canvasSize.height,
-    };
-    distance = (0, Utils_1.getDistance)(pos1, pos2SW);
-    return distance;
-}
-class Linker extends Core_1.ParticlesInteractorBase {
-    constructor(container) {
-        super(container);
-    }
-    isEnabled(particle) {
-        return particle.options.links.enable;
-    }
-    reset() {
-    }
-    async interact(p1) {
-        var _a;
-        p1.links = [];
-        const pos1 = p1.getPosition();
-        const container = this.container;
-        const canvasSize = container.canvas.size;
-        if (pos1.x < 0 || pos1.y < 0 || pos1.x > canvasSize.width || pos1.y > canvasSize.height) {
-            return;
-        }
-        const linkOpt1 = p1.options.links;
-        const optOpacity = linkOpt1.opacity;
-        const optDistance = (_a = p1.retina.linksDistance) !== null && _a !== void 0 ? _a : container.retina.linksDistance;
-        const warp = linkOpt1.warp;
-        const range = warp
-            ? new Core_1.CircleWarp(pos1.x, pos1.y, optDistance, canvasSize)
-            : new Core_1.Circle(pos1.x, pos1.y, optDistance);
-        const query = container.particles.quadTree.query(range);
-        for (const p2 of query) {
-            const linkOpt2 = p2.options.links;
-            if (p1 === p2 ||
-                !linkOpt2.enable ||
-                linkOpt1.id !== linkOpt2.id ||
-                p2.spawning ||
-                p2.destroyed ||
-                p1.links.map((t) => t.destination).indexOf(p2) !== -1 ||
-                p2.links.map((t) => t.destination).indexOf(p1) !== -1) {
-                continue;
-            }
-            const pos2 = p2.getPosition();
-            if (pos2.x < 0 || pos2.y < 0 || pos2.x > canvasSize.width || pos2.y > canvasSize.height) {
-                continue;
-            }
-            const distance = getLinkDistance(pos1, pos2, optDistance, canvasSize, warp && linkOpt2.warp);
-            if (distance > optDistance) {
-                return;
-            }
-            const opacityLine = (1 - distance / optDistance) * optOpacity;
-            this.setColor(p1);
-            p1.links.push({
-                destination: p2,
-                opacity: opacityLine,
-            });
-        }
-    }
-    setColor(p1) {
-        const container = this.container;
-        const linksOptions = p1.options.links;
-        let linkColor = linksOptions.id === undefined
-            ? container.particles.linksColor
-            : container.particles.linksColors.get(linksOptions.id);
-        if (!linkColor) {
-            const optColor = linksOptions.color;
-            linkColor = (0, Utils_1.getLinkRandomColor)(optColor, linksOptions.blink, linksOptions.consent);
-            if (linksOptions.id === undefined) {
-                container.particles.linksColor = linkColor;
-            }
-            else {
-                container.particles.linksColors.set(linksOptions.id, linkColor);
-            }
-        }
-    }
-}
-exports.Linker = Linker;

package/Options/Classes/AnimatableColor.d.ts

@@ -1,11 +0,0 @@
-import type { RecursivePartial, SingleOrMultiple } from "../../Types";
-import { HslAnimation } from "./HslAnimation";
-import type { IAnimatableColor } from "../Interfaces/IAnimatableColor";
-import type { IOptionLoader } from "../Interfaces/IOptionLoader";
-import { OptionsColor } from "./OptionsColor";
-export declare class AnimatableColor extends OptionsColor implements IAnimatableColor, IOptionLoader<IAnimatableColor> {
-    animation: HslAnimation;
-    constructor();
-    static create(source?: AnimatableColor, data?: SingleOrMultiple<string> | RecursivePartial<IAnimatableColor>): AnimatableColor;
-    load(data?: RecursivePartial<IAnimatableColor>): void;
-}

package/Options/Classes/AnimatableGradient.d.ts

@@ -1,53 +0,0 @@
-import { GradientType, RotateDirection, RotateDirectionAlt, StartValueType } from "../../Enums";
-import type { IAnimatableGradientColor, IGradientColorOpacityAnimation } from "../Interfaces/IOptionsGradient";
-import type { IGradientAngle, IGradientColorOpacity } from "../../Core";
-import type { RangeValue, RecursivePartial } from "../../Types";
-import { AnimatableColor } from "./AnimatableColor";
-import type { IAnimatable } from "../Interfaces/IAnimatable";
-import type { IAnimatableGradient } from "../Interfaces/IAnimatableGradient";
-import type { IAnimation } from "../Interfaces/IAnimation";
-import type { IOptionLoader } from "../Interfaces/IOptionLoader";
-export declare class AnimatableGradient implements IAnimatableGradient, IOptionLoader<IAnimatableGradient> {
-    angle: GradientAngle;
-    colors: AnimatableGradientColor[];
-    type: GradientType;
-    constructor();
-    load(data?: RecursivePartial<IAnimatableGradient>): void;
-}
-export declare class GradientAngle implements IGradientAngle, IAnimatable<IAnimation>, IOptionLoader<IGradientAngle & IAnimatable<IAnimation>> {
-    animation: GradientAngleAnimation;
-    value: number;
-    direction: RotateDirection | keyof typeof RotateDirection | RotateDirectionAlt;
-    constructor();
-    load(data?: RecursivePartial<IGradientAngle & IAnimatable<IAnimation>>): void;
-}
-export declare class GradientColorOpacity implements IGradientColorOpacity, IAnimatable<GradientColorOpacityAnimation>, IOptionLoader<IGradientColorOpacity & IAnimatable<IGradientColorOpacityAnimation>> {
-    animation: GradientColorOpacityAnimation;
-    value: RangeValue;
-    constructor();
-    load(data?: RecursivePartial<IGradientColorOpacity & IAnimatable<IAnimation>>): void;
-}
-export declare class AnimatableGradientColor implements IAnimatableGradientColor, IOptionLoader<IAnimatableGradientColor> {
-    stop: number;
-    value: AnimatableColor;
-    opacity?: GradientColorOpacity;
-    constructor();
-    load(data?: RecursivePartial<IAnimatableGradientColor>): void;
-}
-export declare class GradientAngleAnimation implements IAnimation, IOptionLoader<IAnimation> {
-    count: RangeValue;
-    enable: boolean;
-    speed: RangeValue;
-    sync: boolean;
-    constructor();
-    load(data?: RecursivePartial<IAnimation>): void;
-}
-export declare class GradientColorOpacityAnimation implements IGradientColorOpacityAnimation, IOptionLoader<IGradientColorOpacityAnimation> {
-    count: RangeValue;
-    enable: boolean;
-    speed: RangeValue;
-    sync: boolean;
-    startValue: StartValueType | keyof typeof StartValueType;
-    constructor();
-    load(data?: RecursivePartial<IGradientColorOpacityAnimation>): void;
-}

package/Options/Classes/AnimatableGradient.js

@@ -1,146 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GradientColorOpacityAnimation = exports.GradientAngleAnimation = exports.AnimatableGradientColor = exports.GradientColorOpacity = exports.GradientAngle = exports.AnimatableGradient = void 0;
-const AnimatableColor_1 = require("./AnimatableColor");
-const Utils_1 = require("../../Utils");
-class AnimatableGradient {
-    constructor() {
-        this.angle = new GradientAngle();
-        this.colors = [];
-        this.type = "random";
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        this.angle.load(data.angle);
-        if (data.colors !== undefined) {
-            this.colors = data.colors.map((s) => {
-                const tmp = new AnimatableGradientColor();
-                tmp.load(s);
-                return tmp;
-            });
-        }
-        if (data.type !== undefined) {
-            this.type = data.type;
-        }
-    }
-}
-exports.AnimatableGradient = AnimatableGradient;
-class GradientAngle {
-    constructor() {
-        this.value = 0;
-        this.animation = new GradientAngleAnimation();
-        this.direction = "clockwise";
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        this.animation.load(data.animation);
-        if (data.value !== undefined) {
-            this.value = data.value;
-        }
-        if (data.direction !== undefined) {
-            this.direction = data.direction;
-        }
-    }
-}
-exports.GradientAngle = GradientAngle;
-class GradientColorOpacity {
-    constructor() {
-        this.value = 0;
-        this.animation = new GradientColorOpacityAnimation();
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        this.animation.load(data.animation);
-        if (data.value !== undefined) {
-            this.value = (0, Utils_1.setRangeValue)(data.value);
-        }
-    }
-}
-exports.GradientColorOpacity = GradientColorOpacity;
-class AnimatableGradientColor {
-    constructor() {
-        this.stop = 0;
-        this.value = new AnimatableColor_1.AnimatableColor();
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        if (data.stop !== undefined) {
-            this.stop = data.stop;
-        }
-        this.value = AnimatableColor_1.AnimatableColor.create(this.value, data.value);
-        if (data.opacity !== undefined) {
-            this.opacity = new GradientColorOpacity();
-            if (typeof data.opacity === "number") {
-                this.opacity.value = data.opacity;
-            }
-            else {
-                this.opacity.load(data.opacity);
-            }
-        }
-    }
-}
-exports.AnimatableGradientColor = AnimatableGradientColor;
-class GradientAngleAnimation {
-    constructor() {
-        this.count = 0;
-        this.enable = false;
-        this.speed = 0;
-        this.sync = false;
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        if (data.count !== undefined) {
-            this.count = (0, Utils_1.setRangeValue)(data.count);
-        }
-        if (data.enable !== undefined) {
-            this.enable = data.enable;
-        }
-        if (data.speed !== undefined) {
-            this.speed = (0, Utils_1.setRangeValue)(data.speed);
-        }
-        if (data.sync !== undefined) {
-            this.sync = data.sync;
-        }
-    }
-}
-exports.GradientAngleAnimation = GradientAngleAnimation;
-class GradientColorOpacityAnimation {
-    constructor() {
-        this.count = 0;
-        this.enable = false;
-        this.speed = 0;
-        this.sync = false;
-        this.startValue = "random";
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        if (data.count !== undefined) {
-            this.count = (0, Utils_1.setRangeValue)(data.count);
-        }
-        if (data.enable !== undefined) {
-            this.enable = data.enable;
-        }
-        if (data.speed !== undefined) {
-            this.speed = (0, Utils_1.setRangeValue)(data.speed);
-        }
-        if (data.sync !== undefined) {
-            this.sync = data.sync;
-        }
-        if (data.startValue !== undefined) {
-            this.startValue = data.startValue;
-        }
-    }
-}
-exports.GradientColorOpacityAnimation = GradientColorOpacityAnimation;

package/Options/Classes/AnimationOptions.d.ts

@@ -1,11 +0,0 @@
-import type { RangeValue, RecursivePartial } from "../../Types";
-import type { IAnimation } from "../Interfaces/IAnimation";
-import type { IOptionLoader } from "../Interfaces/IOptionLoader";
-export declare class AnimationOptions implements IAnimation, IOptionLoader<IAnimation> {
-    count: RangeValue;
-    enable: boolean;
-    speed: RangeValue;
-    sync: boolean;
-    constructor();
-    load(data?: RecursivePartial<IAnimation>): void;
-}

package/Options/Classes/AnimationOptions.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnimationOptions = void 0;
-const Utils_1 = require("../../Utils");
-class AnimationOptions {
-    constructor() {
-        this.count = 0;
-        this.enable = false;
-        this.speed = 1;
-        this.sync = false;
-    }
-    load(data) {
-        if (!data) {
-            return;
-        }
-        if (data.count !== undefined) {
-            this.count = (0, Utils_1.setRangeValue)(data.count);
-        }
-        if (data.enable !== undefined) {
-            this.enable = data.enable;
-        }
-        if (data.speed !== undefined) {
-            this.speed = (0, Utils_1.setRangeValue)(data.speed);
-        }
-        if (data.sync !== undefined) {
-            this.sync = data.sync;
-        }
-    }
-}
-exports.AnimationOptions = AnimationOptions;

package/Options/Classes/Background/Background.d.ts

@@ -1,14 +0,0 @@
-import type { IBackground } from "../../Interfaces/Background/IBackground";
-import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
-import { OptionsColor } from "../OptionsColor";
-import type { RecursivePartial } from "../../../Types";
-export declare class Background implements IBackground, IOptionLoader<IBackground> {
-    color: OptionsColor;
-    image: string;
-    position: string;
-    repeat: string;
-    size: string;
-    opacity: number;
-    constructor();
-    load(data?: RecursivePartial<IBackground>): void;
-}

package/Options/Classes/BackgroundMask/BackgroundMask.d.ts

@@ -1,11 +0,0 @@
-import { BackgroundMaskCover } from "./BackgroundMaskCover";
-import type { IBackgroundMask } from "../../Interfaces/BackgroundMask/IBackgroundMask";
-import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
-import type { RecursivePartial } from "../../../Types";
-export declare class BackgroundMask implements IBackgroundMask, IOptionLoader<IBackgroundMask> {
-    composite: string;
-    cover: BackgroundMaskCover;
-    enable: boolean;
-    constructor();
-    load(data?: RecursivePartial<IBackgroundMask>): void;
-}

package/Options/Classes/BackgroundMask/BackgroundMaskCover.d.ts

@@ -1,10 +0,0 @@
-import type { IBackgroundMaskCover } from "../../Interfaces/BackgroundMask/IBackgroundMaskCover";
-import type { IOptionLoader } from "../../Interfaces/IOptionLoader";
-import { OptionsColor } from "../OptionsColor";
-import type { RecursivePartial } from "../../../Types";
-export declare class BackgroundMaskCover implements IBackgroundMaskCover, IOptionLoader<IBackgroundMaskCover> {
-    color: OptionsColor;
-    opacity: number;
-    constructor();
-    load(data?: RecursivePartial<IBackgroundMaskCover> | undefined): void;
-}

package/Options/Classes/ColorAnimation.d.ts

@@ -1,12 +0,0 @@
-import type { RangeValue, RecursivePartial } from "../../Types";
-import type { IColorAnimation } from "../Interfaces/IColorAnimation";
-import type { IOptionLoader } from "../Interfaces/IOptionLoader";
-export declare class ColorAnimation implements IColorAnimation, IOptionLoader<IColorAnimation> {
-    count: RangeValue;
-    enable: boolean;
-    offset: RangeValue;
-    speed: RangeValue;
-    sync: boolean;
-    constructor();
-    load(data?: RecursivePartial<IColorAnimation>): void;
-}