@tsparticles/engine 4.0.0-alpha.5 → 4.0.0-beta.0

package/umd/Core/Utils/Ranges.js

@@ -14,6 +14,8 @@
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     const Constants_js_1 = require("./Constants.js");
     class BaseRange {
+        position;
+        type;
         constructor(x, y, type) {
             this.position = {
                 x: x,
@@ -21,34 +23,42 @@
             };
             this.type = type;
         }
+        _resetPosition(x, y) {
+            this.position.x = x;
+            this.position.y = y;
+        }
     }
     exports.BaseRange = BaseRange;
     class Circle extends BaseRange {
+        radius;
         constructor(x, y, radius) {
             super(x, y, RangeType_js_1.RangeType.circle);
             this.radius = radius;
         }
         contains(point) {
-            return (0, MathUtils_js_1.getDistance)(point, this.position) <= this.radius;
+            return (0, MathUtils_js_1.checkDistance)(point, this.position, this.radius);
         }
         intersects(range) {
-            const pos1 = this.position, pos2 = range.position, distPos = { x: Math.abs(pos2.x - pos1.x), y: Math.abs(pos2.y - pos1.y) }, r = this.radius;
+            const pos1 = this.position, pos2 = range.position, r = this.radius, dx = Math.abs(pos2.x - pos1.x), dy = Math.abs(pos2.y - pos1.y);
             if (range instanceof Circle || range.type === RangeType_js_1.RangeType.circle) {
-                const circleRange = range, rSum = r + circleRange.radius, dist = Math.sqrt(distPos.x ** Constants_js_1.squareExp + distPos.y ** Constants_js_1.squareExp);
+                const circleRange = range, rSum = r + circleRange.radius, dist = Math.hypot(dx, dy);
                 return rSum > dist;
             }
             else if (range instanceof Rectangle || range.type === RangeType_js_1.RangeType.rectangle) {
-                const rectRange = range, { width, height } = rectRange.size, edges = Math.pow(distPos.x - width, Constants_js_1.squareExp) + Math.pow(distPos.y - height, Constants_js_1.squareExp);
-                return (edges <= r ** Constants_js_1.squareExp ||
-                    (distPos.x <= r + width && distPos.y <= r + height) ||
-                    distPos.x <= width ||
-                    distPos.y <= height);
+                const rectRange = range, { width, height } = rectRange.size, edges = Math.pow(dx - width, Constants_js_1.squareExp) + Math.pow(dy - height, Constants_js_1.squareExp);
+                return edges <= r ** Constants_js_1.squareExp || (dx <= r + width && dy <= r + height) || dx <= width || dy <= height;
             }
             return false;
         }
+        reset(x, y, radius) {
+            this._resetPosition(x, y);
+            this.radius = radius;
+            return this;
+        }
     }
     exports.Circle = Circle;
     class Rectangle extends BaseRange {
+        size;
         constructor(x, y, width, height) {
             super(x, y, RangeType_js_1.RangeType.rectangle);
             this.size = {
@@ -64,9 +74,18 @@
             if (range instanceof Circle) {
                 return range.intersects(this);
             }
-            const w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position, size2 = range instanceof Rectangle ? range.size : { width: 0, height: 0 }, w2 = size2.width, h2 = size2.height;
+            if (!(range instanceof Rectangle)) {
+                return false;
+            }
+            const w = this.size.width, h = this.size.height, pos1 = this.position, pos2 = range.position, size2 = range.size, w2 = size2.width, h2 = size2.height;
             return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
         }
+        reset(x, y, width, height) {
+            this._resetPosition(x, y);
+            this.size.width = width;
+            this.size.height = height;
+            return this;
+        }
     }
     exports.Rectangle = Rectangle;
 });

package/umd/Core/Utils/SpatialHashGrid.js

@@ -0,0 +1,116 @@
+(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", "./Ranges.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SpatialHashGrid = void 0;
+    const Ranges_js_1 = require("./Ranges.js");
+    class SpatialHashGrid {
+        _cellSize;
+        _cells = new Map();
+        _circlePool = [];
+        _circlePoolIdx;
+        _pendingCellSize;
+        _rectanglePool = [];
+        _rectanglePoolIdx;
+        constructor(cellSize) {
+            this._cellSize = cellSize;
+            this._circlePoolIdx = 0;
+            this._rectanglePoolIdx = 0;
+        }
+        clear() {
+            this._cells.clear();
+            const pendingCellSize = this._pendingCellSize;
+            if (pendingCellSize) {
+                this._cellSize = pendingCellSize;
+            }
+            this._pendingCellSize = undefined;
+        }
+        insert(particle) {
+            const { x, y } = particle.getPosition(), key = this._cellKeyFromCoords(x, y);
+            if (!this._cells.has(key)) {
+                this._cells.set(key, []);
+            }
+            this._cells.get(key)?.push(particle);
+        }
+        query(range, check, out = []) {
+            const bounds = this._getRangeBounds(range);
+            if (!bounds) {
+                return out;
+            }
+            const minCellX = Math.floor(bounds.minX / this._cellSize), maxCellX = Math.floor(bounds.maxX / this._cellSize), minCellY = Math.floor(bounds.minY / this._cellSize), maxCellY = Math.floor(bounds.maxY / this._cellSize);
+            for (let cx = minCellX; cx <= maxCellX; cx++) {
+                for (let cy = minCellY; cy <= maxCellY; cy++) {
+                    const key = `${cx}_${cy}`, cellParticles = this._cells.get(key);
+                    if (!cellParticles) {
+                        continue;
+                    }
+                    for (const p of cellParticles) {
+                        if (check && !check(p)) {
+                            continue;
+                        }
+                        if (range.contains(p.getPosition())) {
+                            out.push(p);
+                        }
+                    }
+                }
+            }
+            return out;
+        }
+        queryCircle(position, radius, check, out = []) {
+            const circle = this._acquireCircle(position.x, position.y, radius), result = this.query(circle, check, out);
+            this._releaseShapes();
+            return result;
+        }
+        queryRectangle(position, size, check, out = []) {
+            const rect = this._acquireRectangle(position.x, position.y, size.width, size.height), result = this.query(rect, check, out);
+            this._releaseShapes();
+            return result;
+        }
+        setCellSize(cellSize) {
+            this._pendingCellSize = cellSize;
+        }
+        _acquireCircle(x, y, r) {
+            return (this._circlePool[this._circlePoolIdx++] ??= new Ranges_js_1.Circle(x, y, r)).reset(x, y, r);
+        }
+        _acquireRectangle(x, y, w, h) {
+            return (this._rectanglePool[this._rectanglePoolIdx++] ??= new Ranges_js_1.Rectangle(x, y, w, h)).reset(x, y, w, h);
+        }
+        _cellKeyFromCoords(x, y) {
+            const cellX = Math.floor(x / this._cellSize), cellY = Math.floor(y / this._cellSize);
+            return `${cellX}_${cellY}`;
+        }
+        _getRangeBounds(range) {
+            if (range instanceof Ranges_js_1.Circle) {
+                const r = range.radius, { x, y } = range.position;
+                return {
+                    minX: x - r,
+                    maxX: x + r,
+                    minY: y - r,
+                    maxY: y + r,
+                };
+            }
+            if (range instanceof Ranges_js_1.Rectangle) {
+                const { x, y } = range.position, { width, height } = range.size;
+                return {
+                    minX: x,
+                    maxX: x + width,
+                    minY: y,
+                    maxY: y + height,
+                };
+            }
+            return null;
+        }
+        _releaseShapes() {
+            this._circlePoolIdx = 0;
+            this._rectanglePoolIdx = 0;
+        }
+    }
+    exports.SpatialHashGrid = SpatialHashGrid;
+});

package/umd/Core/Utils/Vectors.js

@@ -11,12 +11,14 @@
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.Vector = exports.Vector3d = void 0;
     const Constants_js_1 = require("./Constants.js");
+    function getZ(source) {
+        return "z" in source ? source.z : Constants_js_1.originPoint.z;
+    }
     class Vector3d {
+        x;
+        y;
+        z;
         constructor(x = Constants_js_1.originPoint.x, y = Constants_js_1.originPoint.y, z = Constants_js_1.originPoint.z) {
-            this._updateFromAngle = (angle, length) => {
-                this.x = Math.cos(angle) * length;
-                this.y = Math.sin(angle) * length;
-            };
             this.x = x;
             this.y = y;
             this.z = z;
@@ -37,31 +39,25 @@
             this._updateFromAngle(this.angle, length);
         }
         static clone(source) {
-            return Vector3d.create(source.x, source.y, source.z);
+            return Vector3d.create(source.x, source.y, getZ(source));
         }
         static create(x, y, z) {
             if (typeof x === "number") {
                 return new Vector3d(x, y ?? Constants_js_1.originPoint.y, z ?? Constants_js_1.originPoint.z);
             }
-            return new Vector3d(x.x, x.y, Object.hasOwn(x, "z") ? x.z : Constants_js_1.originPoint.z);
+            return new Vector3d(x.x, x.y, getZ(x));
         }
         add(v) {
-            return Vector3d.create(this.x + v.x, this.y + v.y, this.z + v.z);
+            return Vector3d.create(this.x + v.x, this.y + v.y, this.z + getZ(v));
         }
         addTo(v) {
             this.x += v.x;
             this.y += v.y;
-            this.z += v.z;
+            this.z += getZ(v);
         }
         copy() {
             return Vector3d.clone(this);
         }
-        distanceTo(v) {
-            return this.sub(v).length;
-        }
-        distanceToSq(v) {
-            return this.sub(v).getLengthSq();
-        }
         div(n) {
             return Vector3d.create(this.x / n, this.y / n, this.z / n);
         }
@@ -93,16 +89,19 @@
         setTo(c) {
             this.x = c.x;
             this.y = c.y;
-            const v3d = c;
-            this.z = v3d.z ? v3d.z : Constants_js_1.originPoint.z;
+            this.z = getZ(c);
         }
         sub(v) {
-            return Vector3d.create(this.x - v.x, this.y - v.y, this.z - v.z);
+            return Vector3d.create(this.x - v.x, this.y - v.y, this.z - getZ(v));
         }
         subFrom(v) {
             this.x -= v.x;
             this.y -= v.y;
-            this.z -= v.z;
+            this.z -= getZ(v);
+        }
+        _updateFromAngle(angle, length) {
+            this.x = Math.cos(angle) * length;
+            this.y = Math.sin(angle) * length;
         }
     }
     exports.Vector3d = Vector3d;

package/umd/Enums/Types/EasingType.js

@@ -13,31 +13,46 @@
     var EasingType;
     (function (EasingType) {
         EasingType["easeInBack"] = "ease-in-back";
+        EasingType["easeInBounce"] = "ease-in-bounce";
         EasingType["easeInCirc"] = "ease-in-circ";
         EasingType["easeInCubic"] = "ease-in-cubic";
+        EasingType["easeInElastic"] = "ease-in-elastic";
+        EasingType["easeInExpo"] = "ease-in-expo";
+        EasingType["easeInGaussian"] = "ease-in-gaussian";
         EasingType["easeInLinear"] = "ease-in-linear";
         EasingType["easeInQuad"] = "ease-in-quad";
         EasingType["easeInQuart"] = "ease-in-quart";
         EasingType["easeInQuint"] = "ease-in-quint";
-        EasingType["easeInExpo"] = "ease-in-expo";
+        EasingType["easeInSigmoid"] = "ease-in-sigmoid";
         EasingType["easeInSine"] = "ease-in-sine";
+        EasingType["easeInSmoothstep"] = "ease-in-smoothstep";
         EasingType["easeOutBack"] = "ease-out-back";
+        EasingType["easeOutBounce"] = "ease-out-bounce";
         EasingType["easeOutCirc"] = "ease-out-circ";
         EasingType["easeOutCubic"] = "ease-out-cubic";
+        EasingType["easeOutElastic"] = "ease-out-elastic";
+        EasingType["easeOutExpo"] = "ease-out-expo";
+        EasingType["easeOutGaussian"] = "ease-out-gaussian";
         EasingType["easeOutLinear"] = "ease-out-linear";
         EasingType["easeOutQuad"] = "ease-out-quad";
         EasingType["easeOutQuart"] = "ease-out-quart";
         EasingType["easeOutQuint"] = "ease-out-quint";
-        EasingType["easeOutExpo"] = "ease-out-expo";
+        EasingType["easeOutSigmoid"] = "ease-out-sigmoid";
         EasingType["easeOutSine"] = "ease-out-sine";
+        EasingType["easeOutSmoothstep"] = "ease-out-smoothstep";
         EasingType["easeInOutBack"] = "ease-in-out-back";
+        EasingType["easeInOutBounce"] = "ease-in-out-bounce";
         EasingType["easeInOutCirc"] = "ease-in-out-circ";
         EasingType["easeInOutCubic"] = "ease-in-out-cubic";
+        EasingType["easeInOutElastic"] = "ease-in-out-elastic";
+        EasingType["easeInOutExpo"] = "ease-in-out-expo";
+        EasingType["easeInOutGaussian"] = "ease-in-out-gaussian";
         EasingType["easeInOutLinear"] = "ease-in-out-linear";
         EasingType["easeInOutQuad"] = "ease-in-out-quad";
         EasingType["easeInOutQuart"] = "ease-in-out-quart";
         EasingType["easeInOutQuint"] = "ease-in-out-quint";
-        EasingType["easeInOutExpo"] = "ease-in-out-expo";
+        EasingType["easeInOutSigmoid"] = "ease-in-out-sigmoid";
         EasingType["easeInOutSine"] = "ease-in-out-sine";
+        EasingType["easeInOutSmoothstep"] = "ease-in-out-smoothstep";
     })(EasingType || (exports.EasingType = EasingType = {}));
 });

package/umd/Options/Classes/AnimatableColor.js

@@ -14,6 +14,7 @@
     const HslAnimation_js_1 = require("./HslAnimation.js");
     const OptionsColor_js_1 = require("./OptionsColor.js");
     class AnimatableColor extends OptionsColor_js_1.OptionsColor {
+        animation;
         constructor() {
             super();
             this.animation = new HslAnimation_js_1.HslAnimation();

package/umd/Options/Classes/AnimationOptions.js

@@ -15,6 +15,12 @@
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class AnimationOptions {
+        count;
+        decay;
+        delay;
+        enable;
+        speed;
+        sync;
         constructor() {
             this.count = 0;
             this.enable = false;
@@ -49,6 +55,8 @@
     }
     exports.AnimationOptions = AnimationOptions;
     class RangedAnimationOptions extends AnimationOptions {
+        mode;
+        startValue;
         constructor() {
             super();
             this.mode = AnimationMode_js_1.AnimationMode.auto;

package/umd/Options/Classes/Background/Background.js

@@ -13,6 +13,12 @@
     const OptionsColor_js_1 = require("../OptionsColor.js");
     const TypeUtils_js_1 = require("../../../Utils/TypeUtils.js");
     class Background {
+        color;
+        image;
+        opacity;
+        position;
+        repeat;
+        size;
         constructor() {
             this.color = new OptionsColor_js_1.OptionsColor();
             this.color.value = "";

package/umd/Options/Classes/ColorAnimation.js

@@ -14,8 +14,13 @@
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class ColorAnimation extends AnimationOptions_js_1.AnimationOptions {
-        constructor() {
+        max;
+        min;
+        offset;
+        constructor(min, max) {
             super();
+            this.min = min;
+            this.max = max;
             this.offset = 0;
             this.sync = true;
         }
@@ -24,6 +29,12 @@
             if ((0, TypeUtils_js_1.isNull)(data)) {
                 return;
             }
+            if (data.max !== undefined) {
+                this.max = data.max;
+            }
+            if (data.min !== undefined) {
+                this.min = data.min;
+            }
             if (data.offset !== undefined) {
                 this.offset = (0, MathUtils_js_1.setRangeValue)(data.offset);
             }

package/umd/Options/Classes/FullScreen/FullScreen.js

@@ -12,6 +12,8 @@
     exports.FullScreen = void 0;
     const TypeUtils_js_1 = require("../../../Utils/TypeUtils.js");
     class FullScreen {
+        enable;
+        zIndex;
         constructor() {
             this.enable = true;
             this.zIndex = 0;

package/umd/Options/Classes/HslAnimation.js

@@ -4,20 +4,19 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./ColorAnimation.js", "../../Utils/TypeUtils.js"], factory);
+        define(["require", "exports", "../../Core/Utils/Constants.js", "./ColorAnimation.js", "../../Utils/TypeUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.HslAnimation = void 0;
+    const Constants_js_1 = require("../../Core/Utils/Constants.js");
     const ColorAnimation_js_1 = require("./ColorAnimation.js");
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     class HslAnimation {
-        constructor() {
-            this.h = new ColorAnimation_js_1.ColorAnimation();
-            this.s = new ColorAnimation_js_1.ColorAnimation();
-            this.l = new ColorAnimation_js_1.ColorAnimation();
-        }
+        h = new ColorAnimation_js_1.ColorAnimation(Constants_js_1.hMin, Constants_js_1.hMax);
+        l = new ColorAnimation_js_1.ColorAnimation(Constants_js_1.lMin, Constants_js_1.lMax);
+        s = new ColorAnimation_js_1.ColorAnimation(Constants_js_1.sMin, Constants_js_1.sMax);
         load(data) {
             if ((0, TypeUtils_js_1.isNull)(data)) {
                 return;

package/umd/Options/Classes/Options.js

@@ -18,10 +18,30 @@
     const OptionsUtils_js_1 = require("../../Utils/OptionsUtils.js");
     const MathUtils_js_1 = require("../../Utils/MathUtils.js");
     class Options {
+        autoPlay;
+        background;
+        clear;
+        defaultThemes;
+        delay;
+        detectRetina;
+        duration;
+        fpsLimit;
+        fullScreen;
+        hdr;
+        key;
+        name;
+        palette;
+        particles;
+        pauseOnBlur;
+        pauseOnOutsideViewport;
+        preset;
+        resize;
+        smooth;
+        style;
+        zLayers;
+        _container;
+        _engine;
         constructor(engine, container) {
-            this._importPreset = preset => {
-                this.load(this._engine.getPreset(preset));
-            };
             this._engine = engine;
             this._container = container;
             this.autoPlay = true;
@@ -47,10 +67,15 @@
                 return;
             }
             if (data.preset !== undefined) {
-                (0, Utils_js_1.executeOnSingleOrMultiple)(data.preset, preset => {
+                this.preset = data.preset;
+                (0, Utils_js_1.executeOnSingleOrMultiple)(this.preset, preset => {
                     this._importPreset(preset);
                 });
             }
+            if (data.palette !== undefined) {
+                this.palette = data.palette;
+                this._importPalette(this.palette);
+            }
             if (data.autoPlay !== undefined) {
                 this.autoPlay = data.autoPlay;
             }
@@ -107,6 +132,40 @@
                 plugin.loadOptions(this._container, this, data);
             });
         }
+        _importPalette = palette => {
+            const paletteData = this._engine.getPalette(palette);
+            if (!paletteData) {
+                return;
+            }
+            this.load({
+                background: {
+                    color: paletteData.background,
+                },
+                blend: {
+                    enable: true,
+                    mode: paletteData.blendMode,
+                },
+                particles: {
+                    fill: {
+                        color: paletteData.fill
+                            ? {
+                                value: paletteData.colors,
+                            }
+                            : undefined,
+                        enable: paletteData.fill,
+                    },
+                    stroke: !paletteData.fill
+                        ? paletteData.colors.map(color => ({
+                            color: { value: color },
+                            width: 1,
+                        }))
+                        : undefined,
+                },
+            });
+        };
+        _importPreset = preset => {
+            this.load(this._engine.getPreset(preset));
+        };
     }
     exports.Options = Options;
 });

package/umd/Options/Classes/OptionsColor.js

@@ -12,6 +12,7 @@
     exports.OptionsColor = void 0;
     const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
     class OptionsColor {
+        value;
         constructor() {
             this.value = "";
         }

package/umd/Options/Classes/Particles/Bounce/ParticlesBounce.js

@@ -13,6 +13,8 @@
     const ParticlesBounceFactor_js_1 = require("./ParticlesBounceFactor.js");
     const TypeUtils_js_1 = require("../../../../Utils/TypeUtils.js");
     class ParticlesBounce {
+        horizontal;
+        vertical;
         constructor() {
             this.horizontal = new ParticlesBounceFactor_js_1.ParticlesBounceFactor();
             this.vertical = new ParticlesBounceFactor_js_1.ParticlesBounceFactor();

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

@@ -13,9 +13,11 @@
     const Utils_js_1 = require("../../../../Utils/Utils.js");
     const TypeUtils_js_1 = require("../../../../Utils/TypeUtils.js");
     class Effect {
+        close;
+        options;
+        type;
         constructor() {
             this.close = true;
-            this.fill = true;
             this.options = {};
             this.type = [];
         }
@@ -35,9 +37,6 @@
             if (data.close !== undefined) {
                 this.close = data.close;
             }
-            if (data.fill !== undefined) {
-                this.fill = data.fill;
-            }
             if (data.type !== undefined) {
                 this.type = data.type;
             }

package/umd/Options/Classes/Particles/Fill.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", "../AnimatableColor.js", "../../../Utils/TypeUtils.js", "../../../Utils/MathUtils.js"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Fill = void 0;
+    const AnimatableColor_js_1 = require("../AnimatableColor.js");
+    const TypeUtils_js_1 = require("../../../Utils/TypeUtils.js");
+    const MathUtils_js_1 = require("../../../Utils/MathUtils.js");
+    class Fill {
+        color;
+        enable;
+        opacity;
+        constructor() {
+            this.enable = true;
+            this.color = new AnimatableColor_js_1.AnimatableColor();
+            this.color.value = "#fff";
+            this.opacity = 1;
+        }
+        load(data) {
+            if ((0, TypeUtils_js_1.isNull)(data)) {
+                return;
+            }
+            if (data.color !== undefined) {
+                this.color = AnimatableColor_js_1.AnimatableColor.create(this.color, data.color);
+            }
+            if (data.enable !== undefined) {
+                this.enable = data.enable;
+            }
+            if (data.opacity !== undefined) {
+                this.opacity = (0, MathUtils_js_1.setRangeValue)(data.opacity);
+            }
+        }
+    }
+    exports.Fill = Fill;
+});

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

@@ -4,7 +4,7 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "../../../../Enums/Directions/MoveDirection.js", "../../../../Utils/TypeUtils.js", "./MoveAngle.js", "./MoveAttract.js", "./MoveCenter.js", "./MoveGravity.js", "./Path/MovePath.js", "./OutModes.js", "./Spin.js", "../../../../Utils/MathUtils.js"], factory);
+        define(["require", "exports", "../../../../Enums/Directions/MoveDirection.js", "../../../../Utils/TypeUtils.js", "./MoveAngle.js", "./MoveCenter.js", "./MoveGravity.js", "./Path/MovePath.js", "./OutModes.js", "./Spin.js", "../../../../Utils/MathUtils.js"], factory);
     }
 })(function (require, exports) {
     "use strict";
@@ -13,7 +13,6 @@
     const MoveDirection_js_1 = require("../../../../Enums/Directions/MoveDirection.js");
     const TypeUtils_js_1 = require("../../../../Utils/TypeUtils.js");
     const MoveAngle_js_1 = require("./MoveAngle.js");
-    const MoveAttract_js_1 = require("./MoveAttract.js");
     const MoveCenter_js_1 = require("./MoveCenter.js");
     const MoveGravity_js_1 = require("./MoveGravity.js");
     const MovePath_js_1 = require("./Path/MovePath.js");
@@ -21,9 +20,25 @@
     const Spin_js_1 = require("./Spin.js");
     const MathUtils_js_1 = require("../../../../Utils/MathUtils.js");
     class Move {
+        angle;
+        center;
+        decay;
+        direction;
+        distance;
+        drift;
+        enable;
+        gravity;
+        outModes;
+        path;
+        random;
+        size;
+        speed;
+        spin;
+        straight;
+        vibrate;
+        warp;
         constructor() {
             this.angle = new MoveAngle_js_1.MoveAngle();
-            this.attract = new MoveAttract_js_1.MoveAttract();
             this.center = new MoveCenter_js_1.MoveCenter();
             this.decay = 0;
             this.distance = {};
@@ -46,7 +61,6 @@
                 return;
             }
             this.angle.load((0, TypeUtils_js_1.isNumber)(data.angle) ? { value: data.angle } : data.angle);
-            this.attract.load(data.attract);
             this.center.load(data.center);
             if (data.decay !== undefined) {
                 this.decay = (0, MathUtils_js_1.setRangeValue)(data.decay);