tsparticles 1.40.2 → 1.41.0

package/umd/Shapes/Circle/CircleDrawer.d.ts

@@ -0,0 +1,5 @@
+import type { IParticle, IShapeDrawer } from "../../Core";
+export declare class CircleDrawer implements IShapeDrawer {
+    getSidesCount(): number;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}

package/umd/Shapes/Circle/CircleDrawer.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.CircleDrawer = void 0;
+    class CircleDrawer {
+        getSidesCount() {
+            return 12;
+        }
+        draw(context, particle, radius) {
+            context.arc(0, 0, radius, 0, Math.PI * 2, false);
+        }
+    }
+    exports.CircleDrawer = CircleDrawer;
+});

package/umd/Shapes/Circle/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadCircleShape(engine: Engine): Promise<void>;

package/umd/Shapes/Circle/index.js

@@ -0,0 +1,18 @@
+(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", "./CircleDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadCircleShape = void 0;
+    const CircleDrawer_1 = require("./CircleDrawer");
+    async function loadCircleShape(engine) {
+        await engine.addShape("circle", new CircleDrawer_1.CircleDrawer());
+    }
+    exports.loadCircleShape = loadCircleShape;
+});

package/umd/Shapes/Image/ImageDrawer.d.ts

@@ -0,0 +1,18 @@
+import type { Container, IShapeDrawer, Particle } from "../../Core";
+import type { IImage, IImageParticle } from "./Utils";
+interface ContainerImage {
+    id: string;
+    images: IImage[];
+}
+export declare class ImageDrawer implements IShapeDrawer {
+    #private;
+    constructor();
+    getSidesCount(): number;
+    getImages(container: Container): ContainerImage;
+    addImage(container: Container, image: IImage): void;
+    destroy(): void;
+    private loadImageShape;
+    draw(context: CanvasRenderingContext2D, particle: IImageParticle, radius: number, opacity: number): void;
+    loadShape(particle: Particle): void;
+}
+export {};

package/umd/Shapes/Image/ImageDrawer.js

@@ -0,0 +1,142 @@
+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;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+(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";
+    var _ImageDrawer_images;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ImageDrawer = void 0;
+    const Utils_1 = require("./Utils");
+    class ImageDrawer {
+        constructor() {
+            _ImageDrawer_images.set(this, void 0);
+            __classPrivateFieldSet(this, _ImageDrawer_images, [], "f");
+        }
+        getSidesCount() {
+            return 12;
+        }
+        getImages(container) {
+            const containerImages = __classPrivateFieldGet(this, _ImageDrawer_images, "f").find((t) => t.id === container.id);
+            if (!containerImages) {
+                __classPrivateFieldGet(this, _ImageDrawer_images, "f").push({
+                    id: container.id,
+                    images: [],
+                });
+                return this.getImages(container);
+            }
+            else {
+                return containerImages;
+            }
+        }
+        addImage(container, image) {
+            const containerImages = this.getImages(container);
+            containerImages === null || containerImages === void 0 ? void 0 : containerImages.images.push(image);
+        }
+        destroy() {
+            __classPrivateFieldSet(this, _ImageDrawer_images, [], "f");
+        }
+        async loadImageShape(container, imageShape) {
+            const source = imageShape.src;
+            if (!source) {
+                throw new Error("Error tsParticles - No image.src");
+            }
+            try {
+                const image = {
+                    source: source,
+                    type: source.substr(source.length - 3),
+                    error: false,
+                    loading: true,
+                };
+                this.addImage(container, image);
+                const imageFunc = imageShape.replaceColor ? Utils_1.downloadSvgImage : Utils_1.loadImage;
+                await imageFunc(image);
+            }
+            catch (_a) {
+                throw new Error(`tsParticles error - ${imageShape.src} not found`);
+            }
+        }
+        draw(context, particle, radius, opacity) {
+            var _a, _b;
+            const image = particle.image;
+            const element = (_a = image === null || image === void 0 ? void 0 : image.data) === null || _a === void 0 ? void 0 : _a.element;
+            if (!element) {
+                return;
+            }
+            const ratio = (_b = image === null || image === void 0 ? void 0 : image.ratio) !== null && _b !== void 0 ? _b : 1;
+            const pos = {
+                x: -radius,
+                y: -radius,
+            };
+            if (!(image === null || image === void 0 ? void 0 : image.data.svgData) || !(image === null || image === void 0 ? void 0 : image.replaceColor)) {
+                context.globalAlpha = opacity;
+            }
+            context.drawImage(element, pos.x, pos.y, radius * 2, (radius * 2) / ratio);
+            if (!(image === null || image === void 0 ? void 0 : image.data.svgData) || !(image === null || image === void 0 ? void 0 : image.replaceColor)) {
+                context.globalAlpha = 1;
+            }
+        }
+        loadShape(particle) {
+            var _a, _b, _c;
+            if (particle.shape !== "image" && particle.shape !== "images") {
+                return;
+            }
+            const images = this.getImages(particle.container).images;
+            const imageData = particle.shapeData;
+            const image = images.find((t) => t.source === imageData.src);
+            let imageRes;
+            if (!image) {
+                this.loadImageShape(particle.container, imageData).then(() => {
+                    this.loadShape(particle);
+                });
+                return;
+            }
+            if (image.error) {
+                return;
+            }
+            const color = particle.getFillColor();
+            if (image.svgData && imageData.replaceColor && color) {
+                imageRes = (0, Utils_1.replaceImageColor)(image, imageData, color, particle);
+            }
+            else {
+                imageRes = {
+                    data: image,
+                    loaded: true,
+                    ratio: imageData.width / imageData.height,
+                    replaceColor: (_a = imageData.replaceColor) !== null && _a !== void 0 ? _a : imageData.replace_color,
+                    source: imageData.src,
+                };
+            }
+            if (!imageRes.ratio) {
+                imageRes.ratio = 1;
+            }
+            const fill = (_b = imageData.fill) !== null && _b !== void 0 ? _b : particle.fill;
+            const close = (_c = imageData.close) !== null && _c !== void 0 ? _c : particle.close;
+            const imageShape = {
+                image: imageRes,
+                fill,
+                close,
+            };
+            particle.image = imageShape.image;
+            particle.fill = imageShape.fill;
+            particle.close = imageShape.close;
+        }
+    }
+    exports.ImageDrawer = ImageDrawer;
+    _ImageDrawer_images = new WeakMap();
+});

package/umd/Shapes/Image/Utils.d.ts

@@ -0,0 +1,28 @@
+import type { IHsl, IParticle, Particle } from "../../Core";
+import type { IImageShape } from "../../Options/Interfaces/Particles/Shape/IImageShape";
+export interface IImage {
+    source: string;
+    type: string;
+    element?: HTMLImageElement;
+    svgData?: string;
+    error: boolean;
+    loading: boolean;
+}
+export interface IParticleImage {
+    source: string;
+    data: IImage;
+    ratio: number;
+    element?: HTMLImageElement;
+    loaded?: boolean;
+    replaceColor: boolean;
+}
+export interface ContainerImage {
+    id: string;
+    images: IImage[];
+}
+export declare type IImageParticle = IParticle & {
+    image?: IParticleImage;
+};
+export declare function loadImage(image: IImage): Promise<void>;
+export declare function downloadSvgImage(image: IImage): Promise<void>;
+export declare function replaceImageColor(image: IImage, imageData: IImageShape, color: IHsl, particle: Particle): IParticleImage;

package/umd/Shapes/Image/Utils.js

@@ -0,0 +1,99 @@
+(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.replaceImageColor = exports.downloadSvgImage = exports.loadImage = void 0;
+    const Utils_1 = require("../../Utils");
+    const currentColorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
+    function replaceColorSvg(imageShape, color, opacity) {
+        const { svgData } = imageShape;
+        if (!svgData) {
+            return "";
+        }
+        const colorStyle = (0, Utils_1.getStyleFromHsl)(color, opacity);
+        if (svgData.includes("fill")) {
+            return svgData.replace(currentColorRegex, () => colorStyle);
+        }
+        const preFillIndex = svgData.indexOf(">");
+        return `${svgData.substring(0, preFillIndex)} fill="${colorStyle}"${svgData.substring(preFillIndex)}`;
+    }
+    async function loadImage(image) {
+        return new Promise((resolve) => {
+            image.loading = true;
+            const img = new Image();
+            img.addEventListener("load", () => {
+                image.element = img;
+                image.loading = false;
+                resolve();
+            });
+            img.addEventListener("error", () => {
+                image.error = true;
+                image.loading = false;
+                console.error(`Error tsParticles - loading image: ${image.source}`);
+                resolve();
+            });
+            img.src = image.source;
+        });
+    }
+    exports.loadImage = loadImage;
+    async function downloadSvgImage(image) {
+        if (image.type !== "svg") {
+            await loadImage(image);
+            return;
+        }
+        image.loading = true;
+        const response = await fetch(image.source);
+        image.loading = false;
+        if (!response.ok) {
+            console.error("Error tsParticles - Image not found");
+            image.error = true;
+        }
+        if (!image.error) {
+            image.svgData = await response.text();
+        }
+    }
+    exports.downloadSvgImage = downloadSvgImage;
+    function replaceImageColor(image, imageData, color, particle) {
+        var _a, _b, _c;
+        const svgColoredData = replaceColorSvg(image, color, (_b = (_a = particle.opacity) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 1);
+        const svg = new Blob([svgColoredData], { type: "image/svg+xml" });
+        const domUrl = URL || window.URL || window.webkitURL || window;
+        const url = domUrl.createObjectURL(svg);
+        const img = new Image();
+        const imageRes = {
+            data: Object.assign(Object.assign({}, image), { svgData: svgColoredData }),
+            ratio: imageData.width / imageData.height,
+            replaceColor: (_c = imageData.replaceColor) !== null && _c !== void 0 ? _c : imageData.replace_color,
+            source: imageData.src,
+        };
+        img.addEventListener("load", () => {
+            const pImage = particle.image;
+            if (pImage) {
+                pImage.loaded = true;
+                image.element = img;
+            }
+            domUrl.revokeObjectURL(url);
+        });
+        img.addEventListener("error", () => {
+            domUrl.revokeObjectURL(url);
+            const img2 = Object.assign(Object.assign({}, image), { error: false, loading: true });
+            loadImage(img2).then(() => {
+                const pImage = particle.image;
+                if (pImage) {
+                    image.element = img2.element;
+                    pImage.loaded = true;
+                }
+            });
+        });
+        img.src = url;
+        return imageRes;
+    }
+    exports.replaceImageColor = replaceImageColor;
+});

package/umd/Shapes/Image/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadImageShape(engine: Engine): Promise<void>;

package/umd/Shapes/Image/index.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", "./ImageDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadImageShape = void 0;
+    const ImageDrawer_1 = require("./ImageDrawer");
+    async function loadImageShape(engine) {
+        const imageDrawer = new ImageDrawer_1.ImageDrawer();
+        await engine.addShape("image", imageDrawer);
+        await engine.addShape("images", imageDrawer);
+    }
+    exports.loadImageShape = loadImageShape;
+});

package/umd/Shapes/Line/LineDrawer.d.ts

@@ -0,0 +1,5 @@
+import type { IParticle, IShapeDrawer } from "../../Core";
+export declare class LineDrawer implements IShapeDrawer {
+    getSidesCount(): number;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}

package/umd/Shapes/Line/LineDrawer.js

@@ -0,0 +1,23 @@
+(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.LineDrawer = void 0;
+    class LineDrawer {
+        getSidesCount() {
+            return 1;
+        }
+        draw(context, particle, radius) {
+            context.moveTo(-radius / 2, 0);
+            context.lineTo(radius / 2, 0);
+        }
+    }
+    exports.LineDrawer = LineDrawer;
+});

package/umd/Shapes/Line/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadLineShape(engine: Engine): Promise<void>;

package/umd/Shapes/Line/index.js

@@ -0,0 +1,18 @@
+(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", "./LineDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadLineShape = void 0;
+    const LineDrawer_1 = require("./LineDrawer");
+    async function loadLineShape(engine) {
+        await engine.addShape("line", new LineDrawer_1.LineDrawer());
+    }
+    exports.loadLineShape = loadLineShape;
+});

package/umd/Shapes/Polygon/PolygonDrawer.d.ts

@@ -0,0 +1,7 @@
+import type { ICoordinates, IParticle } from "../../Core";
+import type { ISide } from "./PolygonDrawerBase";
+import { PolygonDrawerBase } from "./PolygonDrawerBase";
+export declare class PolygonDrawer extends PolygonDrawerBase {
+    getSidesData(particle: IParticle, radius: number): ISide;
+    getCenter(particle: IParticle, radius: number): ICoordinates;
+}

package/umd/Shapes/Polygon/PolygonDrawer.js

@@ -0,0 +1,36 @@
+(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", "./PolygonDrawerBase"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PolygonDrawer = void 0;
+    const PolygonDrawerBase_1 = require("./PolygonDrawerBase");
+    class PolygonDrawer extends PolygonDrawerBase_1.PolygonDrawerBase {
+        getSidesData(particle, radius) {
+            var _a, _b;
+            const polygon = particle.shapeData;
+            const sides = (_b = (_a = polygon === null || polygon === void 0 ? void 0 : polygon.sides) !== null && _a !== void 0 ? _a : polygon === null || polygon === void 0 ? void 0 : polygon.nb_sides) !== null && _b !== void 0 ? _b : 5;
+            return {
+                count: {
+                    denominator: 1,
+                    numerator: sides,
+                },
+                length: (radius * 2.66) / (sides / 3),
+            };
+        }
+        getCenter(particle, radius) {
+            const sides = this.getSidesCount(particle);
+            return {
+                x: -radius / (sides / 3.5),
+                y: -radius / (2.66 / 3.5),
+            };
+        }
+    }
+    exports.PolygonDrawer = PolygonDrawer;
+});

package/umd/Shapes/Polygon/PolygonDrawerBase.d.ts

@@ -0,0 +1,15 @@
+import type { ICoordinates, IParticle, IShapeDrawer } from "../../Core";
+export interface ISideCount {
+    numerator: number;
+    denominator: number;
+}
+export interface ISide {
+    count: ISideCount;
+    length: number;
+}
+export declare abstract class PolygonDrawerBase implements IShapeDrawer {
+    getSidesCount(particle: IParticle): number;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+    abstract getSidesData(particle: IParticle, radius: number): ISide;
+    abstract getCenter(particle: IParticle, radius: number): ICoordinates;
+}

package/umd/Shapes/Polygon/PolygonDrawerBase.js

@@ -0,0 +1,40 @@
+(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.PolygonDrawerBase = void 0;
+    class PolygonDrawerBase {
+        getSidesCount(particle) {
+            var _a, _b;
+            const polygon = particle.shapeData;
+            return (_b = (_a = polygon === null || polygon === void 0 ? void 0 : polygon.sides) !== null && _a !== void 0 ? _a : polygon === null || polygon === void 0 ? void 0 : polygon.nb_sides) !== null && _b !== void 0 ? _b : 5;
+        }
+        draw(context, particle, radius) {
+            const start = this.getCenter(particle, radius);
+            const side = this.getSidesData(particle, radius);
+            const sideCount = side.count.numerator * side.count.denominator;
+            const decimalSides = side.count.numerator / side.count.denominator;
+            const interiorAngleDegrees = (180 * (decimalSides - 2)) / decimalSides;
+            const interiorAngle = Math.PI - (Math.PI * interiorAngleDegrees) / 180;
+            if (!context) {
+                return;
+            }
+            context.beginPath();
+            context.translate(start.x, start.y);
+            context.moveTo(0, 0);
+            for (let i = 0; i < sideCount; i++) {
+                context.lineTo(side.length, 0);
+                context.translate(side.length, 0);
+                context.rotate(interiorAngle);
+            }
+        }
+    }
+    exports.PolygonDrawerBase = PolygonDrawerBase;
+});

package/umd/Shapes/Polygon/TriangleDrawer.d.ts

@@ -0,0 +1,8 @@
+import type { ICoordinates, IParticle } from "../../Core";
+import type { ISide } from "./PolygonDrawerBase";
+import { PolygonDrawerBase } from "./PolygonDrawerBase";
+export declare class TriangleDrawer extends PolygonDrawerBase {
+    getSidesCount(): number;
+    getSidesData(particle: IParticle, radius: number): ISide;
+    getCenter(particle: IParticle, radius: number): ICoordinates;
+}

package/umd/Shapes/Polygon/TriangleDrawer.js

@@ -0,0 +1,35 @@
+(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", "./PolygonDrawerBase"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TriangleDrawer = void 0;
+    const PolygonDrawerBase_1 = require("./PolygonDrawerBase");
+    class TriangleDrawer extends PolygonDrawerBase_1.PolygonDrawerBase {
+        getSidesCount() {
+            return 3;
+        }
+        getSidesData(particle, radius) {
+            return {
+                count: {
+                    denominator: 2,
+                    numerator: 3,
+                },
+                length: radius * 2,
+            };
+        }
+        getCenter(particle, radius) {
+            return {
+                x: -radius,
+                y: radius / 1.66,
+            };
+        }
+    }
+    exports.TriangleDrawer = TriangleDrawer;
+});

package/umd/Shapes/Polygon/index.d.ts

@@ -0,0 +1,4 @@
+import type { Engine } from "../../engine";
+export declare function loadGenericPolygonShape(engine: Engine): Promise<void>;
+export declare function loadTriangleShape(engine: Engine): Promise<void>;
+export declare function loadPolygonShape(engine: Engine): Promise<void>;

package/umd/Shapes/Polygon/index.js

@@ -0,0 +1,28 @@
+(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", "./PolygonDrawer", "./TriangleDrawer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadPolygonShape = exports.loadTriangleShape = exports.loadGenericPolygonShape = void 0;
+    const PolygonDrawer_1 = require("./PolygonDrawer");
+    const TriangleDrawer_1 = require("./TriangleDrawer");
+    async function loadGenericPolygonShape(engine) {
+        await engine.addShape("polygon", new PolygonDrawer_1.PolygonDrawer());
+    }
+    exports.loadGenericPolygonShape = loadGenericPolygonShape;
+    async function loadTriangleShape(engine) {
+        await engine.addShape("triangle", new TriangleDrawer_1.TriangleDrawer());
+    }
+    exports.loadTriangleShape = loadTriangleShape;
+    async function loadPolygonShape(engine) {
+        await loadGenericPolygonShape(engine);
+        await loadTriangleShape(engine);
+    }
+    exports.loadPolygonShape = loadPolygonShape;
+});

package/umd/Shapes/Square/SquareDrawer.d.ts

@@ -0,0 +1,5 @@
+import type { IParticle, IShapeDrawer } from "../../Core";
+export declare class SquareDrawer implements IShapeDrawer {
+    getSidesCount(): number;
+    draw(context: CanvasRenderingContext2D, particle: IParticle, radius: number): void;
+}

package/umd/Shapes/Square/SquareDrawer.js

@@ -0,0 +1,23 @@
+(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.SquareDrawer = void 0;
+    const fixFactor = Math.sqrt(2);
+    class SquareDrawer {
+        getSidesCount() {
+            return 4;
+        }
+        draw(context, particle, radius) {
+            context.rect(-radius / fixFactor, -radius / fixFactor, (radius * 2) / fixFactor, (radius * 2) / fixFactor);
+        }
+    }
+    exports.SquareDrawer = SquareDrawer;
+});

package/umd/Shapes/Square/index.d.ts

@@ -0,0 +1,2 @@
+import type { Engine } from "../../engine";
+export declare function loadSquareShape(engine: Engine): Promise<void>;