@tsparticles/updater-out-modes 3.0.0-alpha.0

package/tsparticles.updater.out-modes.js

@@ -0,0 +1,440 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@tsparticles/engine"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@tsparticles/engine"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@tsparticles/engine")) : factory(root["window"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__533__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 533:
+/***/ ((module) => {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "loadOutModesUpdater": () => (/* binding */ loadOutModesUpdater)
+});
+
+// EXTERNAL MODULE: external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"}
+var engine_root_window_ = __webpack_require__(533);
+;// CONCATENATED MODULE: ./dist/browser/Utils.js
+
+function bounceHorizontal(data) {
+  if (data.outMode !== "bounce" && data.outMode !== "bounce-horizontal" && data.outMode !== "bounceHorizontal" && data.outMode !== "split") {
+    return;
+  }
+  if (data.bounds.right < 0) {
+    data.particle.position.x = data.size + data.offset.x;
+  } else if (data.bounds.left > data.canvasSize.width) {
+    data.particle.position.x = data.canvasSize.width - data.size - data.offset.x;
+  }
+  const velocity = data.particle.velocity.x;
+  let bounced = false;
+  if (data.direction === "right" && data.bounds.right >= data.canvasSize.width && velocity > 0 || data.direction === "left" && data.bounds.left <= 0 && velocity < 0) {
+    const newVelocity = (0,engine_root_window_.getValue)(data.particle.options.bounce.horizontal);
+    data.particle.velocity.x *= -newVelocity;
+    bounced = true;
+  }
+  if (!bounced) {
+    return;
+  }
+  const minPos = data.offset.x + data.size;
+  if (data.bounds.right >= data.canvasSize.width) {
+    data.particle.position.x = data.canvasSize.width - minPos;
+  } else if (data.bounds.left <= 0) {
+    data.particle.position.x = minPos;
+  }
+  if (data.outMode === "split") {
+    data.particle.destroy();
+  }
+}
+function bounceVertical(data) {
+  if (data.outMode !== "bounce" && data.outMode !== "bounce-vertical" && data.outMode !== "bounceVertical" && data.outMode !== "split") {
+    return;
+  }
+  if (data.bounds.bottom < 0) {
+    data.particle.position.y = data.size + data.offset.y;
+  } else if (data.bounds.top > data.canvasSize.height) {
+    data.particle.position.y = data.canvasSize.height - data.size - data.offset.y;
+  }
+  const velocity = data.particle.velocity.y;
+  let bounced = false;
+  if (data.direction === "bottom" && data.bounds.bottom >= data.canvasSize.height && velocity > 0 || data.direction === "top" && data.bounds.top <= 0 && velocity < 0) {
+    const newVelocity = (0,engine_root_window_.getValue)(data.particle.options.bounce.vertical);
+    data.particle.velocity.y *= -newVelocity;
+    bounced = true;
+  }
+  if (!bounced) {
+    return;
+  }
+  const minPos = data.offset.y + data.size;
+  if (data.bounds.bottom >= data.canvasSize.height) {
+    data.particle.position.y = data.canvasSize.height - minPos;
+  } else if (data.bounds.top <= 0) {
+    data.particle.position.y = minPos;
+  }
+  if (data.outMode === "split") {
+    data.particle.destroy();
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/BounceOutMode.js
+
+
+class BounceOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = ["bounce", "bounce-vertical", "bounce-horizontal", "bounceVertical", "bounceHorizontal", "split"];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    let handled = false;
+    for (const [, plugin] of container.plugins) {
+      if (plugin.particleBounce !== undefined) {
+        handled = plugin.particleBounce(particle, delta, direction);
+      }
+      if (handled) {
+        break;
+      }
+    }
+    if (handled) {
+      return;
+    }
+    const pos = particle.getPosition(),
+      offset = particle.offset,
+      size = particle.getRadius(),
+      bounds = (0,engine_root_window_.calculateBounds)(pos, size),
+      canvasSize = container.canvas.size;
+    bounceHorizontal({
+      particle,
+      outMode,
+      direction,
+      bounds,
+      canvasSize,
+      offset,
+      size
+    });
+    bounceVertical({
+      particle,
+      outMode,
+      direction,
+      bounds,
+      canvasSize,
+      offset,
+      size
+    });
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/DestroyOutMode.js
+
+class DestroyOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = ["destroy"];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    switch (particle.outType) {
+      case "normal":
+      case "outside":
+        if ((0,engine_root_window_.isPointInside)(particle.position, container.canvas.size, engine_root_window_.Vector.origin, particle.getRadius(), direction)) {
+          return;
+        }
+        break;
+      case "inside":
+        {
+          const {
+            dx,
+            dy
+          } = (0,engine_root_window_.getDistances)(particle.position, particle.moveCenter);
+          const {
+            x: vx,
+            y: vy
+          } = particle.velocity;
+          if (vx < 0 && dx > particle.moveCenter.radius || vy < 0 && dy > particle.moveCenter.radius || vx >= 0 && dx < -particle.moveCenter.radius || vy >= 0 && dy < -particle.moveCenter.radius) {
+            return;
+          }
+          break;
+        }
+    }
+    container.particles.remove(particle, undefined, true);
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/NoneOutMode.js
+
+class NoneOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = ["none"];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    if (particle.options.move.distance.horizontal && (direction === "left" || direction === "right") || particle.options.move.distance.vertical && (direction === "top" || direction === "bottom")) {
+      return;
+    }
+    const gravityOptions = particle.options.move.gravity,
+      container = this.container;
+    const canvasSize = container.canvas.size;
+    const pRadius = particle.getRadius();
+    if (!gravityOptions.enable) {
+      if (particle.velocity.y > 0 && particle.position.y <= canvasSize.height + pRadius || particle.velocity.y < 0 && particle.position.y >= -pRadius || particle.velocity.x > 0 && particle.position.x <= canvasSize.width + pRadius || particle.velocity.x < 0 && particle.position.x >= -pRadius) {
+        return;
+      }
+      if (!(0,engine_root_window_.isPointInside)(particle.position, container.canvas.size, engine_root_window_.Vector.origin, pRadius, direction)) {
+        container.particles.remove(particle);
+      }
+    } else {
+      const position = particle.position;
+      if (!gravityOptions.inverse && position.y > canvasSize.height + pRadius && direction === "bottom" || gravityOptions.inverse && position.y < -pRadius && direction === "top") {
+        container.particles.remove(particle);
+      }
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/OutOutMode.js
+
+class OutOutMode {
+  constructor(container) {
+    this.container = container;
+    this.modes = ["out"];
+  }
+  update(particle, direction, delta, outMode) {
+    if (!this.modes.includes(outMode)) {
+      return;
+    }
+    const container = this.container;
+    switch (particle.outType) {
+      case "inside":
+        {
+          const {
+            x: vx,
+            y: vy
+          } = particle.velocity;
+          const circVec = engine_root_window_.Vector.origin;
+          circVec.length = particle.moveCenter.radius;
+          circVec.angle = particle.velocity.angle + Math.PI;
+          circVec.addTo(engine_root_window_.Vector.create(particle.moveCenter));
+          const {
+            dx,
+            dy
+          } = (0,engine_root_window_.getDistances)(particle.position, circVec);
+          if (vx <= 0 && dx >= 0 || vy <= 0 && dy >= 0 || vx >= 0 && dx <= 0 || vy >= 0 && dy <= 0) {
+            return;
+          }
+          particle.position.x = Math.floor((0,engine_root_window_.randomInRange)({
+            min: 0,
+            max: container.canvas.size.width
+          }));
+          particle.position.y = Math.floor((0,engine_root_window_.randomInRange)({
+            min: 0,
+            max: container.canvas.size.height
+          }));
+          const {
+            dx: newDx,
+            dy: newDy
+          } = (0,engine_root_window_.getDistances)(particle.position, particle.moveCenter);
+          particle.direction = Math.atan2(-newDy, -newDx);
+          particle.velocity.angle = particle.direction;
+          break;
+        }
+      default:
+        {
+          if ((0,engine_root_window_.isPointInside)(particle.position, container.canvas.size, engine_root_window_.Vector.origin, particle.getRadius(), direction)) {
+            return;
+          }
+          switch (particle.outType) {
+            case "outside":
+              {
+                particle.position.x = Math.floor((0,engine_root_window_.randomInRange)({
+                  min: -particle.moveCenter.radius,
+                  max: particle.moveCenter.radius
+                })) + particle.moveCenter.x;
+                particle.position.y = Math.floor((0,engine_root_window_.randomInRange)({
+                  min: -particle.moveCenter.radius,
+                  max: particle.moveCenter.radius
+                })) + particle.moveCenter.y;
+                const {
+                  dx,
+                  dy
+                } = (0,engine_root_window_.getDistances)(particle.position, particle.moveCenter);
+                if (particle.moveCenter.radius) {
+                  particle.direction = Math.atan2(dy, dx);
+                  particle.velocity.angle = particle.direction;
+                }
+                break;
+              }
+            case "normal":
+              {
+                const wrap = particle.options.move.warp,
+                  canvasSize = container.canvas.size,
+                  newPos = {
+                    bottom: canvasSize.height + particle.getRadius() + particle.offset.y,
+                    left: -particle.getRadius() - particle.offset.x,
+                    right: canvasSize.width + particle.getRadius() + particle.offset.x,
+                    top: -particle.getRadius() - particle.offset.y
+                  },
+                  sizeValue = particle.getRadius(),
+                  nextBounds = (0,engine_root_window_.calculateBounds)(particle.position, sizeValue);
+                if (direction === "right" && nextBounds.left > canvasSize.width + particle.offset.x) {
+                  particle.position.x = newPos.left;
+                  particle.initialPosition.x = particle.position.x;
+                  if (!wrap) {
+                    particle.position.y = (0,engine_root_window_.getRandom)() * canvasSize.height;
+                    particle.initialPosition.y = particle.position.y;
+                  }
+                } else if (direction === "left" && nextBounds.right < -particle.offset.x) {
+                  particle.position.x = newPos.right;
+                  particle.initialPosition.x = particle.position.x;
+                  if (!wrap) {
+                    particle.position.y = (0,engine_root_window_.getRandom)() * canvasSize.height;
+                    particle.initialPosition.y = particle.position.y;
+                  }
+                }
+                if (direction === "bottom" && nextBounds.top > canvasSize.height + particle.offset.y) {
+                  if (!wrap) {
+                    particle.position.x = (0,engine_root_window_.getRandom)() * canvasSize.width;
+                    particle.initialPosition.x = particle.position.x;
+                  }
+                  particle.position.y = newPos.top;
+                  particle.initialPosition.y = particle.position.y;
+                } else if (direction === "top" && nextBounds.bottom < -particle.offset.y) {
+                  if (!wrap) {
+                    particle.position.x = (0,engine_root_window_.getRandom)() * canvasSize.width;
+                    particle.initialPosition.x = particle.position.x;
+                  }
+                  particle.position.y = newPos.bottom;
+                  particle.initialPosition.y = particle.position.y;
+                }
+                break;
+              }
+          }
+          break;
+        }
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/OutOfCanvasUpdater.js
+
+
+
+
+class OutOfCanvasUpdater {
+  constructor(container) {
+    this.container = container;
+    this.updaters = [new BounceOutMode(container), new DestroyOutMode(container), new OutOutMode(container), new NoneOutMode(container)];
+  }
+  init() {}
+  isEnabled(particle) {
+    return !particle.destroyed && !particle.spawning;
+  }
+  update(particle, delta) {
+    var _a, _b, _c, _d;
+    const outModes = particle.options.move.outModes;
+    this.updateOutMode(particle, delta, (_a = outModes.bottom) !== null && _a !== void 0 ? _a : outModes.default, "bottom");
+    this.updateOutMode(particle, delta, (_b = outModes.left) !== null && _b !== void 0 ? _b : outModes.default, "left");
+    this.updateOutMode(particle, delta, (_c = outModes.right) !== null && _c !== void 0 ? _c : outModes.default, "right");
+    this.updateOutMode(particle, delta, (_d = outModes.top) !== null && _d !== void 0 ? _d : outModes.default, "top");
+  }
+  updateOutMode(particle, delta, outMode, direction) {
+    for (const updater of this.updaters) {
+      updater.update(particle, direction, delta, outMode);
+    }
+  }
+}
+;// CONCATENATED MODULE: ./dist/browser/index.js
+
+async function loadOutModesUpdater(engine) {
+  await engine.addParticleUpdater("outModes", container => new OutOfCanvasUpdater(container));
+}
+})();
+
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});

package/tsparticles.updater.out-modes.min.js

@@ -0,0 +1,2 @@
+/*! For license information please see tsparticles.updater.out-modes.min.js.LICENSE.txt */
+!function(t,o){if("object"==typeof exports&&"object"==typeof module)module.exports=o(require("@tsparticles/engine"));else if("function"==typeof define&&define.amd)define(["@tsparticles/engine"],o);else{var e="object"==typeof exports?o(require("@tsparticles/engine")):o(t.window);for(var i in e)("object"==typeof exports?exports:t)[i]=e[i]}}(this,(t=>(()=>{"use strict";var o={533:o=>{o.exports=t}},e={};function i(t){var n=e[t];if(void 0!==n)return n.exports;var s=e[t]={exports:{}};return o[t](s,s.exports,i),s.exports}i.d=(t,o)=>{for(var e in o)i.o(o,e)&&!i.o(t,e)&&Object.defineProperty(t,e,{enumerable:!0,get:o[e]})},i.o=(t,o)=>Object.prototype.hasOwnProperty.call(t,o),i.r=t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})};var n={};return(()=>{i.r(n),i.d(n,{loadOutModesUpdater:()=>c});var t=i(533);class o{constructor(t){this.container=t,this.modes=["bounce","bounce-vertical","bounce-horizontal","bounceVertical","bounceHorizontal","split"]}update(o,e,i,n){if(!this.modes.includes(n))return;const s=this.container;let a=!1;for(const[,t]of s.plugins)if(void 0!==t.particleBounce&&(a=t.particleBounce(o,i,e)),a)break;if(a)return;const r=o.getPosition(),c=o.offset,d=o.getRadius(),u=(0,t.calculateBounds)(r,d),l=s.canvas.size;!function(o){if("bounce"!==o.outMode&&"bounce-horizontal"!==o.outMode&&"bounceHorizontal"!==o.outMode&&"split"!==o.outMode)return;o.bounds.right<0?o.particle.position.x=o.size+o.offset.x:o.bounds.left>o.canvasSize.width&&(o.particle.position.x=o.canvasSize.width-o.size-o.offset.x);const e=o.particle.velocity.x;let i=!1;if("right"===o.direction&&o.bounds.right>=o.canvasSize.width&&e>0||"left"===o.direction&&o.bounds.left<=0&&e<0){const e=(0,t.getValue)(o.particle.options.bounce.horizontal);o.particle.velocity.x*=-e,i=!0}if(!i)return;const n=o.offset.x+o.size;o.bounds.right>=o.canvasSize.width?o.particle.position.x=o.canvasSize.width-n:o.bounds.left<=0&&(o.particle.position.x=n),"split"===o.outMode&&o.particle.destroy()}({particle:o,outMode:n,direction:e,bounds:u,canvasSize:l,offset:c,size:d}),function(o){if("bounce"!==o.outMode&&"bounce-vertical"!==o.outMode&&"bounceVertical"!==o.outMode&&"split"!==o.outMode)return;o.bounds.bottom<0?o.particle.position.y=o.size+o.offset.y:o.bounds.top>o.canvasSize.height&&(o.particle.position.y=o.canvasSize.height-o.size-o.offset.y);const e=o.particle.velocity.y;let i=!1;if("bottom"===o.direction&&o.bounds.bottom>=o.canvasSize.height&&e>0||"top"===o.direction&&o.bounds.top<=0&&e<0){const e=(0,t.getValue)(o.particle.options.bounce.vertical);o.particle.velocity.y*=-e,i=!0}if(!i)return;const n=o.offset.y+o.size;o.bounds.bottom>=o.canvasSize.height?o.particle.position.y=o.canvasSize.height-n:o.bounds.top<=0&&(o.particle.position.y=n),"split"===o.outMode&&o.particle.destroy()}({particle:o,outMode:n,direction:e,bounds:u,canvasSize:l,offset:c,size:d})}}class e{constructor(t){this.container=t,this.modes=["destroy"]}update(o,e,i,n){if(!this.modes.includes(n))return;const s=this.container;switch(o.outType){case"normal":case"outside":if((0,t.isPointInside)(o.position,s.canvas.size,t.Vector.origin,o.getRadius(),e))return;break;case"inside":{const{dx:e,dy:i}=(0,t.getDistances)(o.position,o.moveCenter),{x:n,y:s}=o.velocity;if(n<0&&e>o.moveCenter.radius||s<0&&i>o.moveCenter.radius||n>=0&&e<-o.moveCenter.radius||s>=0&&i<-o.moveCenter.radius)return;break}}s.particles.remove(o,void 0,!0)}}class s{constructor(t){this.container=t,this.modes=["none"]}update(o,e,i,n){if(!this.modes.includes(n))return;if(o.options.move.distance.horizontal&&("left"===e||"right"===e)||o.options.move.distance.vertical&&("top"===e||"bottom"===e))return;const s=o.options.move.gravity,a=this.container,r=a.canvas.size,c=o.getRadius();if(s.enable){const t=o.position;(!s.inverse&&t.y>r.height+c&&"bottom"===e||s.inverse&&t.y<-c&&"top"===e)&&a.particles.remove(o)}else{if(o.velocity.y>0&&o.position.y<=r.height+c||o.velocity.y<0&&o.position.y>=-c||o.velocity.x>0&&o.position.x<=r.width+c||o.velocity.x<0&&o.position.x>=-c)return;(0,t.isPointInside)(o.position,a.canvas.size,t.Vector.origin,c,e)||a.particles.remove(o)}}}class a{constructor(t){this.container=t,this.modes=["out"]}update(o,e,i,n){if(!this.modes.includes(n))return;const s=this.container;switch(o.outType){case"inside":{const{x:e,y:i}=o.velocity,n=t.Vector.origin;n.length=o.moveCenter.radius,n.angle=o.velocity.angle+Math.PI,n.addTo(t.Vector.create(o.moveCenter));const{dx:a,dy:r}=(0,t.getDistances)(o.position,n);if(e<=0&&a>=0||i<=0&&r>=0||e>=0&&a<=0||i>=0&&r<=0)return;o.position.x=Math.floor((0,t.randomInRange)({min:0,max:s.canvas.size.width})),o.position.y=Math.floor((0,t.randomInRange)({min:0,max:s.canvas.size.height}));const{dx:c,dy:d}=(0,t.getDistances)(o.position,o.moveCenter);o.direction=Math.atan2(-d,-c),o.velocity.angle=o.direction;break}default:if((0,t.isPointInside)(o.position,s.canvas.size,t.Vector.origin,o.getRadius(),e))return;switch(o.outType){case"outside":{o.position.x=Math.floor((0,t.randomInRange)({min:-o.moveCenter.radius,max:o.moveCenter.radius}))+o.moveCenter.x,o.position.y=Math.floor((0,t.randomInRange)({min:-o.moveCenter.radius,max:o.moveCenter.radius}))+o.moveCenter.y;const{dx:e,dy:i}=(0,t.getDistances)(o.position,o.moveCenter);o.moveCenter.radius&&(o.direction=Math.atan2(i,e),o.velocity.angle=o.direction);break}case"normal":{const i=o.options.move.warp,n=s.canvas.size,a={bottom:n.height+o.getRadius()+o.offset.y,left:-o.getRadius()-o.offset.x,right:n.width+o.getRadius()+o.offset.x,top:-o.getRadius()-o.offset.y},r=o.getRadius(),c=(0,t.calculateBounds)(o.position,r);"right"===e&&c.left>n.width+o.offset.x?(o.position.x=a.left,o.initialPosition.x=o.position.x,i||(o.position.y=(0,t.getRandom)()*n.height,o.initialPosition.y=o.position.y)):"left"===e&&c.right<-o.offset.x&&(o.position.x=a.right,o.initialPosition.x=o.position.x,i||(o.position.y=(0,t.getRandom)()*n.height,o.initialPosition.y=o.position.y)),"bottom"===e&&c.top>n.height+o.offset.y?(i||(o.position.x=(0,t.getRandom)()*n.width,o.initialPosition.x=o.position.x),o.position.y=a.top,o.initialPosition.y=o.position.y):"top"===e&&c.bottom<-o.offset.y&&(i||(o.position.x=(0,t.getRandom)()*n.width,o.initialPosition.x=o.position.x),o.position.y=a.bottom,o.initialPosition.y=o.position.y);break}}}}}class r{constructor(t){this.container=t,this.updaters=[new o(t),new e(t),new a(t),new s(t)]}init(){}isEnabled(t){return!t.destroyed&&!t.spawning}update(t,o){var e,i,n,s;const a=t.options.move.outModes;this.updateOutMode(t,o,null!==(e=a.bottom)&&void 0!==e?e:a.default,"bottom"),this.updateOutMode(t,o,null!==(i=a.left)&&void 0!==i?i:a.default,"left"),this.updateOutMode(t,o,null!==(n=a.right)&&void 0!==n?n:a.default,"right"),this.updateOutMode(t,o,null!==(s=a.top)&&void 0!==s?s:a.default,"top")}updateOutMode(t,o,e,i){for(const n of this.updaters)n.update(t,i,o,e)}}async function c(t){await t.addParticleUpdater("outModes",(t=>new r(t)))}})(),n})()));

package/tsparticles.updater.out-modes.min.js.LICENSE.txt

@@ -0,0 +1,8 @@
+/*!
+ * Author : Matteo Bruni
+ * MIT license: https://opensource.org/licenses/MIT
+ * Demo / Generator : https://particles.js.org/
+ * GitHub : https://www.github.com/matteobruni/tsparticles
+ * How to use? : Check the GitHub README
+ * v3.0.0-alpha.0
+ */

package/types/BounceOutMode.d.ts

@@ -0,0 +1,9 @@
+import type { Container, IDelta, OutModeAlt, OutModeDirection, Particle } from "@tsparticles/engine";
+import { OutMode } from "@tsparticles/engine";
+import type { IOutModeManager } from "./IOutModeManager";
+export declare class BounceOutMode implements IOutModeManager {
+    private readonly container;
+    modes: (OutMode | OutModeAlt | keyof typeof OutMode)[];
+    constructor(container: Container);
+    update(particle: Particle, direction: OutModeDirection, delta: IDelta, outMode: OutMode | OutModeAlt | keyof typeof OutMode): void;
+}

package/types/DestroyOutMode.d.ts

@@ -0,0 +1,9 @@
+import type { Container, IDelta, OutModeAlt, OutModeDirection, Particle } from "@tsparticles/engine";
+import { OutMode } from "@tsparticles/engine";
+import type { IOutModeManager } from "./IOutModeManager";
+export declare class DestroyOutMode implements IOutModeManager {
+    private readonly container;
+    modes: (OutMode | OutModeAlt | keyof typeof OutMode)[];
+    constructor(container: Container);
+    update(particle: Particle, direction: OutModeDirection, delta: IDelta, outMode: OutMode | OutModeAlt | keyof typeof OutMode): void;
+}

package/types/IBounceData.d.ts

@@ -0,0 +1,11 @@
+import type { IBounds, ICoordinates, IDimension, OutMode, OutModeAlt, OutModeDirection } from "@tsparticles/engine";
+import type { Particle } from "@tsparticles/engine";
+export interface IBounceData {
+    bounds: IBounds;
+    canvasSize: IDimension;
+    direction: OutModeDirection;
+    offset: ICoordinates;
+    outMode: OutMode | OutModeAlt | keyof typeof OutMode;
+    particle: Particle;
+    size: number;
+}

package/types/IOutModeManager.d.ts

@@ -0,0 +1,5 @@
+import type { IDelta, OutMode, OutModeAlt, OutModeDirection, Particle } from "@tsparticles/engine";
+export interface IOutModeManager {
+    modes: (OutMode | OutModeAlt | keyof typeof OutMode)[];
+    update(particle: Particle, direction: OutModeDirection, delta: IDelta, outMode: OutMode | OutModeAlt | keyof typeof OutMode): void;
+}

package/types/NoneOutMode.d.ts

@@ -0,0 +1,9 @@
+import type { Container, IDelta, OutModeAlt, Particle } from "@tsparticles/engine";
+import { OutMode, OutModeDirection } from "@tsparticles/engine";
+import type { IOutModeManager } from "./IOutModeManager";
+export declare class NoneOutMode implements IOutModeManager {
+    private readonly container;
+    modes: (OutMode | OutModeAlt | keyof typeof OutMode)[];
+    constructor(container: Container);
+    update(particle: Particle, direction: OutModeDirection, delta: IDelta, outMode: OutMode | OutModeAlt | keyof typeof OutMode): void;
+}

package/types/OutOfCanvasUpdater.d.ts

@@ -0,0 +1,11 @@
+import type { Container, IDelta, IParticleUpdater, Particle } from "@tsparticles/engine";
+import type { IOutModeManager } from "./IOutModeManager";
+export declare class OutOfCanvasUpdater implements IParticleUpdater {
+    private readonly container;
+    updaters: IOutModeManager[];
+    constructor(container: Container);
+    init(): void;
+    isEnabled(particle: Particle): boolean;
+    update(particle: Particle, delta: IDelta): void;
+    private updateOutMode;
+}

package/types/OutOutMode.d.ts

@@ -0,0 +1,9 @@
+import type { Container, IDelta, OutModeAlt, Particle } from "@tsparticles/engine";
+import { OutMode, OutModeDirection } from "@tsparticles/engine";
+import type { IOutModeManager } from "./IOutModeManager";
+export declare class OutOutMode implements IOutModeManager {
+    private readonly container;
+    modes: (OutMode | OutModeAlt | keyof typeof OutMode)[];
+    constructor(container: Container);
+    update(particle: Particle, direction: OutModeDirection, delta: IDelta, outMode: OutMode | OutModeAlt | keyof typeof OutMode): void;
+}

package/types/Utils.d.ts

@@ -0,0 +1,3 @@
+import type { IBounceData } from "./IBounceData";
+export declare function bounceHorizontal(data: IBounceData): void;
+export declare function bounceVertical(data: IBounceData): void;

package/types/index.d.ts

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

package/umd/BounceOutMode.js

@@ -0,0 +1,50 @@
+(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", "@tsparticles/engine", "./Utils"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.BounceOutMode = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    const Utils_1 = require("./Utils");
+    class BounceOutMode {
+        constructor(container) {
+            this.container = container;
+            this.modes = [
+                "bounce",
+                "bounce-vertical",
+                "bounce-horizontal",
+                "bounceVertical",
+                "bounceHorizontal",
+                "split",
+            ];
+        }
+        update(particle, direction, delta, outMode) {
+            if (!this.modes.includes(outMode)) {
+                return;
+            }
+            const container = this.container;
+            let handled = false;
+            for (const [, plugin] of container.plugins) {
+                if (plugin.particleBounce !== undefined) {
+                    handled = plugin.particleBounce(particle, delta, direction);
+                }
+                if (handled) {
+                    break;
+                }
+            }
+            if (handled) {
+                return;
+            }
+            const pos = particle.getPosition(), offset = particle.offset, size = particle.getRadius(), bounds = (0, engine_1.calculateBounds)(pos, size), canvasSize = container.canvas.size;
+            (0, Utils_1.bounceHorizontal)({ particle, outMode, direction, bounds, canvasSize, offset, size });
+            (0, Utils_1.bounceVertical)({ particle, outMode, direction, bounds, canvasSize, offset, size });
+        }
+    }
+    exports.BounceOutMode = BounceOutMode;
+});

package/umd/DestroyOutMode.js

@@ -0,0 +1,47 @@
+(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", "@tsparticles/engine"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DestroyOutMode = void 0;
+    const engine_1 = require("@tsparticles/engine");
+    class DestroyOutMode {
+        constructor(container) {
+            this.container = container;
+            this.modes = ["destroy"];
+        }
+        update(particle, direction, delta, outMode) {
+            if (!this.modes.includes(outMode)) {
+                return;
+            }
+            const container = this.container;
+            switch (particle.outType) {
+                case "normal":
+                case "outside":
+                    if ((0, engine_1.isPointInside)(particle.position, container.canvas.size, engine_1.Vector.origin, particle.getRadius(), direction)) {
+                        return;
+                    }
+                    break;
+                case "inside": {
+                    const { dx, dy } = (0, engine_1.getDistances)(particle.position, particle.moveCenter);
+                    const { x: vx, y: vy } = particle.velocity;
+                    if ((vx < 0 && dx > particle.moveCenter.radius) ||
+                        (vy < 0 && dy > particle.moveCenter.radius) ||
+                        (vx >= 0 && dx < -particle.moveCenter.radius) ||
+                        (vy >= 0 && dy < -particle.moveCenter.radius)) {
+                        return;
+                    }
+                    break;
+                }
+            }
+            container.particles.remove(particle, undefined, true);
+        }
+    }
+    exports.DestroyOutMode = DestroyOutMode;
+});

package/umd/IBounceData.js

@@ -0,0 +1,12 @@
+(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 });
+});