@tsparticles/shape-image 3.1.0 → 3.2.0

package/tsparticles.shape.image.js

@@ -4,7 +4,15 @@
  * Demo / Generator : https://particles.js.org/
  * GitHub : https://www.github.com/matteobruni/tsparticles
  * How to use? : Check the GitHub README
- * v3.1.0
+ * v3.2.0
+ */
+/*
+ * ATTENTION: The "eval" devtool has been used (maybe by default in mode: "development").
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
  */
 (function webpackUniversalModuleDefinition(root, factory) {
 	if(typeof exports === 'object' && typeof module === 'object')
@@ -15,15 +23,38 @@
 		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__) => {
+})(this, (__WEBPACK_EXTERNAL_MODULE__tsparticles_engine__) => {
 return /******/ (() => { // webpackBootstrap
 /******/ 	"use strict";
 /******/ 	var __webpack_modules__ = ({
 
-/***/ 533:
+/***/ "./dist/browser/Utils.js":
+/*!*******************************!*\
+  !*** ./dist/browser/Utils.js ***!
+  \*******************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   downloadSvgImage: () => (/* binding */ downloadSvgImage),\n/* harmony export */   loadImage: () => (/* binding */ loadImage),\n/* harmony export */   replaceImageColor: () => (/* binding */ replaceImageColor)\n/* harmony export */ });\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__);\n\nconst stringStart = 0,\n  defaultOpacity = 1;\nconst currentColorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\\((-?\\d+%?[,\\s]+){2,3}\\s*[\\d.]+%?\\))|currentcolor/gi;\nfunction replaceColorSvg(imageShape, color, opacity) {\n  const {\n    svgData\n  } = imageShape;\n  if (!svgData) {\n    return \"\";\n  }\n  const colorStyle = (0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getStyleFromHsl)(color, opacity);\n  if (svgData.includes(\"fill\")) {\n    return svgData.replace(currentColorRegex, () => colorStyle);\n  }\n  const preFillIndex = svgData.indexOf(\">\");\n  return `${svgData.substring(stringStart, preFillIndex)} fill=\"${colorStyle}\"${svgData.substring(preFillIndex)}`;\n}\nasync function loadImage(image) {\n  return new Promise(resolve => {\n    image.loading = true;\n    const img = new Image();\n    image.element = img;\n    img.addEventListener(\"load\", () => {\n      image.loading = false;\n      resolve();\n    });\n    img.addEventListener(\"error\", () => {\n      image.element = undefined;\n      image.error = true;\n      image.loading = false;\n      (0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getLogger)().error(`${_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.errorPrefix} loading image: ${image.source}`);\n      resolve();\n    });\n    img.src = image.source;\n  });\n}\nasync function downloadSvgImage(image) {\n  if (image.type !== \"svg\") {\n    await loadImage(image);\n    return;\n  }\n  image.loading = true;\n  const response = await fetch(image.source);\n  if (!response.ok) {\n    (0,_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.getLogger)().error(`${_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.errorPrefix} Image not found`);\n    image.error = true;\n  } else {\n    image.svgData = await response.text();\n  }\n  image.loading = false;\n}\nfunction replaceImageColor(image, imageData, color, particle) {\n  const svgColoredData = replaceColorSvg(image, color, particle.opacity?.value ?? defaultOpacity),\n    imageRes = {\n      color,\n      gif: imageData.gif,\n      data: {\n        ...image,\n        svgData: svgColoredData\n      },\n      loaded: false,\n      ratio: imageData.width / imageData.height,\n      replaceColor: imageData.replaceColor,\n      source: imageData.src\n    };\n  return new Promise(resolve => {\n    const svg = new Blob([svgColoredData], {\n        type: \"image/svg+xml\"\n      }),\n      domUrl = URL || window.URL || window.webkitURL || window,\n      url = domUrl.createObjectURL(svg),\n      img = new Image();\n    img.addEventListener(\"load\", () => {\n      imageRes.loaded = true;\n      imageRes.element = img;\n      resolve(imageRes);\n      domUrl.revokeObjectURL(url);\n    });\n    const errorHandler = async () => {\n      domUrl.revokeObjectURL(url);\n      const img2 = {\n        ...image,\n        error: false,\n        loading: true\n      };\n      await loadImage(img2);\n      imageRes.loaded = true;\n      imageRes.element = img2.element;\n      resolve(imageRes);\n    };\n    img.addEventListener(\"error\", () => void errorHandler());\n    img.src = url;\n  });\n}\n\n//# sourceURL=webpack://@tsparticles/shape-image/./dist/browser/Utils.js?");
+
+/***/ }),
+
+/***/ "./dist/browser/index.js":
+/*!*******************************!*\
+  !*** ./dist/browser/index.js ***!
+  \*******************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpack_require__.d(__webpack_exports__, {\n/* harmony export */   loadImageShape: () => (/* binding */ loadImageShape)\n/* harmony export */ });\n/* harmony import */ var _Utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Utils.js */ \"./dist/browser/Utils.js\");\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @tsparticles/engine */ \"@tsparticles/engine\");\n/* harmony import */ var _tsparticles_engine__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__);\n\n\nconst extLength = 3;\nfunction addLoadImageToEngine(engine) {\n  if (engine.loadImage) {\n    return;\n  }\n  engine.loadImage = async data => {\n    if (!data.name && !data.src) {\n      throw new Error(`${_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.errorPrefix} no image source provided`);\n    }\n    if (!engine.images) {\n      engine.images = [];\n    }\n    if (engine.images.find(t => t.name === data.name || t.source === data.src)) {\n      return;\n    }\n    try {\n      const image = {\n        gif: data.gif ?? false,\n        name: data.name ?? data.src,\n        source: data.src,\n        type: data.src.substring(data.src.length - extLength),\n        error: false,\n        loading: true,\n        replaceColor: data.replaceColor,\n        ratio: data.width && data.height ? data.width / data.height : undefined\n      };\n      engine.images.push(image);\n      let imageFunc;\n      if (data.gif) {\n        const {\n          loadGifImage\n        } = await __webpack_require__.e(/*! import() */ \"dist_browser_GifUtils_Utils_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./GifUtils/Utils.js */ \"./dist/browser/GifUtils/Utils.js\"));\n        imageFunc = loadGifImage;\n      } else {\n        imageFunc = data.replaceColor ? _Utils_js__WEBPACK_IMPORTED_MODULE_1__.downloadSvgImage : _Utils_js__WEBPACK_IMPORTED_MODULE_1__.loadImage;\n      }\n      await imageFunc(image);\n    } catch {\n      throw new Error(`${_tsparticles_engine__WEBPACK_IMPORTED_MODULE_0__.errorPrefix} ${data.name ?? data.src} not found`);\n    }\n  };\n}\nasync function loadImageShape(engine, refresh = true) {\n  addLoadImageToEngine(engine);\n  const {\n      ImagePreloaderPlugin\n    } = await __webpack_require__.e(/*! import() */ \"dist_browser_ImagePreloader_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./ImagePreloader.js */ \"./dist/browser/ImagePreloader.js\")),\n    {\n      ImageDrawer\n    } = await __webpack_require__.e(/*! import() */ \"dist_browser_ImageDrawer_js\").then(__webpack_require__.bind(__webpack_require__, /*! ./ImageDrawer.js */ \"./dist/browser/ImageDrawer.js\"));\n  const preloader = new ImagePreloaderPlugin(engine);\n  await engine.addPlugin(preloader, refresh);\n  await engine.addShape([\"image\", \"images\"], new ImageDrawer(engine), refresh);\n}\n\n//# sourceURL=webpack://@tsparticles/shape-image/./dist/browser/index.js?");
+
+/***/ }),
+
+/***/ "@tsparticles/engine":
+/*!*********************************************************************************************************************************!*\
+  !*** external {"commonjs":"@tsparticles/engine","commonjs2":"@tsparticles/engine","amd":"@tsparticles/engine","root":"window"} ***!
+  \*********************************************************************************************************************************/
 /***/ ((module) => {
 
-module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
+module.exports = __WEBPACK_EXTERNAL_MODULE__tsparticles_engine__;
 
 /***/ })
 
@@ -53,7 +84,22 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
 /******/ 		return module.exports;
 /******/ 	}
 /******/ 	
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = __webpack_modules__;
+/******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/define property getters */
 /******/ 	(() => {
 /******/ 		// define getter functions for harmony exports
@@ -66,11 +112,91 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/ensure chunk */
+/******/ 	(() => {
+/******/ 		__webpack_require__.f = {};
+/******/ 		// This file contains only the entry chunk.
+/******/ 		// The chunk loading function for additional chunks
+/******/ 		__webpack_require__.e = (chunkId) => {
+/******/ 			return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
+/******/ 				__webpack_require__.f[key](chunkId, promises);
+/******/ 				return promises;
+/******/ 			}, []));
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/get javascript chunk filename */
+/******/ 	(() => {
+/******/ 		// This function allow to reference async chunks
+/******/ 		__webpack_require__.u = (chunkId) => {
+/******/ 			// return url for filenames based on template
+/******/ 			return "" + chunkId + ".js";
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	(() => {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/hasOwnProperty shorthand */
 /******/ 	(() => {
 /******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/load script */
+/******/ 	(() => {
+/******/ 		var inProgress = {};
+/******/ 		var dataWebpackPrefix = "@tsparticles/shape-image:";
+/******/ 		// loadScript function to load a script via script tag
+/******/ 		__webpack_require__.l = (url, done, key, chunkId) => {
+/******/ 			if(inProgress[url]) { inProgress[url].push(done); return; }
+/******/ 			var script, needAttach;
+/******/ 			if(key !== undefined) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				for(var i = 0; i < scripts.length; i++) {
+/******/ 					var s = scripts[i];
+/******/ 					if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
+/******/ 				}
+/******/ 			}
+/******/ 			if(!script) {
+/******/ 				needAttach = true;
+/******/ 				script = document.createElement('script');
+/******/ 		
+/******/ 				script.charset = 'utf-8';
+/******/ 				script.timeout = 120;
+/******/ 				if (__webpack_require__.nc) {
+/******/ 					script.setAttribute("nonce", __webpack_require__.nc);
+/******/ 				}
+/******/ 				script.setAttribute("data-webpack", dataWebpackPrefix + key);
+/******/ 		
+/******/ 				script.src = url;
+/******/ 			}
+/******/ 			inProgress[url] = [done];
+/******/ 			var onScriptComplete = (prev, event) => {
+/******/ 				// avoid mem leaks in IE.
+/******/ 				script.onerror = script.onload = null;
+/******/ 				clearTimeout(timeout);
+/******/ 				var doneFns = inProgress[url];
+/******/ 				delete inProgress[url];
+/******/ 				script.parentNode && script.parentNode.removeChild(script);
+/******/ 				doneFns && doneFns.forEach((fn) => (fn(event)));
+/******/ 				if(prev) return prev(event);
+/******/ 			}
+/******/ 			var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
+/******/ 			script.onerror = onScriptComplete.bind(null, script.onerror);
+/******/ 			script.onload = onScriptComplete.bind(null, script.onload);
+/******/ 			needAttach && document.head.appendChild(script);
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/make namespace object */
 /******/ 	(() => {
 /******/ 		// define __esModule on exports
@@ -82,913 +208,128 @@ module.exports = __WEBPACK_EXTERNAL_MODULE__533__;
 /******/ 		};
 /******/ 	})();
 /******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	(() => {
+/******/ 		var scriptUrl;
+/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
+/******/ 		var document = __webpack_require__.g.document;
+/******/ 		if (!scriptUrl && document) {
+/******/ 			if (document.currentScript)
+/******/ 				scriptUrl = document.currentScript.src;
+/******/ 			if (!scriptUrl) {
+/******/ 				var scripts = document.getElementsByTagName("script");
+/******/ 				if(scripts.length) {
+/******/ 					var i = scripts.length - 1;
+/******/ 					while (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;
+/******/ 				}
+/******/ 			}
+/******/ 		}
+/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
+/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
+/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
+/******/ 		scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
+/******/ 		__webpack_require__.p = scriptUrl;
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/jsonp chunk loading */
+/******/ 	(() => {
+/******/ 		// no baseURI
+/******/ 		
+/******/ 		// object to store loaded and loading chunks
+/******/ 		// undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ 		// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ 		var installedChunks = {
+/******/ 			"tsparticles.shape.image": 0
+/******/ 		};
+/******/ 		
+/******/ 		__webpack_require__.f.j = (chunkId, promises) => {
+/******/ 				// JSONP chunk loading for javascript
+/******/ 				var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
+/******/ 				if(installedChunkData !== 0) { // 0 means "already installed".
+/******/ 		
+/******/ 					// a Promise means "currently loading".
+/******/ 					if(installedChunkData) {
+/******/ 						promises.push(installedChunkData[2]);
+/******/ 					} else {
+/******/ 						if(true) { // all chunks have JS
+/******/ 							// setup Promise in chunk cache
+/******/ 							var promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));
+/******/ 							promises.push(installedChunkData[2] = promise);
+/******/ 		
+/******/ 							// start chunk loading
+/******/ 							var url = __webpack_require__.p + __webpack_require__.u(chunkId);
+/******/ 							// create error before stack unwound to get useful stacktrace later
+/******/ 							var error = new Error();
+/******/ 							var loadingEnded = (event) => {
+/******/ 								if(__webpack_require__.o(installedChunks, chunkId)) {
+/******/ 									installedChunkData = installedChunks[chunkId];
+/******/ 									if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
+/******/ 									if(installedChunkData) {
+/******/ 										var errorType = event && (event.type === 'load' ? 'missing' : event.type);
+/******/ 										var realSrc = event && event.target && event.target.src;
+/******/ 										error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
+/******/ 										error.name = 'ChunkLoadError';
+/******/ 										error.type = errorType;
+/******/ 										error.request = realSrc;
+/******/ 										installedChunkData[1](error);
+/******/ 									}
+/******/ 								}
+/******/ 							};
+/******/ 							__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
+/******/ 						}
+/******/ 					}
+/******/ 				}
+/******/ 		};
+/******/ 		
+/******/ 		// no prefetching
+/******/ 		
+/******/ 		// no preloaded
+/******/ 		
+/******/ 		// no HMR
+/******/ 		
+/******/ 		// no HMR manifest
+/******/ 		
+/******/ 		// no on chunks loaded
+/******/ 		
+/******/ 		// install a JSONP callback for chunk loading
+/******/ 		var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
+/******/ 			var chunkIds = data[0];
+/******/ 			var moreModules = data[1];
+/******/ 			var runtime = data[2];
+/******/ 			// add "moreModules" to the modules object,
+/******/ 			// then flag all "chunkIds" as loaded and fire callback
+/******/ 			var moduleId, chunkId, i = 0;
+/******/ 			if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
+/******/ 				for(moduleId in moreModules) {
+/******/ 					if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ 						__webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ 					}
+/******/ 				}
+/******/ 				if(runtime) var result = runtime(__webpack_require__);
+/******/ 			}
+/******/ 			if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+/******/ 			for(;i < chunkIds.length; i++) {
+/******/ 				chunkId = chunkIds[i];
+/******/ 				if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+/******/ 					installedChunks[chunkId][0]();
+/******/ 				}
+/******/ 				installedChunks[chunkId] = 0;
+/******/ 			}
+/******/ 		
+/******/ 		}
+/******/ 		
+/******/ 		var chunkLoadingGlobal = this["webpackChunk_tsparticles_shape_image"] = this["webpackChunk_tsparticles_shape_image"] || [];
+/******/ 		chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
+/******/ 		chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
+/******/ 	})();
+/******/ 	
 /************************************************************************/
-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__, {
-  loadImageShape: () => (/* binding */ loadImageShape)
-});
-
-// 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/GifUtils/Constants.js
-const InterlaceOffsets = [0, 4, 2, 1];
-const InterlaceSteps = [8, 8, 4, 2];
-;// CONCATENATED MODULE: ./dist/browser/GifUtils/ByteStream.js
-class ByteStream {
-  constructor(bytes) {
-    this.pos = 0;
-    this.data = new Uint8ClampedArray(bytes);
-  }
-  getString(count) {
-    const slice = this.data.slice(this.pos, this.pos + count);
-    this.pos += slice.length;
-    return slice.reduce((acc, curr) => acc + String.fromCharCode(curr), "");
-  }
-  nextByte() {
-    return this.data[this.pos++];
-  }
-  nextTwoBytes() {
-    const increment = 2,
-      previous = 1,
-      shift = 8;
-    this.pos += increment;
-    return this.data[this.pos - increment] + (this.data[this.pos - previous] << shift);
-  }
-  readSubBlocks() {
-    let blockString = "",
-      size = 0;
-    const minCount = 0,
-      emptySize = 0;
-    do {
-      size = this.data[this.pos++];
-      for (let count = size; --count >= minCount; blockString += String.fromCharCode(this.data[this.pos++])) {}
-    } while (size !== emptySize);
-    return blockString;
-  }
-  readSubBlocksBin() {
-    let size = 0,
-      len = 0;
-    const emptySize = 0,
-      increment = 1;
-    for (let offset = 0; size !== emptySize; offset += size + increment, size = this.data[this.pos + offset]) {
-      len += size;
-    }
-    const blockData = new Uint8Array(len);
-    for (let i = 0; size !== emptySize; size = this.data[this.pos++]) {
-      for (let count = size; --count >= emptySize; blockData[i++] = this.data[this.pos++]) {}
-    }
-    return blockData;
-  }
-  skipSubBlocks() {
-    for (const increment = 1, noData = 0; this.data[this.pos] !== noData; this.pos += this.data[this.pos] + increment) {}
-    this.pos++;
-  }
-}
-;// CONCATENATED MODULE: ./dist/browser/GifUtils/Utils.js
-
-
-function parseColorTable(byteStream, count) {
-  const colors = [];
-  for (let i = 0; i < count; i++) {
-    colors.push({
-      r: byteStream.data[byteStream.pos],
-      g: byteStream.data[byteStream.pos + 1],
-      b: byteStream.data[byteStream.pos + 2]
-    });
-    byteStream.pos += 3;
-  }
-  return colors;
-}
-function parseExtensionBlock(byteStream, gif, getFrameIndex, getTransparencyIndex) {
-  switch (byteStream.nextByte()) {
-    case 249:
-      {
-        const frame = gif.frames[getFrameIndex(false)];
-        byteStream.pos++;
-        const packedByte = byteStream.nextByte();
-        frame.GCreserved = (packedByte & 0xe0) >>> 5;
-        frame.disposalMethod = (packedByte & 0x1c) >>> 2;
-        frame.userInputDelayFlag = (packedByte & 2) === 2;
-        const transparencyFlag = (packedByte & 1) === 1;
-        frame.delayTime = byteStream.nextTwoBytes() * 0xa;
-        const transparencyIndex = byteStream.nextByte();
-        if (transparencyFlag) {
-          getTransparencyIndex(transparencyIndex);
-        }
-        byteStream.pos++;
-        break;
-      }
-    case 255:
-      {
-        byteStream.pos++;
-        const applicationExtension = {
-          identifier: byteStream.getString(8),
-          authenticationCode: byteStream.getString(3),
-          data: byteStream.readSubBlocksBin()
-        };
-        gif.applicationExtensions.push(applicationExtension);
-        break;
-      }
-    case 254:
-      {
-        gif.comments.push([getFrameIndex(false), byteStream.readSubBlocks()]);
-        break;
-      }
-    case 1:
-      {
-        if (gif.globalColorTable.length === 0) {
-          throw new EvalError("plain text extension without global color table");
-        }
-        byteStream.pos++;
-        gif.frames[getFrameIndex(false)].plainTextData = {
-          left: byteStream.nextTwoBytes(),
-          top: byteStream.nextTwoBytes(),
-          width: byteStream.nextTwoBytes(),
-          height: byteStream.nextTwoBytes(),
-          charSize: {
-            width: byteStream.nextTwoBytes(),
-            height: byteStream.nextTwoBytes()
-          },
-          foregroundColor: byteStream.nextByte(),
-          backgroundColor: byteStream.nextByte(),
-          text: byteStream.readSubBlocks()
-        };
-        break;
-      }
-    default:
-      byteStream.skipSubBlocks();
-      break;
-  }
-}
-async function parseImageBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex, progressCallback) {
-  const frame = gif.frames[getFrameIndex(true)];
-  frame.left = byteStream.nextTwoBytes();
-  frame.top = byteStream.nextTwoBytes();
-  frame.width = byteStream.nextTwoBytes();
-  frame.height = byteStream.nextTwoBytes();
-  const packedByte = byteStream.nextByte(),
-    localColorTableFlag = (packedByte & 0x80) === 0x80,
-    interlacedFlag = (packedByte & 0x40) === 0x40;
-  frame.sortFlag = (packedByte & 0x20) === 0x20;
-  frame.reserved = (packedByte & 0x18) >>> 3;
-  const localColorCount = 1 << (packedByte & 7) + 1;
-  if (localColorTableFlag) {
-    frame.localColorTable = parseColorTable(byteStream, localColorCount);
-  }
-  const getColor = index => {
-    const {
-      r,
-      g,
-      b
-    } = (localColorTableFlag ? frame.localColorTable : gif.globalColorTable)[index];
-    if (index !== getTransparencyIndex(null)) {
-      return {
-        r,
-        g,
-        b,
-        a: 255
-      };
-    }
-    return {
-      r,
-      g,
-      b,
-      a: avgAlpha ? ~~((r + g + b) / 3) : 0
-    };
-  };
-  const image = (() => {
-    try {
-      return new ImageData(frame.width, frame.height, {
-        colorSpace: "srgb"
-      });
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "IndexSizeError") {
-        return null;
-      }
-      throw error;
-    }
-  })();
-  if (image == null) {
-    throw new EvalError("GIF frame size is to large");
-  }
-  const minCodeSize = byteStream.nextByte(),
-    imageData = byteStream.readSubBlocksBin(),
-    clearCode = 1 << minCodeSize;
-  const readBits = (pos, len) => {
-    const bytePos = pos >>> 3,
-      bitPos = pos & 7;
-    return (imageData[bytePos] + (imageData[bytePos + 1] << 8) + (imageData[bytePos + 2] << 16) & (1 << len) - 1 << bitPos) >>> bitPos;
-  };
-  if (interlacedFlag) {
-    for (let code = 0, size = minCodeSize + 1, pos = 0, dic = [[0]], pass = 0; pass < 4; pass++) {
-      if (InterlaceOffsets[pass] < frame.height) {
-        let pixelPos = 0,
-          lineIndex = 0,
-          exit = false;
-        while (!exit) {
-          const last = code;
-          code = readBits(pos, size);
-          pos += size + 1;
-          if (code === clearCode) {
-            size = minCodeSize + 1;
-            dic.length = clearCode + 2;
-            for (let i = 0; i < dic.length; i++) {
-              dic[i] = i < clearCode ? [i] : [];
-            }
-          } else {
-            if (code >= dic.length) {
-              dic.push(dic[last].concat(dic[last][0]));
-            } else if (last !== clearCode) {
-              dic.push(dic[last].concat(dic[code][0]));
-            }
-            for (const item of dic[code]) {
-              const {
-                r,
-                g,
-                b,
-                a
-              } = getColor(item);
-              image.data.set([r, g, b, a], InterlaceOffsets[pass] * frame.width + InterlaceSteps[pass] * lineIndex + pixelPos % (frame.width * 4));
-              pixelPos += 4;
-            }
-            if (dic.length === 1 << size && size < 0xc) {
-              size++;
-            }
-          }
-          if (pixelPos === frame.width * 4 * (lineIndex + 1)) {
-            lineIndex++;
-            if (InterlaceOffsets[pass] + InterlaceSteps[pass] * lineIndex >= frame.height) {
-              exit = true;
-            }
-          }
-        }
-      }
-      progressCallback?.(byteStream.pos / (byteStream.data.length - 1), getFrameIndex(false) + 1, image, {
-        x: frame.left,
-        y: frame.top
-      }, {
-        width: gif.width,
-        height: gif.height
-      });
-    }
-    frame.image = image;
-    frame.bitmap = await createImageBitmap(image);
-  } else {
-    let code = 0,
-      size = minCodeSize + 1,
-      pos = 0,
-      pixelPos = -4,
-      exit = false;
-    const dic = [[0]];
-    while (!exit) {
-      const last = code;
-      code = readBits(pos, size);
-      pos += size;
-      if (code === clearCode) {
-        size = minCodeSize + 1;
-        dic.length = clearCode + 2;
-        for (let i = 0; i < dic.length; i++) {
-          dic[i] = i < clearCode ? [i] : [];
-        }
-      } else {
-        if (code === clearCode + 1) {
-          exit = true;
-          break;
-        }
-        if (code >= dic.length) {
-          dic.push(dic[last].concat(dic[last][0]));
-        } else if (last !== clearCode) {
-          dic.push(dic[last].concat(dic[code][0]));
-        }
-        for (const item of dic[code]) {
-          const {
-            r,
-            g,
-            b,
-            a
-          } = getColor(item);
-          image.data.set([r, g, b, a], pixelPos += 4);
-        }
-        if (dic.length >= 1 << size && size < 0xc) {
-          size++;
-        }
-      }
-    }
-    frame.image = image;
-    frame.bitmap = await createImageBitmap(image);
-    progressCallback?.((byteStream.pos + 1) / byteStream.data.length, getFrameIndex(false) + 1, frame.image, {
-      x: frame.left,
-      y: frame.top
-    }, {
-      width: gif.width,
-      height: gif.height
-    });
-  }
-}
-async function parseBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex, progressCallback) {
-  switch (byteStream.nextByte()) {
-    case 59:
-      return true;
-    case 44:
-      await parseImageBlock(byteStream, gif, avgAlpha, getFrameIndex, getTransparencyIndex, progressCallback);
-      break;
-    case 33:
-      parseExtensionBlock(byteStream, gif, getFrameIndex, getTransparencyIndex);
-      break;
-    default:
-      throw new EvalError("undefined block found");
-  }
-  return false;
-}
-function getGIFLoopAmount(gif) {
-  for (const extension of gif.applicationExtensions) {
-    if (extension.identifier + extension.authenticationCode !== "NETSCAPE2.0") {
-      continue;
-    }
-    return extension.data[1] + (extension.data[2] << 8);
-  }
-  return NaN;
-}
-async function decodeGIF(gifURL, progressCallback, avgAlpha) {
-  if (!avgAlpha) avgAlpha = false;
-  const res = await fetch(gifURL);
-  if (!res.ok && res.status === 404) {
-    throw new EvalError("file not found");
-  }
-  const buffer = await res.arrayBuffer();
-  const gif = {
-      width: 0,
-      height: 0,
-      totalTime: 0,
-      colorRes: 0,
-      pixelAspectRatio: 0,
-      frames: [],
-      sortFlag: false,
-      globalColorTable: [],
-      backgroundImage: new ImageData(1, 1, {
-        colorSpace: "srgb"
-      }),
-      comments: [],
-      applicationExtensions: []
-    },
-    byteStream = new ByteStream(new Uint8ClampedArray(buffer));
-  if (byteStream.getString(6) !== "GIF89a") {
-    throw new Error("not a supported GIF file");
-  }
-  gif.width = byteStream.nextTwoBytes();
-  gif.height = byteStream.nextTwoBytes();
-  const packedByte = byteStream.nextByte(),
-    globalColorTableFlag = (packedByte & 0x80) === 0x80;
-  gif.colorRes = (packedByte & 0x70) >>> 4;
-  gif.sortFlag = (packedByte & 8) === 8;
-  const globalColorCount = 1 << (packedByte & 7) + 1,
-    backgroundColorIndex = byteStream.nextByte();
-  gif.pixelAspectRatio = byteStream.nextByte();
-  if (gif.pixelAspectRatio !== 0) {
-    gif.pixelAspectRatio = (gif.pixelAspectRatio + 0xf) / 0x40;
-  }
-  if (globalColorTableFlag) {
-    gif.globalColorTable = parseColorTable(byteStream, globalColorCount);
-  }
-  const backgroundImage = (() => {
-    try {
-      return new ImageData(gif.width, gif.height, {
-        colorSpace: "srgb"
-      });
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "IndexSizeError") {
-        return null;
-      }
-      throw error;
-    }
-  })();
-  if (backgroundImage == null) {
-    throw new Error("GIF frame size is to large");
-  }
-  const {
-    r,
-    g,
-    b
-  } = gif.globalColorTable[backgroundColorIndex];
-  backgroundImage.data.set(globalColorTableFlag ? [r, g, b, 255] : [0, 0, 0, 0]);
-  for (let i = 4; i < backgroundImage.data.length; i *= 2) {
-    backgroundImage.data.copyWithin(i, 0, i);
-  }
-  gif.backgroundImage = backgroundImage;
-  let frameIndex = -1,
-    incrementFrameIndex = true,
-    transparencyIndex = -1;
-  const getframeIndex = increment => {
-    if (increment) {
-      incrementFrameIndex = true;
-    }
-    return frameIndex;
-  };
-  const getTransparencyIndex = newValue => {
-    if (newValue != null) {
-      transparencyIndex = newValue;
-    }
-    return transparencyIndex;
-  };
-  try {
-    do {
-      if (incrementFrameIndex) {
-        gif.frames.push({
-          left: 0,
-          top: 0,
-          width: 0,
-          height: 0,
-          disposalMethod: 0,
-          image: new ImageData(1, 1, {
-            colorSpace: "srgb"
-          }),
-          plainTextData: null,
-          userInputDelayFlag: false,
-          delayTime: 0,
-          sortFlag: false,
-          localColorTable: [],
-          reserved: 0,
-          GCreserved: 0
-        });
-        frameIndex++;
-        transparencyIndex = -1;
-        incrementFrameIndex = false;
-      }
-    } while (!(await parseBlock(byteStream, gif, avgAlpha, getframeIndex, getTransparencyIndex, progressCallback)));
-    gif.frames.length--;
-    for (const frame of gif.frames) {
-      if (frame.userInputDelayFlag && frame.delayTime === 0) {
-        gif.totalTime = Infinity;
-        break;
-      }
-      gif.totalTime += frame.delayTime;
-    }
-    return gif;
-  } catch (error) {
-    if (error instanceof EvalError) {
-      throw new Error(`error while parsing frame ${frameIndex} "${error.message}"`);
-    }
-    throw error;
-  }
-}
-;// CONCATENATED MODULE: ./dist/browser/Utils.js
-
-
-const stringStart = 0,
-  defaultLoopCount = 0,
-  defaultOpacity = 1;
-const currentColorRegex = /(#(?:[0-9a-f]{2}){2,4}|(#[0-9a-f]{3})|(rgb|hsl)a?\((-?\d+%?[,\s]+){2,3}\s*[\d.]+%?\))|currentcolor/gi;
-function replaceColorSvg(imageShape, color, opacity) {
-  const {
-    svgData
-  } = imageShape;
-  if (!svgData) {
-    return "";
-  }
-  const colorStyle = (0,engine_root_window_.getStyleFromHsl)(color, opacity);
-  if (svgData.includes("fill")) {
-    return svgData.replace(currentColorRegex, () => colorStyle);
-  }
-  const preFillIndex = svgData.indexOf(">");
-  return `${svgData.substring(stringStart, preFillIndex)} fill="${colorStyle}"${svgData.substring(preFillIndex)}`;
-}
-async function loadImage(image) {
-  return new Promise(resolve => {
-    image.loading = true;
-    const img = new Image();
-    image.element = img;
-    img.addEventListener("load", () => {
-      image.loading = false;
-      resolve();
-    });
-    img.addEventListener("error", () => {
-      image.element = undefined;
-      image.error = true;
-      image.loading = false;
-      (0,engine_root_window_.getLogger)().error(`${engine_root_window_.errorPrefix} loading image: ${image.source}`);
-      resolve();
-    });
-    img.src = image.source;
-  });
-}
-async function loadGifImage(image) {
-  if (image.type !== "gif") {
-    await loadImage(image);
-    return;
-  }
-  image.loading = true;
-  try {
-    image.gifData = await decodeGIF(image.source);
-    image.gifLoopCount = getGIFLoopAmount(image.gifData) ?? defaultLoopCount;
-    if (!image.gifLoopCount) {
-      image.gifLoopCount = Infinity;
-    }
-  } catch {
-    image.error = true;
-  }
-  image.loading = false;
-}
-async function downloadSvgImage(image) {
-  if (image.type !== "svg") {
-    await loadImage(image);
-    return;
-  }
-  image.loading = true;
-  const response = await fetch(image.source);
-  if (!response.ok) {
-    (0,engine_root_window_.getLogger)().error(`${engine_root_window_.errorPrefix} Image not found`);
-    image.error = true;
-  } else {
-    image.svgData = await response.text();
-  }
-  image.loading = false;
-}
-function replaceImageColor(image, imageData, color, particle) {
-  const svgColoredData = replaceColorSvg(image, color, particle.opacity?.value ?? defaultOpacity),
-    imageRes = {
-      color,
-      gif: imageData.gif,
-      data: {
-        ...image,
-        svgData: svgColoredData
-      },
-      loaded: false,
-      ratio: imageData.width / imageData.height,
-      replaceColor: imageData.replaceColor,
-      source: imageData.src
-    };
-  return new Promise(resolve => {
-    const svg = new Blob([svgColoredData], {
-        type: "image/svg+xml"
-      }),
-      domUrl = URL || window.URL || window.webkitURL || window,
-      url = domUrl.createObjectURL(svg),
-      img = new Image();
-    img.addEventListener("load", () => {
-      imageRes.loaded = true;
-      imageRes.element = img;
-      resolve(imageRes);
-      domUrl.revokeObjectURL(url);
-    });
-    const errorHandler = async () => {
-      domUrl.revokeObjectURL(url);
-      const img2 = {
-        ...image,
-        error: false,
-        loading: true
-      };
-      await loadImage(img2);
-      imageRes.loaded = true;
-      imageRes.element = img2.element;
-      resolve(imageRes);
-    };
-    img.addEventListener("error", () => void errorHandler());
-    img.src = url;
-  });
-}
-;// CONCATENATED MODULE: ./dist/browser/ImageDrawer.js
-
-
-const origin = {
-    x: 0,
-    y: 0
-  },
-  ImageDrawer_defaultLoopCount = 0,
-  defaultFrame = 0,
-  half = 0.5,
-  initialTime = 0,
-  firstIndex = 0,
-  ImageDrawer_double = 2,
-  defaultAlpha = 1,
-  sides = 12,
-  defaultRatio = 1;
-class ImageDrawer {
-  constructor(engine) {
-    this.loadImageShape = async imageShape => {
-      if (!this._engine.loadImage) {
-        throw new Error(`${engine_root_window_.errorPrefix} image shape not initialized`);
-      }
-      await this._engine.loadImage({
-        gif: imageShape.gif,
-        name: imageShape.name,
-        replaceColor: imageShape.replaceColor ?? false,
-        src: imageShape.src
-      });
-    };
-    this._engine = engine;
-  }
-  addImage(image) {
-    if (!this._engine.images) {
-      this._engine.images = [];
-    }
-    this._engine.images.push(image);
-  }
-  draw(data) {
-    const {
-        context,
-        radius,
-        particle,
-        opacity,
-        delta
-      } = data,
-      image = particle.image,
-      element = image?.element;
-    if (!image) {
-      return;
-    }
-    context.globalAlpha = opacity;
-    if (image.gif && image.gifData) {
-      const offscreenCanvas = new OffscreenCanvas(image.gifData.width, image.gifData.height),
-        offscreenContext = offscreenCanvas.getContext("2d");
-      if (!offscreenContext) {
-        throw new Error("could not create offscreen canvas context");
-      }
-      offscreenContext.imageSmoothingQuality = "low";
-      offscreenContext.imageSmoothingEnabled = false;
-      offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-      if (particle.gifLoopCount === undefined) {
-        particle.gifLoopCount = image.gifLoopCount ?? ImageDrawer_defaultLoopCount;
-      }
-      let frameIndex = particle.gifFrame ?? defaultFrame;
-      const pos = {
-          x: -image.gifData.width * half,
-          y: -image.gifData.height * half
-        },
-        frame = image.gifData.frames[frameIndex];
-      if (particle.gifTime === undefined) {
-        particle.gifTime = initialTime;
-      }
-      if (!frame.bitmap) {
-        return;
-      }
-      context.scale(radius / image.gifData.width, radius / image.gifData.height);
-      switch (frame.disposalMethod) {
-        case 4:
-        case 5:
-        case 6:
-        case 7:
-        case 0:
-          offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
-          context.drawImage(offscreenCanvas, pos.x, pos.y);
-          offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-          break;
-        case 1:
-          offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
-          context.drawImage(offscreenCanvas, pos.x, pos.y);
-          break;
-        case 2:
-          offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
-          context.drawImage(offscreenCanvas, pos.x, pos.y);
-          offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-          if (!image.gifData.globalColorTable.length) {
-            offscreenContext.putImageData(image.gifData.frames[firstIndex].image, pos.x + frame.left, pos.y + frame.top);
-          } else {
-            offscreenContext.putImageData(image.gifData.backgroundImage, pos.x, pos.y);
-          }
-          break;
-        case 3:
-          {
-            const previousImageData = offscreenContext.getImageData(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-            offscreenContext.drawImage(frame.bitmap, frame.left, frame.top);
-            context.drawImage(offscreenCanvas, pos.x, pos.y);
-            offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-            offscreenContext.putImageData(previousImageData, origin.x, origin.y);
-          }
-          break;
-      }
-      particle.gifTime += delta.value;
-      if (particle.gifTime > frame.delayTime) {
-        particle.gifTime -= frame.delayTime;
-        if (++frameIndex >= image.gifData.frames.length) {
-          if (--particle.gifLoopCount <= ImageDrawer_defaultLoopCount) {
-            return;
-          }
-          frameIndex = firstIndex;
-          offscreenContext.clearRect(origin.x, origin.y, offscreenCanvas.width, offscreenCanvas.height);
-        }
-        particle.gifFrame = frameIndex;
-      }
-      context.scale(image.gifData.width / radius, image.gifData.height / radius);
-    } else if (element) {
-      const ratio = image.ratio,
-        pos = {
-          x: -radius,
-          y: -radius
-        },
-        diameter = radius * ImageDrawer_double;
-      context.drawImage(element, pos.x, pos.y, diameter, diameter / ratio);
-    }
-    context.globalAlpha = defaultAlpha;
-  }
-  getSidesCount() {
-    return sides;
-  }
-  async init(container) {
-    const options = container.actualOptions;
-    if (!options.preload || !this._engine.loadImage) {
-      return;
-    }
-    for (const imageData of options.preload) {
-      await this._engine.loadImage(imageData);
-    }
-  }
-  loadShape(particle) {
-    if (particle.shape !== "image" && particle.shape !== "images") {
-      return;
-    }
-    if (!this._engine.images) {
-      this._engine.images = [];
-    }
-    const imageData = particle.shapeData;
-    if (!imageData) {
-      return;
-    }
-    const image = this._engine.images.find(t => t.name === imageData.name || t.source === imageData.src);
-    if (!image) {
-      void this.loadImageShape(imageData).then(() => {
-        this.loadShape(particle);
-      });
-    }
-  }
-  particleInit(container, particle) {
-    if (particle.shape !== "image" && particle.shape !== "images") {
-      return;
-    }
-    if (!this._engine.images) {
-      this._engine.images = [];
-    }
-    const images = this._engine.images,
-      imageData = particle.shapeData;
-    if (!imageData) {
-      return;
-    }
-    const color = particle.getFillColor(),
-      image = images.find(t => t.name === imageData.name || t.source === imageData.src);
-    if (!image) {
-      return;
-    }
-    const replaceColor = imageData.replaceColor ?? image.replaceColor;
-    if (image.loading) {
-      setTimeout(() => {
-        this.particleInit(container, particle);
-      });
-      return;
-    }
-    void (async () => {
-      let imageRes;
-      if (image.svgData && color) {
-        imageRes = await replaceImageColor(image, imageData, color, particle);
-      } else {
-        imageRes = {
-          color,
-          data: image,
-          element: image.element,
-          gif: image.gif,
-          gifData: image.gifData,
-          gifLoopCount: image.gifLoopCount,
-          loaded: true,
-          ratio: imageData.width && imageData.height ? imageData.width / imageData.height : image.ratio ?? defaultRatio,
-          replaceColor: replaceColor,
-          source: imageData.src
-        };
-      }
-      if (!imageRes.ratio) {
-        imageRes.ratio = 1;
-      }
-      const fill = imageData.fill ?? particle.shapeFill,
-        close = imageData.close ?? particle.shapeClose,
-        imageShape = {
-          image: imageRes,
-          fill,
-          close
-        };
-      particle.image = imageShape.image;
-      particle.shapeFill = imageShape.fill;
-      particle.shapeClose = imageShape.close;
-    })();
-  }
-}
-;// CONCATENATED MODULE: ./dist/browser/Options/Classes/Preload.js
-class Preload {
-  constructor() {
-    this.src = "";
-    this.gif = false;
-  }
-  load(data) {
-    if (!data) {
-      return;
-    }
-    if (data.gif !== undefined) {
-      this.gif = data.gif;
-    }
-    if (data.height !== undefined) {
-      this.height = data.height;
-    }
-    if (data.name !== undefined) {
-      this.name = data.name;
-    }
-    if (data.replaceColor !== undefined) {
-      this.replaceColor = data.replaceColor;
-    }
-    if (data.src !== undefined) {
-      this.src = data.src;
-    }
-    if (data.width !== undefined) {
-      this.width = data.width;
-    }
-  }
-}
-;// CONCATENATED MODULE: ./dist/browser/ImagePreloader.js
-
-class ImagePreloaderPlugin {
-  constructor(engine) {
-    this.id = "imagePreloader";
-    this._engine = engine;
-  }
-  getPlugin() {
-    return {};
-  }
-  loadOptions(options, source) {
-    if (!source?.preload) {
-      return;
-    }
-    if (!options.preload) {
-      options.preload = [];
-    }
-    const preloadOptions = options.preload;
-    for (const item of source.preload) {
-      const existing = preloadOptions.find(t => t.name === item.name || t.src === item.src);
-      if (existing) {
-        existing.load(item);
-      } else {
-        const preload = new Preload();
-        preload.load(item);
-        preloadOptions.push(preload);
-      }
-    }
-  }
-  needsPlugin() {
-    return true;
-  }
-}
-;// CONCATENATED MODULE: ./dist/browser/index.js
-
-
-
-
-const extLength = 3;
-function addLoadImageToEngine(engine) {
-  if (engine.loadImage) {
-    return;
-  }
-  engine.loadImage = async data => {
-    if (!data.name && !data.src) {
-      throw new Error(`${engine_root_window_.errorPrefix} no image source provided`);
-    }
-    if (!engine.images) {
-      engine.images = [];
-    }
-    if (engine.images.find(t => t.name === data.name || t.source === data.src)) {
-      return;
-    }
-    try {
-      const image = {
-        gif: data.gif ?? false,
-        name: data.name ?? data.src,
-        source: data.src,
-        type: data.src.substring(data.src.length - extLength),
-        error: false,
-        loading: true,
-        replaceColor: data.replaceColor,
-        ratio: data.width && data.height ? data.width / data.height : undefined
-      };
-      engine.images.push(image);
-      let imageFunc;
-      if (data.gif) {
-        imageFunc = loadGifImage;
-      } else {
-        imageFunc = data.replaceColor ? downloadSvgImage : loadImage;
-      }
-      await imageFunc(image);
-    } catch {
-      throw new Error(`${engine_root_window_.errorPrefix} ${data.name ?? data.src} not found`);
-    }
-  };
-}
-async function loadImageShape(engine, refresh = true) {
-  addLoadImageToEngine(engine);
-  const preloader = new ImagePreloaderPlugin(engine);
-  await engine.addPlugin(preloader, refresh);
-  await engine.addShape(["image", "images"], new ImageDrawer(engine), refresh);
-}
-})();
-
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module can't be inlined because the eval devtool is used.
+/******/ 	var __webpack_exports__ = __webpack_require__("./dist/browser/index.js");
+/******/ 	
 /******/ 	return __webpack_exports__;
 /******/ })()
 ;