tsparticles 1.40.2 → 1.41.3

package/umd/Core/Utils/ParticlesMover.js

@@ -0,0 +1,196 @@
+(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.ParticlesMover = void 0;
+    const Utils_1 = require("../../Utils");
+    function applyDistance(particle) {
+        const initialPosition = particle.initialPosition;
+        const { dx, dy } = (0, Utils_1.getDistances)(initialPosition, particle.position);
+        const dxFixed = Math.abs(dx), dyFixed = Math.abs(dy);
+        const hDistance = particle.retina.maxDistance.horizontal;
+        const vDistance = particle.retina.maxDistance.vertical;
+        if (!hDistance && !vDistance) {
+            return;
+        }
+        if (((hDistance && dxFixed >= hDistance) || (vDistance && dyFixed >= vDistance)) && !particle.misplaced) {
+            particle.misplaced = (!!hDistance && dxFixed > hDistance) || (!!vDistance && dyFixed > vDistance);
+            if (hDistance) {
+                particle.velocity.x = particle.velocity.y / 2 - particle.velocity.x;
+            }
+            if (vDistance) {
+                particle.velocity.y = particle.velocity.x / 2 - particle.velocity.y;
+            }
+        }
+        else if ((!hDistance || dxFixed < hDistance) && (!vDistance || dyFixed < vDistance) && particle.misplaced) {
+            particle.misplaced = false;
+        }
+        else if (particle.misplaced) {
+            const pos = particle.position, vel = particle.velocity;
+            if (hDistance && ((pos.x < initialPosition.x && vel.x < 0) || (pos.x > initialPosition.x && vel.x > 0))) {
+                vel.x *= -Math.random();
+            }
+            if (vDistance && ((pos.y < initialPosition.y && vel.y < 0) || (pos.y > initialPosition.y && vel.y > 0))) {
+                vel.y *= -Math.random();
+            }
+        }
+    }
+    class ParticlesMover {
+        constructor(container) {
+            this.container = container;
+        }
+        move(particle, delta) {
+            if (particle.destroyed) {
+                return;
+            }
+            this.moveParticle(particle, delta);
+            this.moveParallax(particle);
+        }
+        moveParticle(particle, delta) {
+            var _a, _b, _c;
+            var _d, _e;
+            const particleOptions = particle.options;
+            const moveOptions = particleOptions.move;
+            if (!moveOptions.enable) {
+                return;
+            }
+            const container = this.container, slowFactor = this.getProximitySpeedFactor(particle), baseSpeed = ((_a = (_d = particle.retina).moveSpeed) !== null && _a !== void 0 ? _a : (_d.moveSpeed = (0, Utils_1.getRangeValue)(moveOptions.speed) * container.retina.pixelRatio)) *
+                container.retina.reduceFactor, moveDrift = ((_b = (_e = particle.retina).moveDrift) !== null && _b !== void 0 ? _b : (_e.moveDrift = (0, Utils_1.getRangeValue)(particle.options.move.drift) * container.retina.pixelRatio)), maxSize = (0, Utils_1.getRangeMax)(particleOptions.size.value) * container.retina.pixelRatio, sizeFactor = moveOptions.size ? particle.getRadius() / maxSize : 1, diffFactor = 2, speedFactor = (sizeFactor * slowFactor * (delta.factor || 1)) / diffFactor, moveSpeed = baseSpeed * speedFactor;
+            this.applyPath(particle, delta);
+            const gravityOptions = moveOptions.gravity;
+            const gravityFactor = gravityOptions.enable && gravityOptions.inverse ? -1 : 1;
+            if (gravityOptions.enable && moveSpeed) {
+                particle.velocity.y += (gravityFactor * (gravityOptions.acceleration * delta.factor)) / (60 * moveSpeed);
+            }
+            if (moveDrift && moveSpeed) {
+                particle.velocity.x += (moveDrift * delta.factor) / (60 * moveSpeed);
+            }
+            const decay = particle.moveDecay;
+            if (decay != 1) {
+                particle.velocity.multTo(decay);
+            }
+            const velocity = particle.velocity.mult(moveSpeed);
+            const maxSpeed = (_c = particle.retina.maxSpeed) !== null && _c !== void 0 ? _c : container.retina.maxSpeed;
+            if (gravityOptions.enable &&
+                gravityOptions.maxSpeed > 0 &&
+                ((!gravityOptions.inverse && velocity.y >= 0 && velocity.y >= maxSpeed) ||
+                    (gravityOptions.inverse && velocity.y <= 0 && velocity.y <= -maxSpeed))) {
+                velocity.y = gravityFactor * maxSpeed;
+                if (moveSpeed) {
+                    particle.velocity.y = velocity.y / moveSpeed;
+                }
+            }
+            const zIndexOptions = particle.options.zIndex, zVelocityFactor = (1 - particle.zIndexFactor) ** zIndexOptions.velocityRate;
+            if (moveOptions.spin.enable) {
+                this.spin(particle, moveSpeed);
+            }
+            else {
+                if (zVelocityFactor != 1) {
+                    velocity.multTo(zVelocityFactor);
+                }
+                particle.position.addTo(velocity);
+                if (moveOptions.vibrate) {
+                    particle.position.x += Math.sin(particle.position.x * Math.cos(particle.position.y));
+                    particle.position.y += Math.cos(particle.position.y * Math.sin(particle.position.x));
+                }
+            }
+            applyDistance(particle);
+        }
+        spin(particle, moveSpeed) {
+            const container = this.container;
+            if (!particle.spin) {
+                return;
+            }
+            const updateFunc = {
+                x: particle.spin.direction === "clockwise" ? Math.cos : Math.sin,
+                y: particle.spin.direction === "clockwise" ? Math.sin : Math.cos,
+            };
+            particle.position.x = particle.spin.center.x + particle.spin.radius * updateFunc.x(particle.spin.angle);
+            particle.position.y = particle.spin.center.y + particle.spin.radius * updateFunc.y(particle.spin.angle);
+            particle.spin.radius += particle.spin.acceleration;
+            const maxCanvasSize = Math.max(container.canvas.size.width, container.canvas.size.height);
+            if (particle.spin.radius > maxCanvasSize / 2) {
+                particle.spin.radius = maxCanvasSize / 2;
+                particle.spin.acceleration *= -1;
+            }
+            else if (particle.spin.radius < 0) {
+                particle.spin.radius = 0;
+                particle.spin.acceleration *= -1;
+            }
+            particle.spin.angle += (moveSpeed / 100) * (1 - particle.spin.radius / maxCanvasSize);
+        }
+        applyPath(particle, delta) {
+            const particlesOptions = particle.options;
+            const pathOptions = particlesOptions.move.path;
+            const pathEnabled = pathOptions.enable;
+            if (!pathEnabled) {
+                return;
+            }
+            const container = this.container;
+            if (particle.lastPathTime <= particle.pathDelay) {
+                particle.lastPathTime += delta.value;
+                return;
+            }
+            const path = container.pathGenerator.generate(particle);
+            particle.velocity.addTo(path);
+            if (pathOptions.clamp) {
+                particle.velocity.x = (0, Utils_1.clamp)(particle.velocity.x, -1, 1);
+                particle.velocity.y = (0, Utils_1.clamp)(particle.velocity.y, -1, 1);
+            }
+            particle.lastPathTime -= particle.pathDelay;
+        }
+        moveParallax(particle) {
+            const container = this.container;
+            const options = container.actualOptions;
+            if ((0, Utils_1.isSsr)() || !options.interactivity.events.onHover.parallax.enable) {
+                return;
+            }
+            const parallaxForce = options.interactivity.events.onHover.parallax.force;
+            const mousePos = container.interactivity.mouse.position;
+            if (!mousePos) {
+                return;
+            }
+            const canvasCenter = {
+                x: container.canvas.size.width / 2,
+                y: container.canvas.size.height / 2,
+            };
+            const parallaxSmooth = options.interactivity.events.onHover.parallax.smooth;
+            const factor = particle.getRadius() / parallaxForce;
+            const tmp = {
+                x: (mousePos.x - canvasCenter.x) * factor,
+                y: (mousePos.y - canvasCenter.y) * factor,
+            };
+            particle.offset.x += (tmp.x - particle.offset.x) / parallaxSmooth;
+            particle.offset.y += (tmp.y - particle.offset.y) / parallaxSmooth;
+        }
+        getProximitySpeedFactor(particle) {
+            const container = this.container;
+            const options = container.actualOptions;
+            const active = (0, Utils_1.isInArray)("slow", options.interactivity.events.onHover.mode);
+            if (!active) {
+                return 1;
+            }
+            const mousePos = this.container.interactivity.mouse.position;
+            if (!mousePos) {
+                return 1;
+            }
+            const particlePos = particle.getPosition();
+            const dist = (0, Utils_1.getDistance)(mousePos, particlePos);
+            const radius = container.retina.slowModeRadius;
+            if (dist > radius) {
+                return 1;
+            }
+            const proximityFactor = dist / radius || 0;
+            const slowFactor = options.interactivity.modes.slow.factor;
+            return proximityFactor / slowFactor;
+        }
+    }
+    exports.ParticlesMover = ParticlesMover;
+});

package/umd/Core/Utils/Plugins.d.ts

@@ -0,0 +1,36 @@
+import type { IContainerPlugin, IInteractor, IMovePathGenerator, IParticleUpdater, IPlugin, IShapeDrawer } from "../Interfaces";
+import type { Container } from "../Container";
+import type { Engine } from "../../engine";
+import type { IOptions } from "../../Options/Interfaces/IOptions";
+import type { Options } from "../../Options/Classes/Options";
+import type { RecursivePartial } from "../../Types";
+declare type InteractorInitializer = (container: Container) => IInteractor;
+declare type UpdaterInitializer = (container: Container) => IParticleUpdater;
+export declare class Plugins {
+    #private;
+    readonly plugins: IPlugin[];
+    readonly interactorsInitializers: Map<string, InteractorInitializer>;
+    readonly updatersInitializers: Map<string, UpdaterInitializer>;
+    readonly interactors: Map<Container, IInteractor[]>;
+    readonly updaters: Map<Container, IParticleUpdater[]>;
+    readonly presets: Map<string, RecursivePartial<IOptions>>;
+    readonly drawers: Map<string, IShapeDrawer>;
+    readonly pathGenerators: Map<string, IMovePathGenerator>;
+    constructor(engine: Engine);
+    getPlugin(plugin: string): IPlugin | undefined;
+    addPlugin(plugin: IPlugin): void;
+    getAvailablePlugins(container: Container): Map<string, IContainerPlugin>;
+    loadOptions(options: Options, sourceOptions: RecursivePartial<IOptions>): void;
+    getPreset(preset: string): RecursivePartial<IOptions> | undefined;
+    addPreset(presetKey: string, options: RecursivePartial<IOptions>, override?: boolean): void;
+    addShapeDrawer(type: string, drawer: IShapeDrawer): void;
+    getShapeDrawer(type: string): IShapeDrawer | undefined;
+    getSupportedShapes(): IterableIterator<string>;
+    getPathGenerator(type: string): IMovePathGenerator | undefined;
+    addPathGenerator(type: string, pathGenerator: IMovePathGenerator): void;
+    getInteractors(container: Container, force?: boolean): IInteractor[];
+    addInteractor(name: string, initInteractor: (container: Container) => IInteractor): void;
+    getUpdaters(container: Container, force?: boolean): IParticleUpdater[];
+    addParticleUpdater(name: string, initUpdater: (container: Container) => IParticleUpdater): void;
+}
+export {};

package/umd/Core/Utils/Plugins.js

@@ -0,0 +1,108 @@
+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;
+};
+(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";
+    var _Plugins_engine;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Plugins = void 0;
+    class Plugins {
+        constructor(engine) {
+            _Plugins_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _Plugins_engine, engine, "f");
+            this.plugins = [];
+            this.interactorsInitializers = new Map();
+            this.updatersInitializers = new Map();
+            this.interactors = new Map();
+            this.updaters = new Map();
+            this.presets = new Map();
+            this.drawers = new Map();
+            this.pathGenerators = new Map();
+        }
+        getPlugin(plugin) {
+            return this.plugins.find((t) => t.id === plugin);
+        }
+        addPlugin(plugin) {
+            if (!this.getPlugin(plugin.id)) {
+                this.plugins.push(plugin);
+            }
+        }
+        getAvailablePlugins(container) {
+            const res = new Map();
+            for (const plugin of this.plugins) {
+                if (!plugin.needsPlugin(container.actualOptions)) {
+                    continue;
+                }
+                res.set(plugin.id, plugin.getPlugin(container));
+            }
+            return res;
+        }
+        loadOptions(options, sourceOptions) {
+            for (const plugin of this.plugins) {
+                plugin.loadOptions(options, sourceOptions);
+            }
+        }
+        getPreset(preset) {
+            return this.presets.get(preset);
+        }
+        addPreset(presetKey, options, override = false) {
+            if (override || !this.getPreset(presetKey)) {
+                this.presets.set(presetKey, options);
+            }
+        }
+        addShapeDrawer(type, drawer) {
+            if (!this.getShapeDrawer(type)) {
+                this.drawers.set(type, drawer);
+            }
+        }
+        getShapeDrawer(type) {
+            return this.drawers.get(type);
+        }
+        getSupportedShapes() {
+            return this.drawers.keys();
+        }
+        getPathGenerator(type) {
+            return this.pathGenerators.get(type);
+        }
+        addPathGenerator(type, pathGenerator) {
+            if (!this.getPathGenerator(type)) {
+                this.pathGenerators.set(type, pathGenerator);
+            }
+        }
+        getInteractors(container, force = false) {
+            let res = this.interactors.get(container);
+            if (!res || force) {
+                res = [...this.interactorsInitializers.values()].map((t) => t(container));
+                this.interactors.set(container, res);
+            }
+            return res;
+        }
+        addInteractor(name, initInteractor) {
+            this.interactorsInitializers.set(name, initInteractor);
+        }
+        getUpdaters(container, force = false) {
+            let res = this.updaters.get(container);
+            if (!res || force) {
+                res = [...this.updatersInitializers.values()].map((t) => t(container));
+                this.updaters.set(container, res);
+            }
+            return res;
+        }
+        addParticleUpdater(name, initUpdater) {
+            this.updatersInitializers.set(name, initUpdater);
+        }
+    }
+    exports.Plugins = Plugins;
+    _Plugins_engine = new WeakMap();
+});

package/umd/Core/Utils/Point.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../Interfaces";
+import type { Particle } from "../Particle";
+export declare class Point {
+    readonly position: ICoordinates;
+    readonly particle: Particle;
+    constructor(position: ICoordinates, particle: Particle);
+}

package/umd/Core/Utils/Point.js

@@ -0,0 +1,20 @@
+(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.Point = void 0;
+    class Point {
+        constructor(position, particle) {
+            this.position = position;
+            this.particle = particle;
+        }
+    }
+    exports.Point = Point;
+});

package/umd/Core/Utils/QuadTree.d.ts

@@ -0,0 +1,23 @@
+import type { ICoordinates, IDimension } from "../Interfaces";
+import type { Container } from "../Container";
+import type { Particle } from "../Particle";
+import type { Point } from "./Point";
+import type { Range } from "./Range";
+import { Rectangle } from "./Rectangle";
+export declare class QuadTree {
+    readonly rectangle: Rectangle;
+    readonly capacity: number;
+    readonly points: Point[];
+    private northEast?;
+    private northWest?;
+    private southEast?;
+    private southWest?;
+    private divided;
+    constructor(rectangle: Rectangle, capacity: number);
+    subdivide(): void;
+    insert(point: Point): boolean;
+    queryCircle(position: ICoordinates, radius: number): Particle[];
+    queryCircleWarp(position: ICoordinates, radius: number, containerOrSize: Container | IDimension): Particle[];
+    queryRectangle(position: ICoordinates, size: IDimension): Particle[];
+    query(range: Range, found?: Particle[]): Particle[];
+}

package/umd/Core/Utils/QuadTree.js

@@ -0,0 +1,88 @@
+(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", "./Circle", "./CircleWarp", "./Rectangle", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.QuadTree = void 0;
+    const Circle_1 = require("./Circle");
+    const CircleWarp_1 = require("./CircleWarp");
+    const Rectangle_1 = require("./Rectangle");
+    const Utils_1 = require("../../Utils");
+    class QuadTree {
+        constructor(rectangle, capacity) {
+            this.rectangle = rectangle;
+            this.capacity = capacity;
+            this.points = [];
+            this.divided = false;
+        }
+        subdivide() {
+            const x = this.rectangle.position.x;
+            const y = this.rectangle.position.y;
+            const w = this.rectangle.size.width;
+            const h = this.rectangle.size.height;
+            const capacity = this.capacity;
+            this.northEast = new QuadTree(new Rectangle_1.Rectangle(x, y, w / 2, h / 2), capacity);
+            this.northWest = new QuadTree(new Rectangle_1.Rectangle(x + w / 2, y, w / 2, h / 2), capacity);
+            this.southEast = new QuadTree(new Rectangle_1.Rectangle(x, y + h / 2, w / 2, h / 2), capacity);
+            this.southWest = new QuadTree(new Rectangle_1.Rectangle(x + w / 2, y + h / 2, w / 2, h / 2), capacity);
+            this.divided = true;
+        }
+        insert(point) {
+            var _a, _b, _c, _d, _e;
+            if (!this.rectangle.contains(point.position)) {
+                return false;
+            }
+            if (this.points.length < this.capacity) {
+                this.points.push(point);
+                return true;
+            }
+            if (!this.divided) {
+                this.subdivide();
+            }
+            return ((_e = (((_a = this.northEast) === null || _a === void 0 ? void 0 : _a.insert(point)) ||
+                ((_b = this.northWest) === null || _b === void 0 ? void 0 : _b.insert(point)) ||
+                ((_c = this.southEast) === null || _c === void 0 ? void 0 : _c.insert(point)) ||
+                ((_d = this.southWest) === null || _d === void 0 ? void 0 : _d.insert(point)))) !== null && _e !== void 0 ? _e : false);
+        }
+        queryCircle(position, radius) {
+            return this.query(new Circle_1.Circle(position.x, position.y, radius));
+        }
+        queryCircleWarp(position, radius, containerOrSize) {
+            const container = containerOrSize;
+            const size = containerOrSize;
+            return this.query(new CircleWarp_1.CircleWarp(position.x, position.y, radius, container.canvas !== undefined ? container.canvas.size : size));
+        }
+        queryRectangle(position, size) {
+            return this.query(new Rectangle_1.Rectangle(position.x, position.y, size.width, size.height));
+        }
+        query(range, found) {
+            var _a, _b, _c, _d;
+            const res = found !== null && found !== void 0 ? found : [];
+            if (!range.intersects(this.rectangle)) {
+                return [];
+            }
+            else {
+                for (const p of this.points) {
+                    if (!range.contains(p.position) && (0, Utils_1.getDistance)(range.position, p.position) > p.particle.getRadius()) {
+                        continue;
+                    }
+                    res.push(p.particle);
+                }
+                if (this.divided) {
+                    (_a = this.northEast) === null || _a === void 0 ? void 0 : _a.query(range, res);
+                    (_b = this.northWest) === null || _b === void 0 ? void 0 : _b.query(range, res);
+                    (_c = this.southEast) === null || _c === void 0 ? void 0 : _c.query(range, res);
+                    (_d = this.southWest) === null || _d === void 0 ? void 0 : _d.query(range, res);
+                }
+            }
+            return res;
+        }
+    }
+    exports.QuadTree = QuadTree;
+});

package/umd/Core/Utils/Range.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates } from "../Interfaces";
+export declare abstract class Range {
+    readonly position: ICoordinates;
+    protected constructor(x: number, y: number);
+    abstract contains(point: ICoordinates): boolean;
+    abstract intersects(range: Range): boolean;
+}

package/umd/Core/Utils/Range.js

@@ -0,0 +1,22 @@
+(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.Range = void 0;
+    class Range {
+        constructor(x, y) {
+            this.position = {
+                x: x,
+                y: y,
+            };
+        }
+    }
+    exports.Range = Range;
+});

package/umd/Core/Utils/Rectangle.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates, IDimension } from "../Interfaces";
+import { Range } from "./Range";
+export declare class Rectangle extends Range {
+    readonly size: IDimension;
+    constructor(x: number, y: number, width: number, height: number);
+    contains(point: ICoordinates): boolean;
+    intersects(range: Range): boolean;
+}

package/umd/Core/Utils/Rectangle.js

@@ -0,0 +1,48 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Range"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Rectangle = void 0;
+    const Range_1 = require("./Range");
+    class Rectangle extends Range_1.Range {
+        constructor(x, y, width, height) {
+            super(x, y);
+            this.size = {
+                height: height,
+                width: width,
+            };
+        }
+        contains(point) {
+            const w = this.size.width;
+            const h = this.size.height;
+            const pos = this.position;
+            return point.x >= pos.x && point.x <= pos.x + w && point.y >= pos.y && point.y <= pos.y + h;
+        }
+        intersects(range) {
+            const rect = range;
+            const circle = range;
+            const w = this.size.width;
+            const h = this.size.height;
+            const pos1 = this.position;
+            const pos2 = range.position;
+            if (circle.radius !== undefined) {
+                return circle.intersects(this);
+            }
+            else if (rect.size !== undefined) {
+                const size2 = rect.size;
+                const w2 = size2.width;
+                const h2 = size2.height;
+                return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
+            }
+            return false;
+        }
+    }
+    exports.Rectangle = Rectangle;
+});

package/umd/Core/Utils/Vector.d.ts

@@ -0,0 +1,29 @@
+import type { ICoordinates } from "../Interfaces";
+export declare class Vector implements ICoordinates {
+    static clone(source: Vector): Vector;
+    static create(x: number | ICoordinates, y?: number): Vector;
+    static get origin(): Vector;
+    get angle(): number;
+    set angle(angle: number);
+    get length(): number;
+    set length(length: number);
+    x: number;
+    y: number;
+    protected constructor(x: number | ICoordinates, y?: number);
+    add(v: Vector): Vector;
+    addTo(v: Vector): void;
+    sub(v: Vector): Vector;
+    subFrom(v: Vector): void;
+    mult(n: number): Vector;
+    multTo(n: number): void;
+    div(n: number): Vector;
+    divTo(n: number): void;
+    distanceTo(v: Vector): number;
+    getLengthSq(): number;
+    distanceToSq(v: Vector): number;
+    manhattanDistanceTo(v: Vector): number;
+    copy(): Vector;
+    setTo(velocity: Vector): void;
+    rotate(angle: number): Vector;
+    private updateFromAngle;
+}