tsparticles 1.40.1 → 1.41.2

package/umd/Core/Particles.js

@@ -0,0 +1,331 @@
+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", "../Utils", "./Particle", "../Options/Classes/Particles/ParticlesOptions"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    var _Particles_engine;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Particles = void 0;
+    const Utils_1 = require("./Utils");
+    const Utils_2 = require("../Utils");
+    const Particle_1 = require("./Particle");
+    const ParticlesOptions_1 = require("../Options/Classes/Particles/ParticlesOptions");
+    class Particles {
+        constructor(engine, container) {
+            this.container = container;
+            _Particles_engine.set(this, void 0);
+            __classPrivateFieldSet(this, _Particles_engine, engine, "f");
+            this.nextId = 0;
+            this.array = [];
+            this.zArray = [];
+            this.mover = new Utils_1.ParticlesMover(container);
+            this.limit = 0;
+            this.needsSort = false;
+            this.lastZIndex = 0;
+            this.freqs = {
+                links: new Map(),
+                triangles: new Map(),
+            };
+            this.interactionManager = new Utils_1.InteractionManager(__classPrivateFieldGet(this, _Particles_engine, "f"), container);
+            const canvasSize = this.container.canvas.size;
+            this.linksColors = new Map();
+            this.quadTree = new Utils_1.QuadTree(new Utils_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+            this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
+        }
+        get count() {
+            return this.array.length;
+        }
+        init() {
+            var _a;
+            const container = this.container;
+            const options = container.actualOptions;
+            this.lastZIndex = 0;
+            this.needsSort = false;
+            this.freqs.links = new Map();
+            this.freqs.triangles = new Map();
+            let handled = false;
+            this.updaters = __classPrivateFieldGet(this, _Particles_engine, "f").plugins.getUpdaters(container, true);
+            this.interactionManager.init();
+            for (const [, plugin] of container.plugins) {
+                if (plugin.particlesInitialization !== undefined) {
+                    handled = plugin.particlesInitialization();
+                }
+                if (handled) {
+                    break;
+                }
+            }
+            this.addManualParticles();
+            if (!handled) {
+                for (const group in options.particles.groups) {
+                    const groupOptions = options.particles.groups[group];
+                    for (let i = this.count, j = 0; j < ((_a = groupOptions.number) === null || _a === void 0 ? void 0 : _a.value) && i < options.particles.number.value; i++, j++) {
+                        this.addParticle(undefined, groupOptions, group);
+                    }
+                }
+                for (let i = this.count; i < options.particles.number.value; i++) {
+                    this.addParticle();
+                }
+            }
+            container.pathGenerator.init(container);
+        }
+        async redraw() {
+            this.clear();
+            this.init();
+            await this.draw({ value: 0, factor: 0 });
+        }
+        removeAt(index, quantity = 1, group, override) {
+            if (!(index >= 0 && index <= this.count)) {
+                return;
+            }
+            let deleted = 0;
+            for (let i = index; deleted < quantity && i < this.count; i++) {
+                const particle = this.array[i];
+                if (!particle || particle.group !== group) {
+                    continue;
+                }
+                particle.destroy(override);
+                this.array.splice(i--, 1);
+                const zIdx = this.zArray.indexOf(particle);
+                this.zArray.splice(zIdx, 1);
+                deleted++;
+            }
+        }
+        remove(particle, group, override) {
+            this.removeAt(this.array.indexOf(particle), undefined, group, override);
+        }
+        async update(delta) {
+            const container = this.container;
+            const particlesToDelete = [];
+            container.pathGenerator.update();
+            for (const [, plugin] of container.plugins) {
+                if (plugin.update !== undefined) {
+                    plugin.update(delta);
+                }
+            }
+            for (const particle of this.array) {
+                const resizeFactor = container.canvas.resizeFactor;
+                if (resizeFactor) {
+                    particle.position.x *= resizeFactor.width;
+                    particle.position.y *= resizeFactor.height;
+                }
+                particle.bubble.inRange = false;
+                for (const [, plugin] of this.container.plugins) {
+                    if (particle.destroyed) {
+                        break;
+                    }
+                    if (plugin.particleUpdate) {
+                        plugin.particleUpdate(particle, delta);
+                    }
+                }
+                this.mover.move(particle, delta);
+                if (particle.destroyed) {
+                    particlesToDelete.push(particle);
+                    continue;
+                }
+                this.quadTree.insert(new Utils_1.Point(particle.getPosition(), particle));
+            }
+            for (const particle of particlesToDelete) {
+                this.remove(particle);
+            }
+            await this.interactionManager.externalInteract(delta);
+            for (const particle of container.particles.array) {
+                for (const updater of this.updaters) {
+                    updater.update(particle, delta);
+                }
+                if (!particle.destroyed && !particle.spawning) {
+                    await this.interactionManager.particlesInteract(particle, delta);
+                }
+            }
+            delete container.canvas.resizeFactor;
+        }
+        async draw(delta) {
+            const container = this.container;
+            container.canvas.clear();
+            const canvasSize = this.container.canvas.size;
+            this.quadTree = new Utils_1.QuadTree(new Utils_1.Rectangle(-canvasSize.width / 4, -canvasSize.height / 4, (canvasSize.width * 3) / 2, (canvasSize.height * 3) / 2), 4);
+            await this.update(delta);
+            if (this.needsSort) {
+                this.zArray.sort((a, b) => b.position.z - a.position.z || a.id - b.id);
+                this.lastZIndex = this.zArray[this.zArray.length - 1].position.z;
+                this.needsSort = false;
+            }
+            for (const [, plugin] of container.plugins) {
+                container.canvas.drawPlugin(plugin, delta);
+            }
+            for (const p of this.zArray) {
+                p.draw(delta);
+            }
+        }
+        clear() {
+            this.array = [];
+            this.zArray = [];
+        }
+        push(nb, mouse, overrideOptions, group) {
+            this.pushing = true;
+            for (let i = 0; i < nb; i++) {
+                this.addParticle(mouse === null || mouse === void 0 ? void 0 : mouse.position, overrideOptions, group);
+            }
+            this.pushing = false;
+        }
+        addParticle(position, overrideOptions, group) {
+            const container = this.container, options = container.actualOptions, limit = options.particles.number.limit * container.density;
+            if (limit > 0) {
+                const countToRemove = this.count + 1 - limit;
+                if (countToRemove > 0) {
+                    this.removeQuantity(countToRemove);
+                }
+            }
+            return this.pushParticle(position, overrideOptions, group);
+        }
+        addSplitParticle(parent) {
+            const splitOptions = parent.options.destroy.split, options = new ParticlesOptions_1.ParticlesOptions();
+            options.load(parent.options);
+            const factor = (0, Utils_2.getRangeValue)(splitOptions.factor.value);
+            options.color.load({
+                value: {
+                    hsl: parent.getFillColor(),
+                },
+            });
+            if (typeof options.size.value === "number") {
+                options.size.value /= factor;
+            }
+            else {
+                options.size.value.min /= factor;
+                options.size.value.max /= factor;
+            }
+            options.load(splitOptions.particles);
+            const offset = splitOptions.sizeOffset ? (0, Utils_2.setRangeValue)(-parent.size.value, parent.size.value) : 0;
+            const position = {
+                x: parent.position.x + (0, Utils_2.randomInRange)(offset),
+                y: parent.position.y + (0, Utils_2.randomInRange)(offset),
+            };
+            return this.pushParticle(position, options, parent.group, (particle) => {
+                if (particle.size.value < 0.5) {
+                    return false;
+                }
+                particle.velocity.length = (0, Utils_2.randomInRange)((0, Utils_2.setRangeValue)(parent.velocity.length, particle.velocity.length));
+                particle.splitCount = parent.splitCount + 1;
+                particle.unbreakable = true;
+                setTimeout(() => {
+                    particle.unbreakable = false;
+                }, 500);
+                return true;
+            });
+        }
+        removeQuantity(quantity, group) {
+            this.removeAt(0, quantity, group);
+        }
+        getLinkFrequency(p1, p2) {
+            const range = (0, Utils_2.setRangeValue)(p1.id, p2.id), key = `${(0, Utils_2.getRangeMin)(range)}_${(0, Utils_2.getRangeMax)(range)}`;
+            let res = this.freqs.links.get(key);
+            if (res === undefined) {
+                res = Math.random();
+                this.freqs.links.set(key, res);
+            }
+            return res;
+        }
+        getTriangleFrequency(p1, p2, p3) {
+            let [id1, id2, id3] = [p1.id, p2.id, p3.id];
+            if (id1 > id2) {
+                [id2, id1] = [id1, id2];
+            }
+            if (id2 > id3) {
+                [id3, id2] = [id2, id3];
+            }
+            if (id1 > id3) {
+                [id3, id1] = [id1, id3];
+            }
+            const key = `${id1}_${id2}_${id3}`;
+            let res = this.freqs.triangles.get(key);
+            if (res === undefined) {
+                res = Math.random();
+                this.freqs.triangles.set(key, res);
+            }
+            return res;
+        }
+        addManualParticles() {
+            const container = this.container, options = container.actualOptions;
+            for (const particle of options.manualParticles) {
+                const pos = particle.position
+                    ? {
+                        x: (particle.position.x * container.canvas.size.width) / 100,
+                        y: (particle.position.y * container.canvas.size.height) / 100,
+                    }
+                    : undefined;
+                this.addParticle(pos, particle.options);
+            }
+        }
+        setDensity() {
+            const options = this.container.actualOptions;
+            for (const group in options.particles.groups) {
+                this.applyDensity(options.particles.groups[group], 0, group);
+            }
+            this.applyDensity(options.particles, options.manualParticles.length);
+        }
+        applyDensity(options, manualCount, group) {
+            var _a;
+            if (!((_a = options.number.density) === null || _a === void 0 ? void 0 : _a.enable)) {
+                return;
+            }
+            const numberOptions = options.number;
+            const densityFactor = this.initDensityFactor(numberOptions.density);
+            const optParticlesNumber = numberOptions.value;
+            const optParticlesLimit = numberOptions.limit > 0 ? numberOptions.limit : optParticlesNumber;
+            const particlesNumber = Math.min(optParticlesNumber, optParticlesLimit) * densityFactor + manualCount;
+            const particlesCount = Math.min(this.count, this.array.filter((t) => t.group === group).length);
+            this.limit = numberOptions.limit * densityFactor;
+            if (particlesCount < particlesNumber) {
+                this.push(Math.abs(particlesNumber - particlesCount), undefined, options, group);
+            }
+            else if (particlesCount > particlesNumber) {
+                this.removeQuantity(particlesCount - particlesNumber, group);
+            }
+        }
+        initDensityFactor(densityOptions) {
+            const container = this.container;
+            if (!container.canvas.element || !densityOptions.enable) {
+                return 1;
+            }
+            const canvas = container.canvas.element, pxRatio = container.retina.pixelRatio;
+            return (canvas.width * canvas.height) / (densityOptions.factor * pxRatio ** 2 * densityOptions.area);
+        }
+        pushParticle(position, overrideOptions, group, initializer) {
+            try {
+                const particle = new Particle_1.Particle(__classPrivateFieldGet(this, _Particles_engine, "f"), this.nextId, this.container, position, overrideOptions, group);
+                let canAdd = true;
+                if (initializer) {
+                    canAdd = initializer(particle);
+                }
+                if (!canAdd) {
+                    return;
+                }
+                this.array.push(particle);
+                this.zArray.push(particle);
+                this.nextId++;
+                return particle;
+            }
+            catch (e) {
+                console.warn(`error adding particle: ${e}`);
+                return;
+            }
+        }
+    }
+    exports.Particles = Particles;
+    _Particles_engine = new WeakMap();
+});

package/umd/Core/Retina.d.ts

@@ -0,0 +1,26 @@
+import type { Container } from "./Container";
+import type { Particle } from "./Particle";
+export declare class Retina {
+    private readonly container;
+    reduceFactor: number;
+    bubbleModeDistance: number;
+    bubbleModeSize?: number;
+    connectModeDistance: number;
+    connectModeRadius: number;
+    grabModeDistance: number;
+    repulseModeDistance: number;
+    attractModeDistance: number;
+    attractDistance: number;
+    slowModeRadius: number;
+    linksDistance: number;
+    linksWidth: number;
+    sizeAnimationSpeed: number;
+    pixelRatio: number;
+    bounceModeDistance: number;
+    maxSpeed: number;
+    orbitRadius?: number;
+    constructor(container: Container);
+    init(): void;
+    initParticle(particle: Particle): void;
+    private handleMotionChange;
+}

package/umd/Core/Retina.js

@@ -0,0 +1,107 @@
+(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.Retina = void 0;
+    const Utils_1 = require("../Utils");
+    class Retina {
+        constructor(container) {
+            this.container = container;
+        }
+        init() {
+            const container = this.container;
+            const options = container.actualOptions;
+            this.pixelRatio = !options.detectRetina || (0, Utils_1.isSsr)() ? 1 : window.devicePixelRatio;
+            const motionOptions = this.container.actualOptions.motion;
+            if (motionOptions && (motionOptions.disable || motionOptions.reduce.value)) {
+                if ((0, Utils_1.isSsr)() || typeof matchMedia === "undefined" || !matchMedia) {
+                    this.reduceFactor = 1;
+                }
+                else {
+                    const mediaQuery = matchMedia("(prefers-reduced-motion: reduce)");
+                    if (mediaQuery) {
+                        this.handleMotionChange(mediaQuery);
+                        const handleChange = () => {
+                            this.handleMotionChange(mediaQuery);
+                            container.refresh().catch(() => {
+                            });
+                        };
+                        if (mediaQuery.addEventListener !== undefined) {
+                            mediaQuery.addEventListener("change", handleChange);
+                        }
+                        else if (mediaQuery.addListener !== undefined) {
+                            mediaQuery.addListener(handleChange);
+                        }
+                    }
+                }
+            }
+            else {
+                this.reduceFactor = 1;
+            }
+            const ratio = this.pixelRatio;
+            if (container.canvas.element) {
+                const element = container.canvas.element;
+                container.canvas.size.width = element.offsetWidth * ratio;
+                container.canvas.size.height = element.offsetHeight * ratio;
+            }
+            const particles = options.particles;
+            this.attractDistance = particles.move.attract.distance * ratio;
+            this.linksDistance = particles.links.distance * ratio;
+            this.linksWidth = particles.links.width * ratio;
+            this.sizeAnimationSpeed = particles.size.animation.speed * ratio;
+            this.maxSpeed = particles.move.gravity.maxSpeed * ratio;
+            if (particles.orbit.radius !== undefined) {
+                this.orbitRadius = particles.orbit.radius * this.container.retina.pixelRatio;
+            }
+            const modes = options.interactivity.modes;
+            this.connectModeDistance = modes.connect.distance * ratio;
+            this.connectModeRadius = modes.connect.radius * ratio;
+            this.grabModeDistance = modes.grab.distance * ratio;
+            this.repulseModeDistance = modes.repulse.distance * ratio;
+            this.bounceModeDistance = modes.bounce.distance * ratio;
+            this.attractModeDistance = modes.attract.distance * ratio;
+            this.slowModeRadius = modes.slow.radius * ratio;
+            this.bubbleModeDistance = modes.bubble.distance * ratio;
+            if (modes.bubble.size) {
+                this.bubbleModeSize = modes.bubble.size * ratio;
+            }
+        }
+        initParticle(particle) {
+            const options = particle.options;
+            const ratio = this.pixelRatio;
+            const moveDistance = options.move.distance;
+            const props = particle.retina;
+            props.attractDistance = options.move.attract.distance * ratio;
+            props.linksDistance = options.links.distance * ratio;
+            props.linksWidth = options.links.width * ratio;
+            props.moveDrift = (0, Utils_1.getRangeValue)(options.move.drift) * ratio;
+            props.moveSpeed = (0, Utils_1.getRangeValue)(options.move.speed) * ratio;
+            props.sizeAnimationSpeed = options.size.animation.speed * ratio;
+            if (particle.spin) {
+                props.spinAcceleration = (0, Utils_1.getRangeValue)(options.move.spin.acceleration) * ratio;
+            }
+            const maxDistance = props.maxDistance;
+            maxDistance.horizontal = moveDistance.horizontal !== undefined ? moveDistance.horizontal * ratio : undefined;
+            maxDistance.vertical = moveDistance.vertical !== undefined ? moveDistance.vertical * ratio : undefined;
+            props.maxSpeed = options.move.gravity.maxSpeed * ratio;
+        }
+        handleMotionChange(mediaQuery) {
+            const options = this.container.actualOptions;
+            if (mediaQuery.matches) {
+                const motion = options.motion;
+                this.reduceFactor = motion.disable ? 0 : motion.reduce.value ? 1 / motion.reduce.factor : 1;
+            }
+            else {
+                this.reduceFactor = 1;
+            }
+        }
+    }
+    exports.Retina = Retina;
+});

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

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

package/umd/Core/Utils/Circle.js

@@ -0,0 +1,52 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Range", "../../Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Circle = void 0;
+    const Range_1 = require("./Range");
+    const Utils_1 = require("../../Utils");
+    class Circle extends Range_1.Range {
+        constructor(x, y, radius) {
+            super(x, y);
+            this.radius = radius;
+        }
+        contains(point) {
+            return (0, Utils_1.getDistance)(point, this.position) <= this.radius;
+        }
+        intersects(range) {
+            const rect = range;
+            const circle = range;
+            const pos1 = this.position;
+            const pos2 = range.position;
+            const xDist = Math.abs(pos2.x - pos1.x);
+            const yDist = Math.abs(pos2.y - pos1.y);
+            const r = this.radius;
+            if (circle.radius !== undefined) {
+                const rSum = r + circle.radius;
+                const dist = Math.sqrt(xDist * xDist + yDist + yDist);
+                return rSum > dist;
+            }
+            else if (rect.size !== undefined) {
+                const w = rect.size.width;
+                const h = rect.size.height;
+                const edges = Math.pow(xDist - w, 2) + Math.pow(yDist - h, 2);
+                if (xDist > r + w || yDist > r + h) {
+                    return false;
+                }
+                if (xDist <= w || yDist <= h) {
+                    return true;
+                }
+                return edges <= r * r;
+            }
+            return false;
+        }
+    }
+    exports.Circle = Circle;
+});

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

@@ -0,0 +1,9 @@
+import type { ICoordinates, IDimension } from "../Interfaces";
+import { Circle } from "./Circle";
+import { Range } from "./Range";
+export declare class CircleWarp extends Circle {
+    private readonly canvasSize;
+    constructor(x: number, y: number, radius: number, canvasSize: IDimension);
+    contains(point: ICoordinates): boolean;
+    intersects(range: Range): boolean;
+}

package/umd/Core/Utils/CircleWarp.js

@@ -0,0 +1,70 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./Circle", "./Rectangle"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CircleWarp = void 0;
+    const Circle_1 = require("./Circle");
+    const Rectangle_1 = require("./Rectangle");
+    class CircleWarp extends Circle_1.Circle {
+        constructor(x, y, radius, canvasSize) {
+            super(x, y, radius);
+            this.canvasSize = canvasSize;
+            this.canvasSize = {
+                height: canvasSize.height,
+                width: canvasSize.width,
+            };
+        }
+        contains(point) {
+            if (super.contains(point)) {
+                return true;
+            }
+            const posNE = {
+                x: point.x - this.canvasSize.width,
+                y: point.y,
+            };
+            if (super.contains(posNE)) {
+                return true;
+            }
+            const posSE = {
+                x: point.x - this.canvasSize.width,
+                y: point.y - this.canvasSize.height,
+            };
+            if (super.contains(posSE)) {
+                return true;
+            }
+            const posSW = {
+                x: point.x,
+                y: point.y - this.canvasSize.height,
+            };
+            return super.contains(posSW);
+        }
+        intersects(range) {
+            if (super.intersects(range)) {
+                return true;
+            }
+            const rect = range;
+            const circle = range;
+            const newPos = {
+                x: range.position.x - this.canvasSize.width,
+                y: range.position.y - this.canvasSize.height,
+            };
+            if (circle.radius !== undefined) {
+                const biggerCircle = new Circle_1.Circle(newPos.x, newPos.y, circle.radius * 2);
+                return super.intersects(biggerCircle);
+            }
+            else if (rect.size !== undefined) {
+                const rectSW = new Rectangle_1.Rectangle(newPos.x, newPos.y, rect.size.width * 2, rect.size.height * 2);
+                return super.intersects(rectSW);
+            }
+            return false;
+        }
+    }
+    exports.CircleWarp = CircleWarp;
+});

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

@@ -0,0 +1,18 @@
+export declare class Constants {
+    static readonly generatedAttribute: string;
+    static readonly randomColorValue: string;
+    static readonly midColorValue: string;
+    static readonly touchEndEvent: string;
+    static readonly mouseDownEvent: string;
+    static readonly mouseUpEvent: string;
+    static readonly mouseMoveEvent: string;
+    static readonly touchStartEvent: string;
+    static readonly touchMoveEvent: string;
+    static readonly mouseLeaveEvent: string;
+    static readonly mouseOutEvent: string;
+    static readonly touchCancelEvent: string;
+    static readonly resizeEvent: string;
+    static readonly visibilityChangeEvent: string;
+    static readonly noPolygonDataLoaded: string;
+    static readonly noPolygonFound: string;
+}

package/umd/Core/Utils/Constants.js

@@ -0,0 +1,32 @@
+(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.Constants = void 0;
+    class Constants {
+    }
+    exports.Constants = Constants;
+    Constants.generatedAttribute = "generated";
+    Constants.randomColorValue = "random";
+    Constants.midColorValue = "mid";
+    Constants.touchEndEvent = "touchend";
+    Constants.mouseDownEvent = "mousedown";
+    Constants.mouseUpEvent = "mouseup";
+    Constants.mouseMoveEvent = "mousemove";
+    Constants.touchStartEvent = "touchstart";
+    Constants.touchMoveEvent = "touchmove";
+    Constants.mouseLeaveEvent = "mouseleave";
+    Constants.mouseOutEvent = "mouseout";
+    Constants.touchCancelEvent = "touchcancel";
+    Constants.resizeEvent = "resize";
+    Constants.visibilityChangeEvent = "visibilitychange";
+    Constants.noPolygonDataLoaded = "No polygon data loaded.";
+    Constants.noPolygonFound = "No polygon found, you need to specify SVG url in config.";
+});