tsparticles 1.34.1 → 1.35.0

package/Plugins/Emitters/EmitterInstance.js

@@ -29,7 +29,7 @@ class EmitterInstance {
         this.currentEmitDelay = 0;
         this.currentSpawnDelay = 0;
         this.initialPosition = position;
-        this.emitterOptions = Utils_1.deepExtend({}, emitterOptions);
+        this.emitterOptions = (0, Utils_1.deepExtend)({}, emitterOptions);
         this.spawnDelay = (((_a = this.emitterOptions.life.delay) !== null && _a !== void 0 ? _a : 0) * 1000) / this.container.retina.reduceFactor;
         this.position = (_b = this.initialPosition) !== null && _b !== void 0 ? _b : this.calcPosition();
         this.name = emitterOptions.name;
@@ -37,12 +37,12 @@ class EmitterInstance {
         this.fill = emitterOptions.fill;
         __classPrivateFieldSet(this, _EmitterInstance_firstSpawn, !this.emitterOptions.life.wait, "f");
         __classPrivateFieldSet(this, _EmitterInstance_startParticlesAdded, false, "f");
-        let particlesOptions = Utils_1.deepExtend({}, this.emitterOptions.particles);
+        let particlesOptions = (0, Utils_1.deepExtend)({}, this.emitterOptions.particles);
         particlesOptions !== null && particlesOptions !== void 0 ? particlesOptions : (particlesOptions = {});
         (_c = particlesOptions.move) !== null && _c !== void 0 ? _c : (particlesOptions.move = {});
         (_d = (_g = particlesOptions.move).direction) !== null && _d !== void 0 ? _d : (_g.direction = this.emitterOptions.direction);
         if (this.emitterOptions.spawnColor !== undefined) {
-            this.spawnColor = Utils_1.colorToHsl(this.emitterOptions.spawnColor);
+            this.spawnColor = (0, Utils_1.colorToHsl)(this.emitterOptions.spawnColor);
         }
         this.paused = !this.emitterOptions.autoPlay;
         this.particlesOptions = particlesOptions;
@@ -77,7 +77,7 @@ class EmitterInstance {
             (this.lifeCount > 0 || this.immortal || !this.emitterOptions.life.count) &&
             (__classPrivateFieldGet(this, _EmitterInstance_firstSpawn, "f") || this.currentSpawnDelay >= ((_a = this.spawnDelay) !== null && _a !== void 0 ? _a : 0))) {
             if (this.emitDelay === undefined) {
-                const delay = Utils_1.getRangeValue(this.emitterOptions.rate.delay);
+                const delay = (0, Utils_1.getRangeValue)(this.emitterOptions.rate.delay);
                 this.emitDelay = (1000 * delay) / this.container.retina.reduceFactor;
             }
             if (this.lifeCount > 0 || this.immortal) {
@@ -94,7 +94,7 @@ class EmitterInstance {
     resize() {
         const initialPosition = this.initialPosition;
         this.position =
-            initialPosition && Utils_1.isPointInside(initialPosition, this.container.canvas.size)
+            initialPosition && (0, Utils_1.isPointInside)(initialPosition, this.container.canvas.size)
                 ? initialPosition
                 : this.calcPosition();
     }
@@ -179,7 +179,7 @@ class EmitterInstance {
         if (this.paused) {
             return;
         }
-        const quantity = Utils_1.getRangeValue(this.emitterOptions.rate.quantity);
+        const quantity = (0, Utils_1.getRangeValue)(this.emitterOptions.rate.quantity);
         this.emitParticles(quantity);
     }
     emitParticles(quantity) {
@@ -195,8 +195,8 @@ class EmitterInstance {
                 : this.size.height,
         };
         for (let i = 0; i < quantity; i++) {
-            const particlesOptions = Utils_1.deepExtend({}, this.particlesOptions);
-            if (this.spawnColor !== undefined) {
+            const particlesOptions = (0, Utils_1.deepExtend)({}, this.particlesOptions);
+            if (this.spawnColor) {
                 const colorAnimation = (_a = this.emitterOptions.spawnColor) === null || _a === void 0 ? void 0 : _a.animation;
                 if (colorAnimation) {
                     const hueAnimation = colorAnimation;
@@ -229,8 +229,8 @@ class EmitterInstance {
         if (!animation.enable) {
             return initValue;
         }
-        const colorOffset = Utils_1.randomInRange(animation.offset);
-        const delay = Utils_1.getRangeValue(this.emitterOptions.rate.delay);
+        const colorOffset = (0, Utils_1.randomInRange)(animation.offset);
+        const delay = (0, Utils_1.getRangeValue)(this.emitterOptions.rate.delay);
         const emitFactor = (1000 * delay) / container.retina.reduceFactor;
         const colorSpeed = (_a = animation.speed) !== null && _a !== void 0 ? _a : 0;
         return (initValue + (colorSpeed * container.fpsLimit) / emitFactor + colorOffset * 3.6) % maxValue;

package/Plugins/Emitters/Emitters.js

@@ -100,15 +100,15 @@ class Emitters {
             let emitterModeOptions;
             if (modeEmitters instanceof Array) {
                 if (modeEmitters.length > 0) {
-                    emitterModeOptions = Utils_1.itemFromArray(modeEmitters);
+                    emitterModeOptions = (0, Utils_1.itemFromArray)(modeEmitters);
                 }
             }
             else {
                 emitterModeOptions = modeEmitters;
             }
-            const emittersOptions = emitterModeOptions !== null && emitterModeOptions !== void 0 ? emitterModeOptions : (emitterOptions instanceof Array ? Utils_1.itemFromArray(emitterOptions) : emitterOptions);
+            const emittersOptions = emitterModeOptions !== null && emitterModeOptions !== void 0 ? emitterModeOptions : (emitterOptions instanceof Array ? (0, Utils_1.itemFromArray)(emitterOptions) : emitterOptions);
             const ePosition = container.interactivity.mouse.clickPosition;
-            this.addEmitter(Utils_1.deepExtend({}, emittersOptions), ePosition);
+            this.addEmitter((0, Utils_1.deepExtend)({}, emittersOptions), ePosition);
         }
     }
     resize() {

package/Plugins/Emitters/Options/Classes/Emitter.js

@@ -38,7 +38,7 @@ class Emitter {
         this.life.load(data.life);
         this.name = data.name;
         if (data.particles !== undefined) {
-            this.particles = Utils_1.deepExtend({}, data.particles);
+            this.particles = (0, Utils_1.deepExtend)({}, data.particles);
         }
         this.rate.load(data.rate);
         if (data.shape !== undefined) {

package/Plugins/Emitters/Options/Classes/EmitterRate.js

@@ -12,10 +12,10 @@ class EmitterRate {
             return;
         }
         if (data.quantity !== undefined) {
-            this.quantity = Utils_1.setRangeValue(data.quantity);
+            this.quantity = (0, Utils_1.setRangeValue)(data.quantity);
         }
         if (data.delay !== undefined) {
-            this.delay = Utils_1.setRangeValue(data.delay);
+            this.delay = (0, Utils_1.setRangeValue)(data.delay);
         }
     }
 }

package/Plugins/Emitters/Shapes/Circle/CircleShape.js

@@ -20,7 +20,7 @@ class CircleShape {
                 return -theta;
             }
         };
-        const radius = (x, y, theta) => (x * y) / Math.sqrt(Math.pow((y * Math.cos(theta)), 2) + Math.pow((x * Math.sin(theta)), 2));
+        const radius = (x, y, theta) => (x * y) / Math.sqrt((y * Math.cos(theta)) ** 2 + (x * Math.sin(theta)) ** 2);
         const [a, b] = [offset.x / 2, offset.y / 2];
         const randomTheta = generateTheta(a, b), maxRadius = radius(a, b, randomTheta), randomRadius = fill ? maxRadius * Math.sqrt(Math.random()) : maxRadius;
         return {

package/Plugins/Emitters/plugin.js

@@ -34,7 +34,7 @@ class EmittersPlugin {
         return ((emitters instanceof Array && !!emitters.length) ||
             emitters !== undefined ||
             (!!((_c = (_b = (_a = options.interactivity) === null || _a === void 0 ? void 0 : _a.events) === null || _b === void 0 ? void 0 : _b.onClick) === null || _c === void 0 ? void 0 : _c.mode) &&
-                Utils_1.isInArray(Enums_1.EmitterClickMode.emitter, options.interactivity.events.onClick.mode)));
+                (0, Utils_1.isInArray)(Enums_1.EmitterClickMode.emitter, options.interactivity.events.onClick.mode)));
     }
     loadOptions(options, source) {
         var _a, _b;

package/Plugins/PolygonMask/Interfaces/ISvgPath.d.ts

@@ -1,3 +1,4 @@
+import type { SVGPathElement } from "../pathseg";
 export interface ISvgPath {
     element: SVGPathElement;
     length: number;

package/Plugins/PolygonMask/Options/Classes/DrawStroke.js

@@ -14,7 +14,7 @@ class DrawStroke {
         if (data !== undefined) {
             this.color = OptionsColor_1.OptionsColor.create(this.color, data.color);
             if (typeof this.color.value === "string") {
-                this.opacity = (_a = Utils_1.stringToAlpha(this.color.value)) !== null && _a !== void 0 ? _a : this.opacity;
+                this.opacity = (_a = (0, Utils_1.stringToAlpha)(this.color.value)) !== null && _a !== void 0 ? _a : this.opacity;
             }
             if (data.opacity !== undefined) {
                 this.opacity = data.opacity;

package/Plugins/PolygonMask/Options/Classes/PolygonMask.js

@@ -58,7 +58,7 @@ class PolygonMask {
                 }
             }
             if (data.position !== undefined) {
-                this.position = Utils_1.deepExtend({}, data.position);
+                this.position = (0, Utils_1.deepExtend)({}, data.position);
             }
         }
     }

package/Plugins/PolygonMask/PolygonMaskInstance.d.ts

@@ -1,18 +1,11 @@
 import type { Container } from "../../Core/Container";
-import type { ICoordinates } from "../../Core/Interfaces/ICoordinates";
+import type { IContainerPlugin, ICoordinates, IDelta, IDimension } from "../../Core/Interfaces";
 import { Particle } from "../../Core/Particle";
-import type { IDimension } from "../../Core/Interfaces/IDimension";
 import type { ISvgPath } from "./Interfaces/ISvgPath";
-import type { IContainerPlugin } from "../../Core/Interfaces/IContainerPlugin";
-import type { IOptions } from "../../Options/Interfaces/IOptions";
 import type { RecursivePartial } from "../../Types";
-import type { IPolygonMask } from "./Options/Interfaces/IPolygonMask";
 import { PolygonMask } from "./Options/Classes/PolygonMask";
-import type { IDelta } from "../../Core/Interfaces/IDelta";
 import { OutModeDirection } from "../../Enums";
-declare type IPolygonMaskOptions = IOptions & {
-    polygon: IPolygonMask;
-};
+import type { IPolygonMaskOptions } from "./types";
 export declare class PolygonMaskInstance implements IContainerPlugin {
     private readonly container;
     redrawTimeout?: number;
@@ -45,4 +38,3 @@ export declare class PolygonMaskInstance implements IContainerPlugin {
     private createPath2D;
     private initRawData;
 }
-export {};

package/Plugins/PolygonMask/PolygonMaskInstance.js

@@ -1,130 +1,11 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PolygonMaskInstance = void 0;
 const Enums_1 = require("./Enums");
 const Utils_1 = require("../../Utils");
 const PolygonMask_1 = require("./Options/Classes/PolygonMask");
 const Enums_2 = require("../../Enums");
-function drawPolygonMask(context, rawData, stroke) {
-    const color = Utils_1.colorToRgb(stroke.color);
-    if (!color) {
-        return;
-    }
-    context.beginPath();
-    context.moveTo(rawData[0].x, rawData[0].y);
-    for (const item of rawData) {
-        context.lineTo(item.x, item.y);
-    }
-    context.closePath();
-    context.strokeStyle = Utils_1.getStyleFromRgb(color);
-    context.lineWidth = stroke.width;
-    context.stroke();
-}
-function drawPolygonMaskPath(context, path, stroke, position) {
-    context.translate(position.x, position.y);
-    const color = Utils_1.colorToRgb(stroke.color);
-    if (!color) {
-        return;
-    }
-    context.strokeStyle = Utils_1.getStyleFromRgb(color, stroke.opacity);
-    context.lineWidth = stroke.width;
-    context.stroke(path);
-}
-function parsePaths(paths, scale, offset) {
-    const res = [];
-    for (const path of paths) {
-        const segments = path.element.pathSegList;
-        const len = segments.numberOfItems;
-        const p = {
-            x: 0,
-            y: 0,
-        };
-        for (let i = 0; i < len; i++) {
-            const segment = segments.getItem(i);
-            const svgPathSeg = window.SVGPathSeg;
-            switch (segment.pathSegType) {
-                case svgPathSeg.PATHSEG_MOVETO_ABS:
-                case svgPathSeg.PATHSEG_LINETO_ABS:
-                case svgPathSeg.PATHSEG_CURVETO_CUBIC_ABS:
-                case svgPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS:
-                case svgPathSeg.PATHSEG_ARC_ABS:
-                case svgPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS:
-                case svgPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: {
-                    const absSeg = segment;
-                    p.x = absSeg.x;
-                    p.y = absSeg.y;
-                    break;
-                }
-                case svgPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:
-                    p.x = segment.x;
-                    break;
-                case svgPathSeg.PATHSEG_LINETO_VERTICAL_ABS:
-                    p.y = segment.y;
-                    break;
-                case svgPathSeg.PATHSEG_LINETO_REL:
-                case svgPathSeg.PATHSEG_MOVETO_REL:
-                case svgPathSeg.PATHSEG_CURVETO_CUBIC_REL:
-                case svgPathSeg.PATHSEG_CURVETO_QUADRATIC_REL:
-                case svgPathSeg.PATHSEG_ARC_REL:
-                case svgPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL:
-                case svgPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: {
-                    const relSeg = segment;
-                    p.x += relSeg.x;
-                    p.y += relSeg.y;
-                    break;
-                }
-                case svgPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:
-                    p.x += segment.x;
-                    break;
-                case svgPathSeg.PATHSEG_LINETO_VERTICAL_REL:
-                    p.y += segment.y;
-                    break;
-                case svgPathSeg.PATHSEG_UNKNOWN:
-                case svgPathSeg.PATHSEG_CLOSEPATH:
-                    continue;
-            }
-            res.push({
-                x: p.x * scale + offset.x,
-                y: p.y * scale + offset.y,
-            });
-        }
-    }
-    return res;
-}
-function calcClosestPtOnSegment(s1, s2, pos) {
-    const { dx, dy } = Utils_1.getDistances(pos, s1);
-    const { dx: dxx, dy: dyy } = Utils_1.getDistances(s2, s1);
-    const t = (dx * dxx + dy * dyy) / (Math.pow(dxx, 2) + Math.pow(dyy, 2));
-    let x = s1.x + dxx * t;
-    let y = s1.y + dyy * t;
-    if (t < 0) {
-        x = s1.x;
-        y = s1.y;
-    }
-    else if (t > 1) {
-        x = s2.x;
-        y = s2.y;
-    }
-    return { x: x, y: y, isOnSegment: t >= 0 && t <= 1 };
-}
-function segmentBounce(start, stop, velocity) {
-    const { dx, dy } = Utils_1.getDistances(start, stop);
-    const wallAngle = Math.atan2(dy, dx);
-    const wallNormalX = Math.sin(wallAngle);
-    const wallNormalY = -Math.cos(wallAngle);
-    const d = 2 * (velocity.x * wallNormalX + velocity.y * wallNormalY);
-    velocity.x -= d * wallNormalX;
-    velocity.y -= d * wallNormalY;
-}
+const utils_1 = require("./utils");
 class PolygonMaskInstance {
     constructor(container) {
         this.container = container;
@@ -136,15 +17,13 @@ class PolygonMaskInstance {
         this.options = new PolygonMask_1.PolygonMask();
         this.polygonMaskMoveRadius = this.options.move.radius * container.retina.pixelRatio;
     }
-    initAsync(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.options.load(options === null || options === void 0 ? void 0 : options.polygon);
-            const polygonMaskOptions = this.options;
-            this.polygonMaskMoveRadius = polygonMaskOptions.move.radius * this.container.retina.pixelRatio;
-            if (polygonMaskOptions.enable) {
-                yield this.initRawData();
-            }
-        });
+    async initAsync(options) {
+        this.options.load(options === null || options === void 0 ? void 0 : options.polygon);
+        const polygonMaskOptions = this.options;
+        this.polygonMaskMoveRadius = polygonMaskOptions.move.radius * this.container.retina.pixelRatio;
+        if (polygonMaskOptions.enable) {
+            await this.initRawData();
+        }
     }
     resize() {
         const container = this.container;
@@ -155,10 +34,10 @@ class PolygonMaskInstance {
         if (this.redrawTimeout) {
             clearTimeout(this.redrawTimeout);
         }
-        this.redrawTimeout = window.setTimeout(() => __awaiter(this, void 0, void 0, function* () {
-            yield this.initRawData(true);
+        this.redrawTimeout = window.setTimeout(async () => {
+            await this.initRawData(true);
             container.particles.redraw();
-        }), 250);
+        }, 250);
     }
     stop() {
         delete this.raw;
@@ -181,7 +60,7 @@ class PolygonMaskInstance {
         if (!(options.enable && ((_b = (_a = this.raw) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0)) {
             return;
         }
-        return Utils_1.deepExtend({}, position ? position : this.randomPoint());
+        return (0, Utils_1.deepExtend)({}, position ? position : this.randomPoint());
     }
     particleBounce(particle, delta, direction) {
         return this.polygonBounce(particle, delta, direction);
@@ -211,14 +90,14 @@ class PolygonMaskInstance {
                 continue;
             }
             if (path2dSupported && path2d && this.offset) {
-                drawPolygonMaskPath(context, path2d, polygonDraw.stroke, this.offset);
+                (0, utils_1.drawPolygonMaskPath)(context, path2d, polygonDraw.stroke, this.offset);
             }
             else if (rawData) {
-                drawPolygonMask(context, rawData, polygonDraw.stroke);
+                (0, utils_1.drawPolygonMask)(context, rawData, polygonDraw.stroke);
             }
         }
     }
-    polygonBounce(particle, delta, direction) {
+    polygonBounce(particle, _delta, direction) {
         const options = this.options;
         if (!this.raw || !options.enable || direction !== Enums_2.OutModeDirection.top) {
             return false;
@@ -228,11 +107,11 @@ class PolygonMaskInstance {
             const pos = particle.getPosition(), radius = particle.getRadius();
             for (let i = 0, j = this.raw.length - 1; i < this.raw.length; j = i++) {
                 const pi = this.raw[i], pj = this.raw[j];
-                closest = calcClosestPtOnSegment(pi, pj, pos);
-                const dist = Utils_1.getDistances(pos, closest);
+                closest = (0, utils_1.calcClosestPtOnSegment)(pi, pj, pos);
+                const dist = (0, Utils_1.getDistances)(pos, closest);
                 [dx, dy] = [dist.dx, dist.dy];
                 if (dist.distance < radius) {
-                    segmentBounce(pi, pj, particle.velocity);
+                    (0, utils_1.segmentBounce)(pi, pj, particle.velocity);
                     return true;
                 }
             }
@@ -251,7 +130,7 @@ class PolygonMaskInstance {
             }
         }
         else if (options.type === Enums_1.Type.inline && particle.initialPosition) {
-            const dist = Utils_1.getDistance(particle.initialPosition, particle.getPosition());
+            const dist = (0, Utils_1.getDistance)(particle.initialPosition, particle.getPosition());
             if (dist > this.polygonMaskMoveRadius) {
                 particle.velocity.x = particle.velocity.y / 2 - particle.velocity.x;
                 particle.velocity.y = particle.velocity.x / 2 - particle.velocity.y;
@@ -321,22 +200,20 @@ class PolygonMaskInstance {
             x: (container.canvas.size.width * position.x) / (100 * pxRatio) - this.dimension.width / 2,
             y: (container.canvas.size.height * position.y) / (100 * pxRatio) - this.dimension.height / 2,
         };
-        return parsePaths(this.paths, scale, this.offset);
+        return (0, utils_1.parsePaths)(this.paths, scale, this.offset);
     }
-    downloadSvgPath(svgUrl, force) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = this.options;
-            const url = svgUrl || options.url;
-            const forceDownload = force !== null && force !== void 0 ? force : false;
-            if (!url || (this.paths !== undefined && !forceDownload)) {
-                return this.raw;
-            }
-            const req = yield fetch(url);
-            if (!req.ok) {
-                throw new Error("tsParticles Error - Error occurred during polygon mask download");
-            }
-            return this.parseSvgPath(yield req.text(), force);
-        });
+    async downloadSvgPath(svgUrl, force) {
+        const options = this.options;
+        const url = svgUrl || options.url;
+        const forceDownload = force !== null && force !== void 0 ? force : false;
+        if (!url || (this.paths !== undefined && !forceDownload)) {
+            return this.raw;
+        }
+        const req = await fetch(url);
+        if (!req.ok) {
+            throw new Error("tsParticles Error - Error occurred during polygon mask download");
+        }
+        return this.parseSvgPath(await req.text(), force);
     }
     drawPoints() {
         if (!this.raw) {
@@ -387,7 +264,7 @@ class PolygonMaskInstance {
         if (!this.raw || !this.raw.length) {
             throw new Error(Utils_1.Constants.noPolygonDataLoaded);
         }
-        const coords = Utils_1.itemFromArray(this.raw);
+        const coords = (0, Utils_1.itemFromArray)(this.raw);
         return {
             x: coords.x,
             y: coords.y,
@@ -399,7 +276,7 @@ class PolygonMaskInstance {
         if (!this.raw || !this.raw.length || !((_a = this.paths) === null || _a === void 0 ? void 0 : _a.length)) {
             throw new Error(Utils_1.Constants.noPolygonDataLoaded);
         }
-        const path = Utils_1.itemFromArray(this.paths);
+        const path = (0, Utils_1.itemFromArray)(this.paths);
         const distance = Math.floor(Math.random() * path.length) + 1;
         const point = path.element.getPointAtLength(distance);
         return {
@@ -480,29 +357,27 @@ class PolygonMaskInstance {
             path.path2d.closePath();
         }
     }
-    initRawData(force) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const options = this.options;
-            if (options.url) {
-                this.raw = yield this.downloadSvgPath(options.url, force);
+    async initRawData(force) {
+        const options = this.options;
+        if (options.url) {
+            this.raw = await this.downloadSvgPath(options.url, force);
+        }
+        else if (options.data) {
+            const data = options.data;
+            let svg;
+            if (typeof data !== "string") {
+                const path = data.path instanceof Array
+                    ? data.path.map((t) => `<path d="${t}" />`).join("")
+                    : `<path d="${data.path}" />`;
+                const namespaces = 'xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"';
+                svg = `<svg ${namespaces} width="${data.size.width}" height="${data.size.height}">${path}</svg>`;
             }
-            else if (options.data) {
-                const data = options.data;
-                let svg;
-                if (typeof data !== "string") {
-                    const path = data.path instanceof Array
-                        ? data.path.map((t) => `<path d="${t}" />`).join("")
-                        : `<path d="${data.path}" />`;
-                    const namespaces = 'xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"';
-                    svg = `<svg ${namespaces} width="${data.size.width}" height="${data.size.height}">${path}</svg>`;
-                }
-                else {
-                    svg = data;
-                }
-                this.raw = this.parseSvgPath(svg, force);
+            else {
+                svg = data;
             }
-            this.createPath2D();
-        });
+            this.raw = this.parseSvgPath(svg, force);
+        }
+        this.createPath2D();
     }
 }
 exports.PolygonMaskInstance = PolygonMaskInstance;