tsparticles 1.40.2 → 1.41.3

package/umd/Options/Interfaces/Particles/Tilt/ITilt.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Particles/Tilt/ITiltAnimation.d.ts

@@ -0,0 +1,5 @@
+export interface ITiltAnimation {
+    enable: boolean;
+    speed: number;
+    sync: boolean;
+}

package/umd/Options/Interfaces/Particles/Tilt/ITiltAnimation.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Particles/Twinkle/ITwinkle.d.ts

@@ -0,0 +1,5 @@
+import type { ITwinkleValues } from "./ITwinkleValues";
+export interface ITwinkle {
+    lines: ITwinkleValues;
+    particles: ITwinkleValues;
+}

package/umd/Options/Interfaces/Particles/Twinkle/ITwinkle.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Particles/Twinkle/ITwinkleValues.d.ts

@@ -0,0 +1,7 @@
+import type { IColor } from "../../../../Core/Interfaces/Colors";
+export interface ITwinkleValues {
+    color?: string | IColor;
+    enable: boolean;
+    frequency: number;
+    opacity: number;
+}

package/umd/Options/Interfaces/Particles/Twinkle/ITwinkleValues.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Particles/Wobble/IWobble.d.ts

@@ -0,0 +1,6 @@
+import type { RangeValue } from "../../../../Types";
+export interface IWobble {
+    distance: RangeValue;
+    enable: boolean;
+    speed: RangeValue;
+}

package/umd/Options/Interfaces/Particles/Wobble/IWobble.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Particles/ZIndex/IZIndex.d.ts

@@ -0,0 +1,6 @@
+import type { IValueWithRandom } from "../../IValueWithRandom";
+export interface IZIndex extends IValueWithRandom {
+    opacityRate: number;
+    velocityRate: number;
+    sizeRate: number;
+}

package/umd/Options/Interfaces/Particles/ZIndex/IZIndex.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Theme/ITheme.d.ts

@@ -0,0 +1,8 @@
+import type { IOptions } from "../IOptions";
+import type { IThemeDefault } from "./IThemeDefault";
+import type { RecursivePartial } from "../../../Types";
+export interface ITheme {
+    name: string;
+    default: IThemeDefault;
+    options?: RecursivePartial<IOptions>;
+}

package/umd/Options/Interfaces/Theme/ITheme.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Options/Interfaces/Theme/IThemeDefault.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeMode } from "../../../Enums";
+export interface IThemeDefault {
+    auto: boolean;
+    mode: ThemeMode | keyof ThemeMode;
+    value: boolean;
+}

package/umd/Options/Interfaces/Theme/IThemeDefault.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Plugins/Absorbers/AbsorberContainer.d.ts

@@ -0,0 +1,7 @@
+import type { AbsorberInstance } from "./AbsorberInstance";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+import type { ICoordinates } from "../../Core";
+export interface AbsorberContainer {
+    addAbsorber: (options: IAbsorber, position: ICoordinates) => AbsorberInstance;
+    getAbsorber: (idxOrName?: number | string) => AbsorberInstance | undefined;
+}

package/umd/Plugins/Absorbers/AbsorberContainer.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Plugins/Absorbers/AbsorberInstance.d.ts

@@ -0,0 +1,33 @@
+import type { Container, ICoordinates, IRgb, Particle } from "../../Core";
+import type { Absorbers } from "./Absorbers";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+import { IAbsorberSizeLimit } from "./Options/Interfaces/IAbsorberSizeLimit";
+import { RecursivePartial } from "../../Types";
+import { RotateDirection } from "../../Enums";
+import { Vector } from "../../Core";
+declare type OrbitingParticle = Particle & {
+    absorberOrbit?: Vector;
+    absorberOrbitDirection?: RotateDirection;
+    needsNewPosition?: boolean;
+};
+export declare class AbsorberInstance {
+    private readonly absorbers;
+    private readonly container;
+    mass: number;
+    opacity: number;
+    size: number;
+    color: IRgb;
+    limit: IAbsorberSizeLimit;
+    readonly name?: string;
+    position: Vector;
+    private dragging;
+    private readonly initialPosition?;
+    private readonly options;
+    constructor(absorbers: Absorbers, container: Container, options: RecursivePartial<IAbsorber>, position?: ICoordinates);
+    attract(particle: OrbitingParticle): void;
+    resize(): void;
+    draw(context: CanvasRenderingContext2D): void;
+    private calcPosition;
+    private updateParticlePosition;
+}
+export {};

package/umd/Plugins/Absorbers/AbsorberInstance.js

@@ -0,0 +1,172 @@
+(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", "./Options/Classes/Absorber", "../../Core"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AbsorberInstance = void 0;
+    const Utils_1 = require("../../Utils");
+    const Absorber_1 = require("./Options/Classes/Absorber");
+    const Core_1 = require("../../Core");
+    class AbsorberInstance {
+        constructor(absorbers, container, options, position) {
+            var _a, _b, _c;
+            this.absorbers = absorbers;
+            this.container = container;
+            this.initialPosition = position ? Core_1.Vector.create(position.x, position.y) : undefined;
+            if (options instanceof Absorber_1.Absorber) {
+                this.options = options;
+            }
+            else {
+                this.options = new Absorber_1.Absorber();
+                this.options.load(options);
+            }
+            this.dragging = false;
+            this.name = this.options.name;
+            this.opacity = this.options.opacity;
+            this.size = (0, Utils_1.getRangeValue)(this.options.size.value) * container.retina.pixelRatio;
+            this.mass = this.size * this.options.size.density * container.retina.reduceFactor;
+            const limit = this.options.size.limit;
+            this.limit = {
+                radius: limit.radius * container.retina.pixelRatio * container.retina.reduceFactor,
+                mass: limit.mass,
+            };
+            this.color = (_a = (0, Utils_1.colorToRgb)(this.options.color)) !== null && _a !== void 0 ? _a : {
+                b: 0,
+                g: 0,
+                r: 0,
+            };
+            this.position = (_c = (_b = this.initialPosition) === null || _b === void 0 ? void 0 : _b.copy()) !== null && _c !== void 0 ? _c : this.calcPosition();
+        }
+        attract(particle) {
+            const container = this.container;
+            const options = this.options;
+            if (options.draggable) {
+                const mouse = container.interactivity.mouse;
+                if (mouse.clicking && mouse.downPosition) {
+                    const mouseDist = (0, Utils_1.getDistance)(this.position, mouse.downPosition);
+                    if (mouseDist <= this.size) {
+                        this.dragging = true;
+                    }
+                }
+                else {
+                    this.dragging = false;
+                }
+                if (this.dragging && mouse.position) {
+                    this.position.x = mouse.position.x;
+                    this.position.y = mouse.position.y;
+                }
+            }
+            const pos = particle.getPosition();
+            const { dx, dy, distance } = (0, Utils_1.getDistances)(this.position, pos);
+            const v = Core_1.Vector.create(dx, dy);
+            v.length = (this.mass / Math.pow(distance, 2)) * container.retina.reduceFactor;
+            if (distance < this.size + particle.getRadius()) {
+                const sizeFactor = particle.getRadius() * 0.033 * container.retina.pixelRatio;
+                if ((this.size > particle.getRadius() && distance < this.size - particle.getRadius()) ||
+                    (particle.absorberOrbit !== undefined && particle.absorberOrbit.length < 0)) {
+                    if (options.destroy) {
+                        particle.destroy();
+                    }
+                    else {
+                        particle.needsNewPosition = true;
+                        this.updateParticlePosition(particle, v);
+                    }
+                }
+                else {
+                    if (options.destroy) {
+                        particle.size.value -= sizeFactor;
+                    }
+                    this.updateParticlePosition(particle, v);
+                }
+                if (this.limit.radius <= 0 || this.size < this.limit.radius) {
+                    this.size += sizeFactor;
+                }
+                if (this.limit.mass <= 0 || this.mass < this.limit.mass) {
+                    this.mass += sizeFactor * this.options.size.density * container.retina.reduceFactor;
+                }
+            }
+            else {
+                this.updateParticlePosition(particle, v);
+            }
+        }
+        resize() {
+            const initialPosition = this.initialPosition;
+            this.position =
+                initialPosition && (0, Utils_1.isPointInside)(initialPosition, this.container.canvas.size)
+                    ? initialPosition
+                    : this.calcPosition();
+        }
+        draw(context) {
+            context.translate(this.position.x, this.position.y);
+            context.beginPath();
+            context.arc(0, 0, this.size, 0, Math.PI * 2, false);
+            context.closePath();
+            context.fillStyle = (0, Utils_1.getStyleFromRgb)(this.color, this.opacity);
+            context.fill();
+        }
+        calcPosition() {
+            var _a, _b;
+            const container = this.container;
+            const percentPosition = this.options.position;
+            return Core_1.Vector.create((((_a = percentPosition === null || percentPosition === void 0 ? void 0 : percentPosition.x) !== null && _a !== void 0 ? _a : Math.random() * 100) / 100) * container.canvas.size.width, (((_b = percentPosition === null || percentPosition === void 0 ? void 0 : percentPosition.y) !== null && _b !== void 0 ? _b : Math.random() * 100) / 100) * container.canvas.size.height);
+        }
+        updateParticlePosition(particle, v) {
+            var _a;
+            if (particle.destroyed) {
+                return;
+            }
+            const container = this.container;
+            const canvasSize = container.canvas.size;
+            if (particle.needsNewPosition) {
+                particle.position.x = Math.floor(Math.random() * canvasSize.width);
+                particle.position.y = Math.floor(Math.random() * canvasSize.height);
+                particle.velocity.setTo(particle.initialVelocity);
+                particle.absorberOrbit = undefined;
+                particle.needsNewPosition = false;
+            }
+            if (this.options.orbits) {
+                if (particle.absorberOrbit === undefined) {
+                    particle.absorberOrbit = Core_1.Vector.create(0, 0);
+                    particle.absorberOrbit.length = (0, Utils_1.getDistance)(particle.getPosition(), this.position);
+                    particle.absorberOrbit.angle = Math.random() * Math.PI * 2;
+                }
+                if (particle.absorberOrbit.length <= this.size && !this.options.destroy) {
+                    const minSize = Math.min(canvasSize.width, canvasSize.height);
+                    particle.absorberOrbit.length = minSize * (1 + (Math.random() * 0.2 - 0.1));
+                }
+                if (particle.absorberOrbitDirection === undefined) {
+                    particle.absorberOrbitDirection =
+                        particle.velocity.x >= 0 ? "clockwise" : "counter-clockwise";
+                }
+                const orbitRadius = particle.absorberOrbit.length;
+                const orbitAngle = particle.absorberOrbit.angle;
+                const orbitDirection = particle.absorberOrbitDirection;
+                particle.velocity.x = 0;
+                particle.velocity.y = 0;
+                const updateFunc = {
+                    x: orbitDirection === "clockwise" ? Math.cos : Math.sin,
+                    y: orbitDirection === "clockwise" ? Math.sin : Math.cos,
+                };
+                particle.position.x = this.position.x + orbitRadius * updateFunc.x(orbitAngle);
+                particle.position.y = this.position.y + orbitRadius * updateFunc.y(orbitAngle);
+                particle.absorberOrbit.length -= v.length;
+                particle.absorberOrbit.angle +=
+                    ((((_a = particle.retina.moveSpeed) !== null && _a !== void 0 ? _a : 0) * container.retina.pixelRatio) / 100) *
+                        container.retina.reduceFactor;
+            }
+            else {
+                const addV = Core_1.Vector.origin;
+                addV.length = v.length;
+                addV.angle = v.angle;
+                particle.velocity.addTo(addV);
+            }
+        }
+    }
+    exports.AbsorberInstance = AbsorberInstance;
+});

package/umd/Plugins/Absorbers/Absorbers.d.ts

@@ -0,0 +1,22 @@
+import type { Container, IContainerPlugin, ICoordinates, Particle } from "../../Core";
+import type { RecursivePartial, SingleOrMultiple } from "../../Types";
+import { Absorber } from "./Options/Classes/Absorber";
+import { AbsorberInstance } from "./AbsorberInstance";
+import type { IAbsorber } from "./Options/Interfaces/IAbsorber";
+import type { IAbsorberOptions } from "./Options/Interfaces/IAbsorberOptions";
+import type { IOptions } from "../../Options/Interfaces/IOptions";
+export declare class Absorbers implements IContainerPlugin {
+    private readonly container;
+    array: AbsorberInstance[];
+    absorbers: SingleOrMultiple<Absorber>;
+    interactivityAbsorbers: SingleOrMultiple<Absorber>;
+    constructor(container: Container);
+    init(options?: RecursivePartial<IOptions & IAbsorberOptions>): void;
+    particleUpdate(particle: Particle): void;
+    draw(context: CanvasRenderingContext2D): void;
+    stop(): void;
+    resize(): void;
+    handleClickMode(mode: string): void;
+    addAbsorber(options: IAbsorber, position?: ICoordinates): AbsorberInstance;
+    removeAbsorber(absorber: AbsorberInstance): void;
+}

package/umd/Plugins/Absorbers/Absorbers.js

@@ -0,0 +1,128 @@
+(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", "./Options/Classes/Absorber", "./AbsorberInstance", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Absorbers = void 0;
+    const Absorber_1 = require("./Options/Classes/Absorber");
+    const AbsorberInstance_1 = require("./AbsorberInstance");
+    const Utils_1 = require("../../Utils");
+    class Absorbers {
+        constructor(container) {
+            this.container = container;
+            this.array = [];
+            this.absorbers = [];
+            this.interactivityAbsorbers = [];
+            const overridableContainer = container;
+            overridableContainer.getAbsorber = (idxOrName) => idxOrName === undefined || typeof idxOrName === "number"
+                ? this.array[idxOrName || 0]
+                : this.array.find((t) => t.name === idxOrName);
+            overridableContainer.addAbsorber = (options, position) => this.addAbsorber(options, position);
+        }
+        init(options) {
+            var _a, _b;
+            if (!options) {
+                return;
+            }
+            if (options.absorbers) {
+                if (options.absorbers instanceof Array) {
+                    this.absorbers = options.absorbers.map((s) => {
+                        const tmp = new Absorber_1.Absorber();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    if (this.absorbers instanceof Array) {
+                        this.absorbers = new Absorber_1.Absorber();
+                    }
+                    this.absorbers.load(options.absorbers);
+                }
+            }
+            const interactivityAbsorbers = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.modes) === null || _b === void 0 ? void 0 : _b.absorbers;
+            if (interactivityAbsorbers) {
+                if (interactivityAbsorbers instanceof Array) {
+                    this.interactivityAbsorbers = interactivityAbsorbers.map((s) => {
+                        const tmp = new Absorber_1.Absorber();
+                        tmp.load(s);
+                        return tmp;
+                    });
+                }
+                else {
+                    if (this.interactivityAbsorbers instanceof Array) {
+                        this.interactivityAbsorbers = new Absorber_1.Absorber();
+                    }
+                    this.interactivityAbsorbers.load(interactivityAbsorbers);
+                }
+            }
+            if (this.absorbers instanceof Array) {
+                for (const absorberOptions of this.absorbers) {
+                    this.addAbsorber(absorberOptions);
+                }
+            }
+            else {
+                this.addAbsorber(this.absorbers);
+            }
+        }
+        particleUpdate(particle) {
+            for (const absorber of this.array) {
+                absorber.attract(particle);
+                if (particle.destroyed) {
+                    break;
+                }
+            }
+        }
+        draw(context) {
+            for (const absorber of this.array) {
+                context.save();
+                absorber.draw(context);
+                context.restore();
+            }
+        }
+        stop() {
+            this.array = [];
+        }
+        resize() {
+            for (const absorber of this.array) {
+                absorber.resize();
+            }
+        }
+        handleClickMode(mode) {
+            const container = this.container;
+            const absorberOptions = this.absorbers;
+            const modeAbsorbers = this.interactivityAbsorbers;
+            if (mode === "absorber") {
+                let absorbersModeOptions;
+                if (modeAbsorbers instanceof Array) {
+                    if (modeAbsorbers.length > 0) {
+                        absorbersModeOptions = (0, Utils_1.itemFromArray)(modeAbsorbers);
+                    }
+                }
+                else {
+                    absorbersModeOptions = modeAbsorbers;
+                }
+                const absorbersOptions = absorbersModeOptions !== null && absorbersModeOptions !== void 0 ? absorbersModeOptions : (absorberOptions instanceof Array ? (0, Utils_1.itemFromArray)(absorberOptions) : absorberOptions);
+                const aPosition = container.interactivity.mouse.clickPosition;
+                this.addAbsorber(absorbersOptions, aPosition);
+            }
+        }
+        addAbsorber(options, position) {
+            const absorber = new AbsorberInstance_1.AbsorberInstance(this, this.container, options, position);
+            this.array.push(absorber);
+            return absorber;
+        }
+        removeAbsorber(absorber) {
+            const index = this.array.indexOf(absorber);
+            if (index >= 0) {
+                this.array.splice(index, 1);
+            }
+        }
+    }
+    exports.Absorbers = Absorbers;
+});

package/umd/Plugins/Absorbers/Enums/AbsorberClickMode.d.ts

@@ -0,0 +1,3 @@
+export declare const enum AbsorberClickMode {
+    absorber = "absorber"
+}

package/umd/Plugins/Absorbers/Enums/AbsorberClickMode.js

@@ -0,0 +1,12 @@
+(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 });
+});

package/umd/Plugins/Absorbers/Enums/index.d.ts

@@ -0,0 +1 @@
+export * from "./AbsorberClickMode";

package/umd/Plugins/Absorbers/Enums/index.js

@@ -0,0 +1,23 @@
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+(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", "./AbsorberClickMode"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require("./AbsorberClickMode"), exports);
+});

package/umd/Plugins/Absorbers/Options/Classes/Absorber.d.ts

@@ -0,0 +1,18 @@
+import { AbsorberSize } from "./AbsorberSize";
+import type { IAbsorber } from "../Interfaces/IAbsorber";
+import type { ICoordinates } from "../../../../Core";
+import type { IOptionLoader } from "../../../../Options/Interfaces/IOptionLoader";
+import { OptionsColor } from "../../../../Options/Classes/OptionsColor";
+import type { RecursivePartial } from "../../../../Types";
+export declare class Absorber implements IAbsorber, IOptionLoader<IAbsorber> {
+    color: OptionsColor;
+    draggable: boolean;
+    name?: string;
+    opacity: number;
+    position?: RecursivePartial<ICoordinates>;
+    size: AbsorberSize;
+    destroy: boolean;
+    orbits: boolean;
+    constructor();
+    load(data?: RecursivePartial<IAbsorber>): void;
+}