@tsparticles/engine 3.9.1 → 4.0.0-alpha.1

package/cjs/Core/Utils/EventListeners.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventListeners = void 0;
-const Constants_js_1 = require("./Constants.js");
-const Utils_js_1 = require("../../Utils/Utils.js");
-const InteractivityDetect_js_1 = require("../../Enums/InteractivityDetect.js");
-const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
+import { double, lengthOffset, millisecondsToSeconds, mouseDownEvent, mouseLeaveEvent, mouseMoveEvent, mouseOutEvent, mouseUpEvent, resizeEvent, touchCancelEvent, touchDelay, touchEndEvent, touchMoveEvent, touchStartEvent, visibilityChangeEvent, } from "./Constants.js";
+import { executeOnSingleOrMultiple, safeDocument, safeMatchMedia } from "../../Utils/Utils.js";
+import { InteractivityDetect } from "../../Enums/InteractivityDetect.js";
+import { isBoolean } from "../../Utils/TypeUtils.js";
 function manageListener(element, event, handler, add, options) {
     if (add) {
         let addOptions = { passive: true };
-        if ((0, TypeUtils_js_1.isBoolean)(options)) {
+        if (isBoolean(options)) {
             addOptions.capture = options;
         }
         else if (options !== undefined) {
@@ -21,9 +18,10 @@ function manageListener(element, event, handler, add, options) {
         element.removeEventListener(event, handler, removeOptions);
     }
 }
-class EventListeners {
+export class EventListeners {
     constructor(container) {
         this.container = container;
+        this._canPush = true;
         this._doMouseTouchClick = e => {
             const container = this.container, options = container.actualOptions;
             if (this._canPush) {
@@ -32,12 +30,16 @@ class EventListeners {
                     return;
                 }
                 mouseInteractivity.clickPosition = { ...mousePos };
-                mouseInteractivity.clickTime = new Date().getTime();
+                mouseInteractivity.clickTime = Date.now();
                 const onClick = options.interactivity.events.onClick;
-                (0, Utils_js_1.executeOnSingleOrMultiple)(onClick.mode, mode => this.container.handleClickMode(mode));
+                executeOnSingleOrMultiple(onClick.mode, mode => {
+                    this.container.handleClickMode(mode);
+                });
             }
             if (e.type === "touchend") {
-                setTimeout(() => this._mouseTouchFinish(), Constants_js_1.touchDelay);
+                setTimeout(() => {
+                    this._mouseTouchFinish();
+                }, touchDelay);
             }
         };
         this._handleThemeChange = (e) => {
@@ -52,17 +54,17 @@ class EventListeners {
             if (!options.pauseOnBlur) {
                 return;
             }
-            if (document?.hidden) {
+            if (safeDocument().hidden) {
                 container.pageHidden = true;
                 container.pause();
             }
             else {
                 container.pageHidden = false;
                 if (container.animationStatus) {
-                    void container.play(true);
+                    container.play(true);
                 }
                 else {
-                    void container.draw(true);
+                    container.draw(true);
                 }
             }
         };
@@ -73,9 +75,9 @@ class EventListeners {
             }
             const handleResize = async () => {
                 const canvas = this.container.canvas;
-                await canvas?.windowResize();
+                await canvas.windowResize();
             };
-            this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * Constants_js_1.millisecondsToSeconds);
+            this._resizeTimeout = setTimeout(() => void handleResize(), this.container.actualOptions.interactivity.events.resize.delay * millisecondsToSeconds);
         };
         this._manageInteractivityListeners = (mouseLeaveTmpEvent, add) => {
             const handlers = this._handlers, container = this.container, options = container.actualOptions, interactivityEl = container.interactivity.element;
@@ -87,28 +89,28 @@ class EventListeners {
             if (!(options.interactivity.events.onHover.enable || options.interactivity.events.onClick.enable)) {
                 return;
             }
-            manageListener(interactivityEl, Constants_js_1.mouseMoveEvent, handlers.mouseMove, add);
-            manageListener(interactivityEl, Constants_js_1.touchStartEvent, handlers.touchStart, add);
-            manageListener(interactivityEl, Constants_js_1.touchMoveEvent, handlers.touchMove, add);
-            if (!options.interactivity.events.onClick.enable) {
-                manageListener(interactivityEl, Constants_js_1.touchEndEvent, handlers.touchEnd, add);
+            manageListener(interactivityEl, mouseMoveEvent, handlers.mouseMove, add);
+            manageListener(interactivityEl, touchStartEvent, handlers.touchStart, add);
+            manageListener(interactivityEl, touchMoveEvent, handlers.touchMove, add);
+            if (options.interactivity.events.onClick.enable) {
+                manageListener(interactivityEl, touchEndEvent, handlers.touchEndClick, add);
+                manageListener(interactivityEl, mouseUpEvent, handlers.mouseUp, add);
+                manageListener(interactivityEl, mouseDownEvent, handlers.mouseDown, add);
             }
             else {
-                manageListener(interactivityEl, Constants_js_1.touchEndEvent, handlers.touchEndClick, add);
-                manageListener(interactivityEl, Constants_js_1.mouseUpEvent, handlers.mouseUp, add);
-                manageListener(interactivityEl, Constants_js_1.mouseDownEvent, handlers.mouseDown, add);
+                manageListener(interactivityEl, touchEndEvent, handlers.touchEnd, add);
             }
             manageListener(interactivityEl, mouseLeaveTmpEvent, handlers.mouseLeave, add);
-            manageListener(interactivityEl, Constants_js_1.touchCancelEvent, handlers.touchCancel, add);
+            manageListener(interactivityEl, touchCancelEvent, handlers.touchCancel, add);
         };
         this._manageListeners = add => {
             const handlers = this._handlers, container = this.container, options = container.actualOptions, detectType = options.interactivity.detectsOn, canvasEl = container.canvas.element;
-            let mouseLeaveTmpEvent = Constants_js_1.mouseLeaveEvent;
-            if (detectType === InteractivityDetect_js_1.InteractivityDetect.window) {
+            let mouseLeaveTmpEvent = mouseLeaveEvent;
+            if (detectType === InteractivityDetect.window) {
                 container.interactivity.element = window;
-                mouseLeaveTmpEvent = Constants_js_1.mouseOutEvent;
+                mouseLeaveTmpEvent = mouseOutEvent;
             }
-            else if (detectType === InteractivityDetect_js_1.InteractivityDetect.parent && canvasEl) {
+            else if (detectType === InteractivityDetect.parent && canvasEl) {
                 container.interactivity.element = canvasEl.parentElement ?? canvasEl.parentNode;
             }
             else {
@@ -117,36 +119,22 @@ class EventListeners {
             this._manageMediaMatch(add);
             this._manageResize(add);
             this._manageInteractivityListeners(mouseLeaveTmpEvent, add);
-            if (document) {
-                manageListener(document, Constants_js_1.visibilityChangeEvent, handlers.visibilityChange, add, false);
-            }
+            manageListener(document, visibilityChangeEvent, handlers.visibilityChange, add, false);
         };
         this._manageMediaMatch = add => {
-            const handlers = this._handlers, mediaMatch = (0, Utils_js_1.safeMatchMedia)("(prefers-color-scheme: dark)");
-            if (!mediaMatch) {
-                return;
-            }
-            if (mediaMatch.addEventListener !== undefined) {
-                manageListener(mediaMatch, "change", handlers.themeChange, add);
-                return;
-            }
-            if (mediaMatch.addListener === undefined) {
+            const handlers = this._handlers;
+            if (!this._matchMedia) {
                 return;
             }
-            if (add) {
-                mediaMatch.addListener(handlers.oldThemeChange);
-            }
-            else {
-                mediaMatch.removeListener(handlers.oldThemeChange);
-            }
+            manageListener(this._matchMedia, "change", handlers.themeChange, add);
         };
         this._manageResize = add => {
             const handlers = this._handlers, container = this.container, options = container.actualOptions;
-            if (!options.interactivity.events.resize) {
+            if (!options.interactivity.events.resize.enable) {
                 return;
             }
             if (typeof ResizeObserver === "undefined") {
-                manageListener(window, Constants_js_1.resizeEvent, handlers.resize, add);
+                manageListener(globalThis, resizeEvent, handlers.resize, add);
                 return;
             }
             const canvasEl = container.canvas.element;
@@ -169,11 +157,7 @@ class EventListeners {
             }
         };
         this._mouseDown = () => {
-            const { interactivity } = this.container;
-            if (!interactivity) {
-                return;
-            }
-            const { mouse } = interactivity;
+            const { interactivity } = this.container, { mouse } = interactivity;
             mouse.clicking = true;
             mouse.downPosition = mouse.position;
         };
@@ -200,21 +184,17 @@ class EventListeners {
             mouse.clicking = false;
         };
         this._mouseTouchFinish = () => {
-            const interactivity = this.container.interactivity;
-            if (!interactivity) {
-                return;
-            }
-            const mouse = interactivity.mouse;
+            const { interactivity } = this.container, { mouse } = interactivity;
             delete mouse.position;
             delete mouse.clickPosition;
             delete mouse.downPosition;
-            interactivity.status = Constants_js_1.mouseLeaveEvent;
+            interactivity.status = mouseLeaveEvent;
             mouse.inside = false;
             mouse.clicking = false;
         };
         this._mouseTouchMove = e => {
             const container = this.container, options = container.actualOptions, interactivity = container.interactivity, canvasEl = container.canvas.element;
-            if (!interactivity?.element) {
+            if (!interactivity.element) {
                 return;
             }
             interactivity.mouse.inside = true;
@@ -231,36 +211,39 @@ class EventListeners {
                         };
                     }
                 }
-                else if (options.interactivity.detectsOn === InteractivityDetect_js_1.InteractivityDetect.parent) {
+                else if (options.interactivity.detectsOn === InteractivityDetect.parent) {
                     const source = mouseEvent.target, target = mouseEvent.currentTarget;
-                    if (source && target && canvasEl) {
+                    if (canvasEl) {
                         const sourceRect = source.getBoundingClientRect(), targetRect = target.getBoundingClientRect(), canvasRect = canvasEl.getBoundingClientRect();
                         pos = {
-                            x: mouseEvent.offsetX + Constants_js_1.double * sourceRect.left - (targetRect.left + canvasRect.left),
-                            y: mouseEvent.offsetY + Constants_js_1.double * sourceRect.top - (targetRect.top + canvasRect.top),
+                            x: mouseEvent.offsetX + double * sourceRect.left - (targetRect.left + canvasRect.left),
+                            y: mouseEvent.offsetY + double * sourceRect.top - (targetRect.top + canvasRect.top),
                         };
                     }
                     else {
                         pos = {
-                            x: mouseEvent.offsetX ?? mouseEvent.clientX,
-                            y: mouseEvent.offsetY ?? mouseEvent.clientY,
+                            x: mouseEvent.offsetX,
+                            y: mouseEvent.offsetY,
                         };
                     }
                 }
                 else if (mouseEvent.target === canvasEl) {
                     pos = {
-                        x: mouseEvent.offsetX ?? mouseEvent.clientX,
-                        y: mouseEvent.offsetY ?? mouseEvent.clientY,
+                        x: mouseEvent.offsetX,
+                        y: mouseEvent.offsetY,
                     };
                 }
             }
             else {
                 this._canPush = e.type !== "touchmove";
                 if (canvasEl) {
-                    const touchEvent = e, lastTouch = touchEvent.touches[touchEvent.touches.length - Constants_js_1.lengthOffset], canvasRect = canvasEl.getBoundingClientRect();
+                    const touchEvent = e, lastTouch = touchEvent.touches[touchEvent.touches.length - lengthOffset], canvasRect = canvasEl.getBoundingClientRect();
+                    if (!lastTouch) {
+                        return;
+                    }
                     pos = {
-                        x: lastTouch.clientX - (canvasRect.left ?? Constants_js_1.minCoordinate),
-                        y: lastTouch.clientY - (canvasRect.top ?? Constants_js_1.minCoordinate),
+                        x: lastTouch.clientX - canvasRect.left,
+                        y: lastTouch.clientY - canvasRect.top,
                     };
                 }
             }
@@ -270,7 +253,7 @@ class EventListeners {
                 pos.y *= pxRatio;
             }
             interactivity.mouse.position = pos;
-            interactivity.status = Constants_js_1.mouseMoveEvent;
+            interactivity.status = mouseMoveEvent;
         };
         this._touchEnd = e => {
             const evt = e, touches = Array.from(evt.changedTouches);
@@ -293,21 +276,45 @@ class EventListeners {
             }
             this._mouseTouchMove(e);
         };
-        this._canPush = true;
+        this._matchMedia = safeMatchMedia("(prefers-color-scheme: dark)");
         this._touches = new Map();
         this._handlers = {
-            mouseDown: () => this._mouseDown(),
-            mouseLeave: () => this._mouseTouchFinish(),
-            mouseMove: (e) => this._mouseTouchMove(e),
-            mouseUp: (e) => this._mouseTouchClick(e),
-            touchStart: (e) => this._touchStart(e),
-            touchMove: (e) => this._mouseTouchMove(e),
-            touchEnd: (e) => this._touchEnd(e),
-            touchCancel: (e) => this._touchEnd(e),
-            touchEndClick: (e) => this._touchEndClick(e),
-            visibilityChange: () => this._handleVisibilityChange(),
-            themeChange: (e) => this._handleThemeChange(e),
-            oldThemeChange: (e) => this._handleThemeChange(e),
+            mouseDown: () => {
+                this._mouseDown();
+            },
+            mouseLeave: () => {
+                this._mouseTouchFinish();
+            },
+            mouseMove: (e) => {
+                this._mouseTouchMove(e);
+            },
+            mouseUp: (e) => {
+                this._mouseTouchClick(e);
+            },
+            touchStart: (e) => {
+                this._touchStart(e);
+            },
+            touchMove: (e) => {
+                this._mouseTouchMove(e);
+            },
+            touchEnd: (e) => {
+                this._touchEnd(e);
+            },
+            touchCancel: (e) => {
+                this._touchEnd(e);
+            },
+            touchEndClick: (e) => {
+                this._touchEndClick(e);
+            },
+            visibilityChange: () => {
+                this._handleVisibilityChange();
+            },
+            themeChange: (e) => {
+                this._handleThemeChange(e);
+            },
+            oldThemeChange: (e) => {
+                this._handleThemeChange(e);
+            },
             resize: () => {
                 this._handleWindowResize();
             },
@@ -320,4 +327,3 @@ class EventListeners {
         this._manageListeners(false);
     }
 }
-exports.EventListeners = EventListeners;

package/cjs/Core/Utils/ExternalInteractorBase.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExternalInteractorBase = void 0;
-const InteractorType_js_1 = require("../../Enums/Types/InteractorType.js");
-class ExternalInteractorBase {
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+export class ExternalInteractorBase {
     constructor(container) {
-        this.type = InteractorType_js_1.InteractorType.external;
+        this.type = InteractorType.external;
         this.container = container;
     }
 }
-exports.ExternalInteractorBase = ExternalInteractorBase;

package/cjs/Core/Utils/InteractionManager.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InteractionManager = void 0;
-const InteractorType_js_1 = require("../../Enums/Types/InteractorType.js");
-class InteractionManager {
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+export class InteractionManager {
     constructor(engine, container) {
         this.container = container;
         this._engine = engine;
@@ -28,10 +25,10 @@ class InteractionManager {
         this._particleInteractors = [];
         for (const interactor of this._interactors) {
             switch (interactor.type) {
-                case InteractorType_js_1.InteractorType.external:
+                case InteractorType.external:
                     this._externalInteractors.push(interactor);
                     break;
-                case InteractorType_js_1.InteractorType.particles:
+                case InteractorType.particles:
                     this._particleInteractors.push(interactor);
                     break;
             }
@@ -61,4 +58,3 @@ class InteractionManager {
         }
     }
 }
-exports.InteractionManager = InteractionManager;

package/cjs/Core/Utils/ParticlesInteractorBase.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParticlesInteractorBase = void 0;
-const InteractorType_js_1 = require("../../Enums/Types/InteractorType.js");
-class ParticlesInteractorBase {
+import { InteractorType } from "../../Enums/Types/InteractorType.js";
+export class ParticlesInteractorBase {
     constructor(container) {
-        this.type = InteractorType_js_1.InteractorType.particles;
+        this.type = InteractorType.particles;
         this.container = container;
     }
 }
-exports.ParticlesInteractorBase = ParticlesInteractorBase;

package/cjs/Core/Utils/Point.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Point = void 0;
-class Point {
+export class Point {
     constructor(position, particle) {
         this.position = position;
         this.particle = particle;
     }
 }
-exports.Point = Point;

package/cjs/Core/Utils/QuadTree.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuadTree = void 0;
-const Ranges_js_1 = require("./Ranges.js");
-const Constants_js_1 = require("./Constants.js");
-const NumberUtils_js_1 = require("../../Utils/NumberUtils.js");
-class QuadTree {
+import { Circle, Rectangle } from "./Ranges.js";
+import { double, half, subdivideCount } from "./Constants.js";
+import { getDistance } from "../../Utils/MathUtils.js";
+export class QuadTree {
     constructor(rectangle, capacity) {
         this.rectangle = rectangle;
         this.capacity = capacity;
         this._subdivide = () => {
             const { x, y } = this.rectangle.position, { width, height } = this.rectangle.size, { capacity } = this;
-            for (let i = 0; i < Constants_js_1.subdivideCount; i++) {
-                const fixedIndex = i % Constants_js_1.double;
-                this._subs.push(new QuadTree(new Ranges_js_1.Rectangle(x + width * Constants_js_1.half * fixedIndex, y + height * Constants_js_1.half * (Math.round(i * Constants_js_1.half) - fixedIndex), width * Constants_js_1.half, height * Constants_js_1.half), capacity));
+            for (let i = 0; i < subdivideCount; i++) {
+                const fixedIndex = i % double;
+                this._subs.push(new QuadTree(new Rectangle(x + width * half * fixedIndex, y + height * half * (Math.round(i * half) - fixedIndex), width * half, height * half), capacity));
             }
             this._divided = true;
         };
@@ -40,7 +37,7 @@ class QuadTree {
         }
         for (const p of this._points) {
             if (!range.contains(p.position) &&
-                (0, NumberUtils_js_1.getDistance)(range.position, p.position) > p.particle.getRadius() &&
+                getDistance(range.position, p.position) > p.particle.getRadius() &&
                 (!check || check(p.particle))) {
                 continue;
             }
@@ -54,10 +51,9 @@ class QuadTree {
         return res;
     }
     queryCircle(position, radius, check) {
-        return this.query(new Ranges_js_1.Circle(position.x, position.y, radius), check);
+        return this.query(new Circle(position.x, position.y, radius), check);
     }
     queryRectangle(position, size, check) {
-        return this.query(new Ranges_js_1.Rectangle(position.x, position.y, size.width, size.height), check);
+        return this.query(new Rectangle(position.x, position.y, size.width, size.height), check);
     }
 }
-exports.QuadTree = QuadTree;

package/cjs/Core/Utils/Ranges.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rectangle = exports.Circle = exports.BaseRange = void 0;
-const RangeType_js_1 = require("../../Types/RangeType.js");
-const NumberUtils_js_1 = require("../../Utils/NumberUtils.js");
-const Constants_js_1 = require("./Constants.js");
-class BaseRange {
+import { RangeType } from "../../Enums/RangeType.js";
+import { getDistance } from "../../Utils/MathUtils.js";
+import { squareExp } from "./Constants.js";
+export class BaseRange {
     constructor(x, y, type) {
         this.position = {
             x: x,
@@ -13,24 +10,23 @@ class BaseRange {
         this.type = type;
     }
 }
-exports.BaseRange = BaseRange;
-class Circle extends BaseRange {
+export class Circle extends BaseRange {
     constructor(x, y, radius) {
-        super(x, y, RangeType_js_1.RangeType.circle);
+        super(x, y, RangeType.circle);
         this.radius = radius;
     }
     contains(point) {
-        return (0, NumberUtils_js_1.getDistance)(point, this.position) <= this.radius;
+        return getDistance(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;
-        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);
+        if (range instanceof Circle || range.type === RangeType.circle) {
+            const circleRange = range, rSum = r + circleRange.radius, dist = Math.sqrt(distPos.x ** squareExp + distPos.y ** squareExp);
             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 ||
+        else if (range instanceof Rectangle || range.type === RangeType.rectangle) {
+            const rectRange = range, { width, height } = rectRange.size, edges = Math.pow(distPos.x - width, squareExp) + Math.pow(distPos.y - height, squareExp);
+            return (edges <= r ** squareExp ||
                 (distPos.x <= r + width && distPos.y <= r + height) ||
                 distPos.x <= width ||
                 distPos.y <= height);
@@ -38,10 +34,9 @@ class Circle extends BaseRange {
         return false;
     }
 }
-exports.Circle = Circle;
-class Rectangle extends BaseRange {
+export class Rectangle extends BaseRange {
     constructor(x, y, width, height) {
-        super(x, y, RangeType_js_1.RangeType.rectangle);
+        super(x, y, RangeType.rectangle);
         this.size = {
             height: height,
             width: width,
@@ -59,4 +54,3 @@ class Rectangle extends BaseRange {
         return pos2.x < pos1.x + w && pos2.x + w2 > pos1.x && pos2.y < pos1.y + h && pos2.y + h2 > pos1.y;
     }
 }
-exports.Rectangle = Rectangle;

package/cjs/Core/Utils/Vectors.js

@@ -1,31 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Vector = exports.Vector3d = void 0;
-const Constants_js_1 = require("./Constants.js");
-const TypeUtils_js_1 = require("../../Utils/TypeUtils.js");
-class Vector3d {
-    constructor(xOrCoords, y, z) {
+import { inverseFactorNumerator, none, originPoint, squareExp } from "./Constants.js";
+export class Vector3d {
+    constructor(x = originPoint.x, y = originPoint.y, z = originPoint.z) {
         this._updateFromAngle = (angle, length) => {
             this.x = Math.cos(angle) * length;
             this.y = Math.sin(angle) * length;
         };
-        if (!(0, TypeUtils_js_1.isNumber)(xOrCoords) && xOrCoords) {
-            this.x = xOrCoords.x;
-            this.y = xOrCoords.y;
-            const coords3d = xOrCoords;
-            this.z = coords3d.z ? coords3d.z : Constants_js_1.originPoint.z;
-        }
-        else if (xOrCoords !== undefined && y !== undefined) {
-            this.x = xOrCoords;
-            this.y = y;
-            this.z = z ?? Constants_js_1.originPoint.z;
-        }
-        else {
-            throw new Error(`${Constants_js_1.errorPrefix} Vector3d not initialized correctly`);
-        }
+        this.x = x;
+        this.y = y;
+        this.z = z;
     }
     static get origin() {
-        return Vector3d.create(Constants_js_1.originPoint.x, Constants_js_1.originPoint.y, Constants_js_1.originPoint.z);
+        return Vector3d.create(originPoint.x, originPoint.y, originPoint.z);
     }
     get angle() {
         return Math.atan2(this.y, this.x);
@@ -43,7 +28,10 @@ class Vector3d {
         return Vector3d.create(source.x, source.y, source.z);
     }
     static create(x, y, z) {
-        return new Vector3d(x, y, z);
+        if (typeof x === "number") {
+            return new Vector3d(x, y ?? originPoint.y, z ?? originPoint.z);
+        }
+        return new Vector3d(x.x, x.y, Object.hasOwn(x, "z") ? x.z : originPoint.z);
     }
     add(v) {
         return Vector3d.create(this.x + v.x, this.y + v.y, this.z + v.z);
@@ -71,7 +59,7 @@ class Vector3d {
         this.z /= n;
     }
     getLengthSq() {
-        return this.x ** Constants_js_1.squareExp + this.y ** Constants_js_1.squareExp;
+        return this.x ** squareExp + this.y ** squareExp;
     }
     mult(n) {
         return Vector3d.create(this.x * n, this.y * n, this.z * n);
@@ -83,18 +71,18 @@ class Vector3d {
     }
     normalize() {
         const length = this.length;
-        if (length != Constants_js_1.none) {
-            this.multTo(Constants_js_1.inverseFactorNumerator / length);
+        if (length != none) {
+            this.multTo(inverseFactorNumerator / length);
         }
     }
     rotate(angle) {
-        return Vector3d.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle), Constants_js_1.originPoint.z);
+        return Vector3d.create(this.x * Math.cos(angle) - this.y * Math.sin(angle), this.x * Math.sin(angle) + this.y * Math.cos(angle), originPoint.z);
     }
     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 = v3d.z ? v3d.z : originPoint.z;
     }
     sub(v) {
         return Vector3d.create(this.x - v.x, this.y - v.y, this.z - v.z);
@@ -105,19 +93,20 @@ class Vector3d {
         this.z -= v.z;
     }
 }
-exports.Vector3d = Vector3d;
-class Vector extends Vector3d {
-    constructor(xOrCoords, y) {
-        super(xOrCoords, y, Constants_js_1.originPoint.z);
+export class Vector extends Vector3d {
+    constructor(x = originPoint.x, y = originPoint.y) {
+        super(x, y, originPoint.z);
     }
     static get origin() {
-        return Vector.create(Constants_js_1.originPoint.x, Constants_js_1.originPoint.y);
+        return Vector.create(originPoint.x, originPoint.y);
     }
     static clone(source) {
         return Vector.create(source.x, source.y);
     }
     static create(x, y) {
-        return new Vector(x, y);
+        if (typeof x === "number") {
+            return new Vector(x, y ?? originPoint.y);
+        }
+        return new Vector(x.x, x.y);
     }
 }
-exports.Vector = Vector;

package/cjs/Enums/AnimationStatus.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnimationStatus = void 0;
-var AnimationStatus;
+export var AnimationStatus;
 (function (AnimationStatus) {
     AnimationStatus["increasing"] = "increasing";
     AnimationStatus["decreasing"] = "decreasing";
-})(AnimationStatus || (exports.AnimationStatus = AnimationStatus = {}));
+})(AnimationStatus || (AnimationStatus = {}));

package/cjs/Enums/Directions/MoveDirection.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoveDirection = void 0;
-var MoveDirection;
+export var MoveDirection;
 (function (MoveDirection) {
     MoveDirection["bottom"] = "bottom";
     MoveDirection["bottomLeft"] = "bottom-left";
@@ -14,4 +11,4 @@ var MoveDirection;
     MoveDirection["topRight"] = "top-right";
     MoveDirection["outside"] = "outside";
     MoveDirection["inside"] = "inside";
-})(MoveDirection || (exports.MoveDirection = MoveDirection = {}));
+})(MoveDirection || (MoveDirection = {}));