@tsparticles/plugin-polygon-mask 3.9.0 → 4.0.0-alpha.0

package/cjs/Options/Interfaces/IPolygonMaskDrawStroke.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/Options/Interfaces/IPolygonMaskInline.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/Options/Interfaces/IPolygonMaskLocalSvg.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/Options/Interfaces/IPolygonMaskMove.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/PolygonMaskInstance.js

@@ -1,37 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolygonMaskInstance = void 0;
-const engine_1 = require("@tsparticles/engine");
-const utils_js_1 = require("./utils.js");
-const PolygonMaskInlineArrangement_js_1 = require("./Enums/PolygonMaskInlineArrangement.js");
-const PolygonMaskType_js_1 = require("./Enums/PolygonMaskType.js");
-const noPolygonDataLoaded = `${engine_1.errorPrefix} No polygon data loaded.`, noPolygonFound = `${engine_1.errorPrefix} No polygon found, you need to specify SVG url in config.`, origin = {
+import "./pathseg.js";
+import { OutModeDirection, deepExtend, getDistance, getDistances, getRandom, isArray, isString, itemFromArray, percentDenominator, safeDocument, } from "@tsparticles/engine";
+import { calcClosestPointOnSegment, drawPolygonMask, drawPolygonMaskPath, parsePaths, segmentBounce } from "./utils.js";
+import { PolygonMaskInlineArrangement } from "./Enums/PolygonMaskInlineArrangement.js";
+import { PolygonMaskType } from "./Enums/PolygonMaskType.js";
+const noPolygonDataLoaded = `No polygon data loaded.`, noPolygonFound = `No polygon found, you need to specify SVG url in config.`, origin = {
     x: 0,
     y: 0,
 }, half = 0.5, double = 2;
-class PolygonMaskInstance {
+export class PolygonMaskInstance {
     constructor(container, engine) {
         this._checkInsidePolygon = position => {
             const container = this._container, options = container.actualOptions.polygon;
-            if (!options?.enable || options.type === PolygonMaskType_js_1.PolygonMaskType.none || options.type === PolygonMaskType_js_1.PolygonMaskType.inline) {
+            if (!options?.enable || options.type === PolygonMaskType.none || options.type === PolygonMaskType.inline) {
                 return true;
             }
             if (!this.raw) {
                 throw new Error(noPolygonFound);
             }
-            const canvasSize = container.canvas.size, x = position?.x ?? (0, engine_1.getRandom)() * canvasSize.width, y = position?.y ?? (0, engine_1.getRandom)() * canvasSize.height, indexOffset = 1;
+            const canvasSize = container.canvas.size, x = position?.x ?? getRandom() * canvasSize.width, y = position?.y ?? getRandom() * canvasSize.height, indexOffset = 1;
             let inside = false;
             for (let i = 0, j = this.raw.length - indexOffset; i < this.raw.length; j = i++) {
-                const pi = this.raw[i], pj = this.raw[j], intersect = pi.y > y !== pj.y > y && x < ((pj.x - pi.x) * (y - pi.y)) / (pj.y - pi.y) + pi.x;
+                const pi = this.raw[i], pj = this.raw[j];
+                if (!pi || !pj) {
+                    continue;
+                }
+                const intersect = pi.y > y !== pj.y > y && x < ((pj.x - pi.x) * (y - pi.y)) / (pj.y - pi.y) + pi.x;
                 if (intersect) {
                     inside = !inside;
                 }
             }
-            if (options.type === PolygonMaskType_js_1.PolygonMaskType.inside) {
+            if (options.type === PolygonMaskType.inside) {
                 return inside;
             }
             else {
-                return options.type === PolygonMaskType_js_1.PolygonMaskType.outside ? !inside : false;
+                return !inside;
             }
         };
         this._createPath2D = () => {
@@ -40,16 +42,11 @@ class PolygonMaskInstance {
                 return;
             }
             for (const path of this.paths) {
-                const pathData = path.element?.getAttribute("d");
+                const pathData = path.element.getAttribute("d");
                 if (pathData) {
-                    const path2d = new Path2D(pathData), matrix = document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix(), finalPath = new Path2D(), transform = matrix.scale(this._scale);
-                    if (finalPath.addPath) {
-                        finalPath.addPath(path2d, transform);
-                        path.path2d = finalPath;
-                    }
-                    else {
-                        delete path.path2d;
-                    }
+                    const path2d = new Path2D(pathData), matrix = safeDocument().createElementNS("http://www.w3.org/2000/svg", "svg").createSVGMatrix(), finalPath = new Path2D(), transform = matrix.scale(this._scale);
+                    finalPath.addPath(path2d, transform);
+                    path.path2d = finalPath;
                 }
                 else {
                     delete path.path2d;
@@ -59,6 +56,9 @@ class PolygonMaskInstance {
                 }
                 path.path2d = new Path2D();
                 const firstIndex = 0, firstPoint = this.raw[firstIndex];
+                if (!firstPoint) {
+                    continue;
+                }
                 path.path2d.moveTo(firstPoint.x, firstPoint.y);
                 this.raw.forEach((pos, i) => {
                     if (i > firstIndex) {
@@ -79,7 +79,7 @@ class PolygonMaskInstance {
             }
             const req = await fetch(url);
             if (!req.ok) {
-                throw new Error(`${engine_1.errorPrefix} occurred during polygon mask download`);
+                throw new Error(`Error occurred during polygon mask download`);
             }
             return this._parseSvgPath(await req.text(), force);
         };
@@ -125,6 +125,9 @@ class PolygonMaskInstance {
                 throw new Error(noPolygonDataLoaded);
             }
             const coords = this.raw[index % this.raw.length];
+            if (!coords) {
+                return;
+            }
             return {
                 x: coords.x,
                 y: coords.y,
@@ -134,7 +137,10 @@ class PolygonMaskInstance {
             if (!this.raw?.length) {
                 throw new Error(noPolygonDataLoaded);
             }
-            const coords = (0, engine_1.itemFromArray)(this.raw);
+            const coords = itemFromArray(this.raw);
+            if (!coords) {
+                return;
+            }
             return {
                 x: coords.x,
                 y: coords.y,
@@ -148,7 +154,11 @@ class PolygonMaskInstance {
             if (!this.raw?.length || !this.paths?.length) {
                 throw new Error(noPolygonDataLoaded);
             }
-            const path = (0, engine_1.itemFromArray)(this.paths), offset = 1, distance = Math.floor((0, engine_1.getRandom)() * path.length) + offset, point = path.element.getPointAtLength(distance), scale = this._scale;
+            const path = itemFromArray(this.paths);
+            if (!path) {
+                return;
+            }
+            const offset = 1, distance = Math.floor(getRandom() * path.length) + offset, point = path.element.getPointAtLength(distance), scale = this._scale;
             return {
                 x: point.x * scale + (this.offset?.x ?? origin.x),
                 y: point.y * scale + (this.offset?.y ?? origin.y),
@@ -165,13 +175,13 @@ class PolygonMaskInstance {
             else if (options.data) {
                 const data = options.data;
                 let svg;
-                if ((0, engine_1.isString)(data)) {
+                if (isString(data)) {
                     svg = data;
                 }
                 else {
-                    const getPath = (p) => `<path d="${p}" />`, path = (0, engine_1.isArray)(data.path) ? data.path.map(getPath).join("") : getPath(data.path);
+                    const getPath = (p) => `<path d="${p}" />`, path = isArray(data.path) ? data.path.map(getPath).join("") : getPath(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>`;
+                    svg = `<svg ${namespaces} width="${data.size.width.toString()}" height="${data.size.height.toString()}">${path}</svg>`;
                 }
                 this.raw = this._parseSvgPath(svg, force);
             }
@@ -190,6 +200,9 @@ class PolygonMaskInstance {
                 return;
             }
             const parser = new DOMParser(), doc = parser.parseFromString(xml, "image/svg+xml"), firstIndex = 0, svg = doc.getElementsByTagName("svg")[firstIndex];
+            if (!svg) {
+                return;
+            }
             let svgPaths = svg.getElementsByTagName("path");
             if (!svgPaths.length) {
                 svgPaths = doc.getElementsByTagName("path");
@@ -212,26 +225,29 @@ class PolygonMaskInstance {
                 y: 50,
             }, canvasSize = container.canvas.size;
             this.offset = {
-                x: (canvasSize.width * position.x) / engine_1.percentDenominator - this.dimension.width * half,
-                y: (canvasSize.height * position.y) / engine_1.percentDenominator - this.dimension.height * half,
+                x: (canvasSize.width * position.x) / percentDenominator - this.dimension.width * half,
+                y: (canvasSize.height * position.y) / percentDenominator - this.dimension.height * half,
             };
-            return (0, utils_js_1.parsePaths)(this.paths, scale, this.offset);
+            return parsePaths(this.paths, scale, this.offset);
         };
-        this._polygonBounce = (particle, delta, direction) => {
+        this._polygonBounce = (particle, _delta, direction) => {
             const options = this._container.actualOptions.polygon;
-            if (!this.raw || !options?.enable || direction !== engine_1.OutModeDirection.top) {
+            if (!this.raw || !options?.enable || direction !== OutModeDirection.top) {
                 return false;
             }
-            if (options.type === PolygonMaskType_js_1.PolygonMaskType.inside || options.type === PolygonMaskType_js_1.PolygonMaskType.outside) {
+            if (options.type === PolygonMaskType.inside || options.type === PolygonMaskType.outside) {
                 let closest, dx, dy;
                 const pos = particle.getPosition(), radius = particle.getRadius(), offset = 1;
                 for (let i = 0, j = this.raw.length - offset; i < this.raw.length; j = i++) {
                     const pi = this.raw[i], pj = this.raw[j];
-                    closest = (0, utils_js_1.calcClosestPointOnSegment)(pi, pj, pos);
-                    const dist = (0, engine_1.getDistances)(pos, closest);
+                    if (!pi || !pj) {
+                        continue;
+                    }
+                    closest = calcClosestPointOnSegment(pi, pj, pos);
+                    const dist = getDistances(pos, closest);
                     [dx, dy] = [dist.dx, dist.dy];
                     if (dist.distance < radius) {
-                        (0, utils_js_1.segmentBounce)(pi, pj, particle.velocity);
+                        segmentBounce(pi, pj, particle.velocity);
                         return true;
                     }
                 }
@@ -249,8 +265,8 @@ class PolygonMaskInstance {
                     return true;
                 }
             }
-            else if (options.type === PolygonMaskType_js_1.PolygonMaskType.inline && particle.initialPosition) {
-                const dist = (0, engine_1.getDistance)(particle.initialPosition, particle.getPosition()), { velocity } = particle;
+            else if (options.type === PolygonMaskType.inline) {
+                const dist = getDistance(particle.initialPosition, particle.getPosition()), { velocity } = particle;
                 if (dist > this._moveRadius) {
                     velocity.x = velocity.y * half - velocity.x;
                     velocity.y = velocity.x * half - velocity.y;
@@ -265,19 +281,19 @@ class PolygonMaskInstance {
                 return;
             }
             let position;
-            if (options.type === PolygonMaskType_js_1.PolygonMaskType.inline) {
+            if (options.type === PolygonMaskType.inline) {
                 switch (options.inline.arrangement) {
-                    case PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.randomPoint:
+                    case PolygonMaskInlineArrangement.randomPoint:
                         position = this._getRandomPoint();
                         break;
-                    case PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.randomLength:
+                    case PolygonMaskInlineArrangement.randomLength:
                         position = this._getRandomPointByLength();
                         break;
-                    case PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.equidistant:
+                    case PolygonMaskInlineArrangement.equidistant:
                         position = this._getEquidistantPointByIndex(container.particles.count);
                         break;
-                    case PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.onePerPoint:
-                    case PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.perPoint:
+                    case PolygonMaskInlineArrangement.onePerPoint:
+                    case PolygonMaskInlineArrangement.perPoint:
                     default:
                         position = this._getPointByIndex(container.particles.count);
                 }
@@ -285,8 +301,8 @@ class PolygonMaskInstance {
             else {
                 const canvasSize = container.canvas.size;
                 position = {
-                    x: (0, engine_1.getRandom)() * canvasSize.width,
-                    y: (0, engine_1.getRandom)() * canvasSize.height,
+                    x: getRandom() * canvasSize.width,
+                    y: getRandom() * canvasSize.height,
                 };
             }
             if (this._checkInsidePolygon(position)) {
@@ -308,8 +324,8 @@ class PolygonMaskInstance {
     clickPositionValid(position) {
         const options = this._container.actualOptions.polygon;
         return (!!options?.enable &&
-            options.type !== PolygonMaskType_js_1.PolygonMaskType.none &&
-            options.type !== PolygonMaskType_js_1.PolygonMaskType.inline &&
+            options.type !== PolygonMaskType.none &&
+            options.type !== PolygonMaskType.inline &&
             this._checkInsidePolygon(position));
     }
     draw(context) {
@@ -327,14 +343,11 @@ class PolygonMaskInstance {
         const rawData = this.raw;
         for (const path of this.paths) {
             const path2d = path.path2d;
-            if (!context) {
-                continue;
-            }
             if (path2d && this.offset) {
-                (0, utils_js_1.drawPolygonMaskPath)(this._engine, context, path2d, polygonDraw.stroke, this.offset);
+                drawPolygonMaskPath(this._engine, context, path2d, polygonDraw.stroke, this.offset, this._container.hdr);
             }
             else if (rawData) {
-                (0, utils_js_1.drawPolygonMask)(this._engine, context, rawData, polygonDraw.stroke);
+                drawPolygonMask(this._engine, context, rawData, polygonDraw.stroke, this._container.hdr);
             }
         }
     }
@@ -357,14 +370,14 @@ class PolygonMaskInstance {
         if (!(options?.enable && (this.raw?.length ?? defaultLength) > defaultLength)) {
             return;
         }
-        return (0, engine_1.deepExtend)({}, position ? position : this._randomPoint());
+        return deepExtend({}, position ?? this._randomPoint());
     }
     particlesInitialization() {
         const options = this._container.actualOptions.polygon;
         if (options?.enable &&
-            options.type === PolygonMaskType_js_1.PolygonMaskType.inline &&
-            (options.inline.arrangement === PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.onePerPoint ||
-                options.inline.arrangement === PolygonMaskInlineArrangement_js_1.PolygonMaskInlineArrangement.perPoint)) {
+            options.type === PolygonMaskType.inline &&
+            (options.inline.arrangement === PolygonMaskInlineArrangement.onePerPoint ||
+                options.inline.arrangement === PolygonMaskInlineArrangement.perPoint)) {
             this._drawPoints();
             return true;
         }
@@ -372,7 +385,7 @@ class PolygonMaskInstance {
     }
     resize() {
         const container = this._container, options = container.actualOptions.polygon;
-        if (!(options?.enable && options.type !== PolygonMaskType_js_1.PolygonMaskType.none)) {
+        if (!(options?.enable && options.type !== PolygonMaskType.none)) {
             return;
         }
         if (this.redrawTimeout) {
@@ -391,4 +404,3 @@ class PolygonMaskInstance {
         delete this.paths;
     }
 }
-exports.PolygonMaskInstance = PolygonMaskInstance;

package/cjs/PolygonMaskPlugin.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PolygonMaskPlugin = void 0;
-const PolygonMask_js_1 = require("./Options/Classes/PolygonMask.js");
-const PolygonMaskInstance_js_1 = require("./PolygonMaskInstance.js");
-const PolygonMaskType_js_1 = require("./Enums/PolygonMaskType.js");
-class PolygonMaskPlugin {
+import { PolygonMask } from "./Options/Classes/PolygonMask.js";
+import { PolygonMaskInstance } from "./PolygonMaskInstance.js";
+import { PolygonMaskType } from "./Enums/PolygonMaskType.js";
+export class PolygonMaskPlugin {
     constructor(engine) {
         this.id = "polygonMask";
         this._engine = engine;
     }
     getPlugin(container) {
-        return Promise.resolve(new PolygonMaskInstance_js_1.PolygonMaskInstance(container, this._engine));
+        return Promise.resolve(new PolygonMaskInstance(container, this._engine));
     }
     loadOptions(options, source) {
         if (!this.needsPlugin(options) && !this.needsPlugin(source)) {
@@ -18,13 +15,12 @@ class PolygonMaskPlugin {
         }
         let polygonOptions = options.polygon;
         if (polygonOptions?.load === undefined) {
-            options.polygon = polygonOptions = new PolygonMask_js_1.PolygonMask(this._engine);
+            options.polygon = polygonOptions = new PolygonMask(this._engine);
         }
         polygonOptions.load(source?.polygon);
     }
     needsPlugin(options) {
         return (options?.polygon?.enable ??
-            (options?.polygon?.type !== undefined && options.polygon.type !== PolygonMaskType_js_1.PolygonMaskType.none));
+            (options?.polygon?.type !== undefined && options.polygon.type !== PolygonMaskType.none));
     }
 }
-exports.PolygonMaskPlugin = PolygonMaskPlugin;

package/cjs/index.js

@@ -1,26 +1,10 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPolygonMaskPlugin = loadPolygonMaskPlugin;
-require("./pathseg.js");
-const PolygonMaskPlugin_js_1 = require("./PolygonMaskPlugin.js");
-async function loadPolygonMaskPlugin(engine, refresh = true) {
-    engine.checkVersion("3.9.0");
-    await engine.addPlugin(new PolygonMaskPlugin_js_1.PolygonMaskPlugin(engine), refresh);
+export function loadPolygonMaskPlugin(engine) {
+    engine.checkVersion("4.0.0-alpha.0");
+    engine.register(async (e) => {
+        const { PolygonMaskPlugin } = await import("./PolygonMaskPlugin.js");
+        e.addPlugin(new PolygonMaskPlugin(engine));
+    });
 }
-__exportStar(require("./Enums/PolygonMaskInlineArrangement.js"), exports);
-__exportStar(require("./Enums/PolygonMaskMoveType.js"), exports);
-__exportStar(require("./Enums/PolygonMaskType.js"), exports);
+export * from "./Enums/PolygonMaskInlineArrangement.js";
+export * from "./Enums/PolygonMaskMoveType.js";
+export * from "./Enums/PolygonMaskType.js";

package/cjs/pathseg.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 (function () {
     "use strict";
     try {
@@ -1148,7 +1146,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
                 return string;
             };
             window.SVGPathSegList.prototype._parsePath = function (string) {
-                if (!string || !string.length)
+                if (!string?.length)
                     return [];
                 const owningPathSegList = this;
                 const Builder = function () {
@@ -1495,3 +1493,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
         console.warn("An error occurred in tsParticles pathseg polyfill. If the Polygon Mask is not working, please open an issue here: https://github.com/tsparticles/tsparticles", e);
     }
 })();
+export {};

package/cjs/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/cjs/utils.js

@@ -1,32 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.drawPolygonMask = drawPolygonMask;
-exports.drawPolygonMaskPath = drawPolygonMaskPath;
-exports.parsePaths = parsePaths;
-exports.calcClosestPointOnSegment = calcClosestPointOnSegment;
-exports.segmentBounce = segmentBounce;
-const engine_1 = require("@tsparticles/engine");
+import { Vector, getDistances, getStyleFromRgb, rangeColorToRgb, } from "@tsparticles/engine";
 const squareExp = 2, inSegmentRange = {
     min: 0,
     max: 1,
 }, double = 2;
-function drawPolygonMask(engine, context, rawData, stroke) {
-    const color = (0, engine_1.rangeColorToRgb)(engine, stroke.color);
+export function drawPolygonMask(engine, context, rawData, stroke, hdr = false) {
+    const color = rangeColorToRgb(engine, stroke.color);
     if (!color) {
         return;
     }
     const firstIndex = 0, firstItem = rawData[firstIndex];
+    if (!firstItem) {
+        return;
+    }
     context.beginPath();
     context.moveTo(firstItem.x, firstItem.y);
     for (const item of rawData) {
         context.lineTo(item.x, item.y);
     }
     context.closePath();
-    context.strokeStyle = (0, engine_1.getStyleFromRgb)(color);
+    context.strokeStyle = getStyleFromRgb(color, hdr);
     context.lineWidth = stroke.width;
     context.stroke();
 }
-function drawPolygonMaskPath(engine, context, path, stroke, position) {
+export function drawPolygonMaskPath(engine, context, path, stroke, position, hdr = false) {
     const defaultTransform = {
         a: 1,
         b: 0,
@@ -34,16 +30,16 @@ function drawPolygonMaskPath(engine, context, path, stroke, position) {
         d: 1,
     };
     context.setTransform(defaultTransform.a, defaultTransform.b, defaultTransform.c, defaultTransform.d, position.x, position.y);
-    const color = (0, engine_1.rangeColorToRgb)(engine, stroke.color);
+    const color = rangeColorToRgb(engine, stroke.color);
     if (!color) {
         return;
     }
-    context.strokeStyle = (0, engine_1.getStyleFromRgb)(color, stroke.opacity);
+    context.strokeStyle = getStyleFromRgb(color, hdr, stroke.opacity);
     context.lineWidth = stroke.width;
     context.stroke(path);
     context.resetTransform();
 }
-function parsePaths(paths, scale, offset) {
+export function parsePaths(paths, scale, offset) {
     const res = [], defaultCount = 0;
     for (const path of paths) {
         const segments = path.element.pathSegList, len = segments?.numberOfItems ?? defaultCount, p = {
@@ -51,7 +47,7 @@ function parsePaths(paths, scale, offset) {
             y: 0,
         };
         for (let i = 0; i < len; i++) {
-            const segment = segments?.getItem(i), svgPathSeg = window.SVGPathSeg;
+            const segment = segments?.getItem(i), svgPathSeg = globalThis.SVGPathSeg;
             switch (segment?.pathSegType) {
                 case svgPathSeg.PATHSEG_MOVETO_ABS:
                 case svgPathSeg.PATHSEG_LINETO_ABS:
@@ -101,8 +97,8 @@ function parsePaths(paths, scale, offset) {
     }
     return res;
 }
-function calcClosestPointOnSegment(s1, s2, pos) {
-    const { dx: dx1, dy: dy1 } = (0, engine_1.getDistances)(pos, s1), { dx: dx2, dy: dy2 } = (0, engine_1.getDistances)(s2, s1), t = (dx1 * dx2 + dy1 * dy2) / (dx2 ** squareExp + dy2 ** squareExp), res = {
+export function calcClosestPointOnSegment(s1, s2, pos) {
+    const { dx: dx1, dy: dy1 } = getDistances(pos, s1), { dx: dx2, dy: dy2 } = getDistances(s2, s1), t = (dx1 * dx2 + dy1 * dy2) / (dx2 ** squareExp + dy2 ** squareExp), res = {
         x: s1.x + dx2 * t,
         y: s1.y + dy2 * t,
         isOnSegment: t >= inSegmentRange.min && t <= inSegmentRange.max,
@@ -117,8 +113,8 @@ function calcClosestPointOnSegment(s1, s2, pos) {
     }
     return res;
 }
-function segmentBounce(start, stop, velocity) {
-    const { dx, dy } = (0, engine_1.getDistances)(start, stop), wallAngle = Math.atan2(dy, dx), wallNormal = engine_1.Vector.create(Math.sin(wallAngle), -Math.cos(wallAngle)), d = double * (velocity.x * wallNormal.x + velocity.y * wallNormal.y);
+export function segmentBounce(start, stop, velocity) {
+    const { dx, dy } = getDistances(start, stop), wallAngle = Math.atan2(dy, dx), wallNormal = Vector.create(Math.sin(wallAngle), -Math.cos(wallAngle)), d = double * (velocity.x * wallNormal.x + velocity.y * wallNormal.y);
     wallNormal.multTo(d);
     velocity.subFrom(wallNormal);
 }