[Web] Rename JavaScript platform to Web.

Also rename export name from "HTML5" to "Web".

4 files changed, 0 insertions, 776 deletions

diff --git a/platform/javascript/js/engine/config.js b/platform/javascript/js/engine/config.js
deleted file mode 100644
index 9c4b6c2012..0000000000
--- a/platform/javascript/js/engine/config.js
+++ /dev/null
@@ -1,358 +0,0 @@
-/**
- * An object used to configure the Engine instance based on godot export options, and to override those in custom HTML
- * templates if needed.
- *
- * @header Engine configuration
- * @summary The Engine configuration object. This is just a typedef, create it like a regular object, e.g.:
- *
- * ``const MyConfig = { executable: 'godot', unloadAfterInit: false }``
- *
- * @typedef {Object} EngineConfig
- */
-const EngineConfig = {}; // eslint-disable-line no-unused-vars
-
-/**
- * @struct
- * @constructor
- * @ignore
- */
-const InternalConfig = function (initConfig) { // eslint-disable-line no-unused-vars
-	const cfg = /** @lends {InternalConfig.prototype} */ {
-		/**
-		 * Whether the unload the engine automatically after the instance is initialized.
-		 *
-		 * @memberof EngineConfig
-		 * @default
-		 * @type {boolean}
-		 */
-		unloadAfterInit: true,
-		/**
-		 * The HTML DOM Canvas object to use.
-		 *
-		 * By default, the first canvas element in the document will be used is none is specified.
-		 *
-		 * @memberof EngineConfig
-		 * @default
-		 * @type {?HTMLCanvasElement}
-		 */
-		canvas: null,
-		/**
-		 * The name of the WASM file without the extension. (Set by Godot Editor export process).
-		 *
-		 * @memberof EngineConfig
-		 * @default
-		 * @type {string}
-		 */
-		executable: '',
-		/**
-		 * An alternative name for the game pck to load. The executable name is used otherwise.
-		 *
-		 * @memberof EngineConfig
-		 * @default
-		 * @type {?string}
-		 */
-		mainPack: null,
-		/**
-		 * Specify a language code to select the proper localization for the game.
-		 *
-		 * The browser locale will be used if none is specified. See complete list of
-		 * :ref:`supported locales <doc_locales>`.
-		 *
-		 * @memberof EngineConfig
-		 * @type {?string}
-		 * @default
-		 */
-		locale: null,
-		/**
-		 * The canvas resize policy determines how the canvas should be resized by Godot.
-		 *
-		 * ``0`` means Godot won't do any resizing. This is useful if you want to control the canvas size from
-		 * javascript code in your template.
-		 *
-		 * ``1`` means Godot will resize the canvas on start, and when changing window size via engine functions.
-		 *
-		 * ``2`` means Godot will adapt the canvas size to match the whole browser window.
-		 *
-		 * @memberof EngineConfig
-		 * @type {number}
-		 * @default
-		 */
-		canvasResizePolicy: 2,
-		/**
-		 * The arguments to be passed as command line arguments on startup.
-		 *
-		 * See :ref:`command line tutorial <doc_command_line_tutorial>`.
-		 *
-		 * **Note**: :js:meth:`startGame <Engine.prototype.startGame>` will always add the ``--main-pack`` argument.
-		 *
-		 * @memberof EngineConfig
-		 * @type {Array<string>}
-		 * @default
-		 */
-		args: [],
-		/**
-		 * When enabled, the game canvas will automatically grab the focus when the engine starts.
-		 *
-		 * @memberof EngineConfig
-		 * @type {boolean}
-		 * @default
-		 */
-		focusCanvas: true,
-		/**
-		 * When enabled, this will turn on experimental virtual keyboard support on mobile.
-		 *
-		 * @memberof EngineConfig
-		 * @type {boolean}
-		 * @default
-		 */
-		experimentalVK: false,
-		/**
-		 * The progressive web app service worker to install.
-		 * @memberof EngineConfig
-		 * @default
-		 * @type {string}
-		 */
-		serviceWorker: '',
-		/**
-		 * @ignore
-		 * @type {Array.<string>}
-		 */
-		persistentPaths: ['/userfs'],
-		/**
-		 * @ignore
-		 * @type {boolean}
-		 */
-		persistentDrops: false,
-		/**
-		 * @ignore
-		 * @type {Array.<string>}
-		 */
-		gdnativeLibs: [],
-		/**
-		 * @ignore
-		 * @type {Array.<string>}
-		 */
-		fileSizes: [],
-		/**
-		 * A callback function for handling Godot's ``OS.execute`` calls.
-		 *
-		 * This is for example used in the Web Editor template to switch between project manager and editor, and for running the game.
-		 *
-		 * @callback EngineConfig.onExecute
-		 * @param {string} path The path that Godot's wants executed.
-		 * @param {Array.<string>} args The arguments of the "command" to execute.
-		 */
-		/**
-		 * @ignore
-		 * @type {?function(string, Array.<string>)}
-		 */
-		onExecute: null,
-		/**
-		 * A callback function for being notified when the Godot instance quits.
-		 *
-		 * **Note**: This function will not be called if the engine crashes or become unresponsive.
-		 *
-		 * @callback EngineConfig.onExit
-		 * @param {number} status_code The status code returned by Godot on exit.
-		 */
-		/**
-		 * @ignore
-		 * @type {?function(number)}
-		 */
-		onExit: null,
-		/**
-		 * A callback function for displaying download progress.
-		 *
-		 * The function is called once per frame while downloading files, so the usage of ``requestAnimationFrame()``
-		 * is not necessary.
-		 *
-		 * If the callback function receives a total amount of bytes as 0, this means that it is impossible to calculate.
-		 * Possible reasons include:
-		 *
-		 * -  Files are delivered with server-side chunked compression
-		 * -  Files are delivered with server-side compression on Chromium
-		 * -  Not all file downloads have started yet (usually on servers without multi-threading)
-		 *
-		 * @callback EngineConfig.onProgress
-		 * @param {number} current The current amount of downloaded bytes so far.
-		 * @param {number} total The total amount of bytes to be downloaded.
-		 */
-		/**
-		 * @ignore
-		 * @type {?function(number, number)}
-		 */
-		onProgress: null,
-		/**
-		 * A callback function for handling the standard output stream. This method should usually only be used in debug pages.
-		 *
-		 * By default, ``console.log()`` is used.
-		 *
-		 * @callback EngineConfig.onPrint
-		 * @param {...*} [var_args] A variadic number of arguments to be printed.
-		 */
-		/**
-		 * @ignore
-		 * @type {?function(...*)}
-		 */
-		onPrint: function () {
-			console.log.apply(console, Array.from(arguments)); // eslint-disable-line no-console
-		},
-		/**
-		 * A callback function for handling the standard error stream. This method should usually only be used in debug pages.
-		 *
-		 * By default, ``console.error()`` is used.
-		 *
-		 * @callback EngineConfig.onPrintError
-		 * @param {...*} [var_args] A variadic number of arguments to be printed as errors.
-		*/
-		/**
-		 * @ignore
-		 * @type {?function(...*)}
-		 */
-		onPrintError: function (var_args) {
-			console.error.apply(console, Array.from(arguments)); // eslint-disable-line no-console
-		},
-	};
-
-	/**
-	 * @ignore
-	 * @struct
-	 * @constructor
-	 * @param {EngineConfig} opts
-	 */
-	function Config(opts) {
-		this.update(opts);
-	}
-
-	Config.prototype = cfg;
-
-	/**
-	 * @ignore
-	 * @param {EngineConfig} opts
-	 */
-	Config.prototype.update = function (opts) {
-		const config = opts || {};
-		// NOTE: We must explicitly pass the default, accessing it via
-		// the key will fail due to closure compiler renames.
-		function parse(key, def) {
-			if (typeof (config[key]) === 'undefined') {
-				return def;
-			}
-			return config[key];
-		}
-		// Module config
-		this.unloadAfterInit = parse('unloadAfterInit', this.unloadAfterInit);
-		this.onPrintError = parse('onPrintError', this.onPrintError);
-		this.onPrint = parse('onPrint', this.onPrint);
-		this.onProgress = parse('onProgress', this.onProgress);
-
-		// Godot config
-		this.canvas = parse('canvas', this.canvas);
-		this.executable = parse('executable', this.executable);
-		this.mainPack = parse('mainPack', this.mainPack);
-		this.locale = parse('locale', this.locale);
-		this.canvasResizePolicy = parse('canvasResizePolicy', this.canvasResizePolicy);
-		this.persistentPaths = parse('persistentPaths', this.persistentPaths);
-		this.persistentDrops = parse('persistentDrops', this.persistentDrops);
-		this.experimentalVK = parse('experimentalVK', this.experimentalVK);
-		this.focusCanvas = parse('focusCanvas', this.focusCanvas);
-		this.serviceWorker = parse('serviceWorker', this.serviceWorker);
-		this.gdnativeLibs = parse('gdnativeLibs', this.gdnativeLibs);
-		this.fileSizes = parse('fileSizes', this.fileSizes);
-		this.args = parse('args', this.args);
-		this.onExecute = parse('onExecute', this.onExecute);
-		this.onExit = parse('onExit', this.onExit);
-	};
-
-	/**
-	 * @ignore
-	 * @param {string} loadPath
-	 * @param {Response} response
-	 */
-	Config.prototype.getModuleConfig = function (loadPath, response) {
-		let r = response;
-		return {
-			'print': this.onPrint,
-			'printErr': this.onPrintError,
-			'thisProgram': this.executable,
-			'noExitRuntime': true,
-			'dynamicLibraries': [`${loadPath}.side.wasm`],
-			'instantiateWasm': function (imports, onSuccess) {
-				function done(result) {
-					onSuccess(result['instance'], result['module']);
-				}
-				if (typeof (WebAssembly.instantiateStreaming) !== 'undefined') {
-					WebAssembly.instantiateStreaming(Promise.resolve(r), imports).then(done);
-				} else {
-					r.arrayBuffer().then(function (buffer) {
-						WebAssembly.instantiate(buffer, imports).then(done);
-					});
-				}
-				r = null;
-				return {};
-			},
-			'locateFile': function (path) {
-				if (path.endsWith('.worker.js')) {
-					return `${loadPath}.worker.js`;
-				} else if (path.endsWith('.audio.worklet.js')) {
-					return `${loadPath}.audio.worklet.js`;
-				} else if (path.endsWith('.js')) {
-					return `${loadPath}.js`;
-				} else if (path.endsWith('.side.wasm')) {
-					return `${loadPath}.side.wasm`;
-				} else if (path.endsWith('.wasm')) {
-					return `${loadPath}.wasm`;
-				}
-				return path;
-			},
-		};
-	};
-
-	/**
-	 * @ignore
-	 * @param {function()} cleanup
-	 */
-	Config.prototype.getGodotConfig = function (cleanup) {
-		// Try to find a canvas
-		if (!(this.canvas instanceof HTMLCanvasElement)) {
-			const nodes = document.getElementsByTagName('canvas');
-			if (nodes.length && nodes[0] instanceof HTMLCanvasElement) {
-				this.canvas = nodes[0];
-			}
-			if (!this.canvas) {
-				throw new Error('No canvas found in page');
-			}
-		}
-		// Canvas can grab focus on click, or key events won't work.
-		if (this.canvas.tabIndex < 0) {
-			this.canvas.tabIndex = 0;
-		}
-
-		// Browser locale, or custom one if defined.
-		let locale = this.locale;
-		if (!locale) {
-			locale = navigator.languages ? navigator.languages[0] : navigator.language;
-			locale = locale.split('.')[0];
-		}
-		locale = locale.replace('-', '_');
-		const onExit = this.onExit;
-
-		// Godot configuration.
-		return {
-			'canvas': this.canvas,
-			'canvasResizePolicy': this.canvasResizePolicy,
-			'locale': locale,
-			'persistentDrops': this.persistentDrops,
-			'virtualKeyboard': this.experimentalVK,
-			'focusCanvas': this.focusCanvas,
-			'onExecute': this.onExecute,
-			'onExit': function (p_code) {
-				cleanup(); // We always need to call the cleanup callback to free memory.
-				if (typeof (onExit) === 'function') {
-					onExit(p_code);
-				}
-			},
-		};
-	};
-	return new Config(initConfig);
-};
diff --git a/platform/javascript/js/engine/engine.externs.js b/platform/javascript/js/engine/engine.externs.js
deleted file mode 100644
index 35a66a93ae..0000000000
--- a/platform/javascript/js/engine/engine.externs.js
+++ /dev/null
@@ -1,4 +0,0 @@
-var Godot;
-var WebAssembly = {};
-WebAssembly.instantiate = function(buffer, imports) {};
-WebAssembly.instantiateStreaming = function(response, imports) {};
diff --git a/platform/javascript/js/engine/engine.js b/platform/javascript/js/engine/engine.js
deleted file mode 100644
index d2ba595083..0000000000
--- a/platform/javascript/js/engine/engine.js
+++ /dev/null
@@ -1,281 +0,0 @@
-/**
- * Projects exported for the Web expose the :js:class:`Engine` class to the JavaScript environment, that allows
- * fine control over the engine's start-up process.
- *
- * This API is built in an asynchronous manner and requires basic understanding
- * of `Promises <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises>`__.
- *
- * @module Engine
- * @header HTML5 shell class reference
- */
-const Engine = (function () {
-	const preloader = new Preloader();
-
-	let loadPromise = null;
-	let loadPath = '';
-	let initPromise = null;
-
-	/**
-	 * @classdesc The ``Engine`` class provides methods for loading and starting exported projects on the Web. For default export
-	 * settings, this is already part of the exported HTML page. To understand practical use of the ``Engine`` class,
-	 * see :ref:`Custom HTML page for Web export <doc_customizing_html5_shell>`.
-	 *
-	 * @description Create a new Engine instance with the given configuration.
-	 *
-	 * @global
-	 * @constructor
-	 * @param {EngineConfig} initConfig The initial config for this instance.
-	 */
-	function Engine(initConfig) { // eslint-disable-line no-shadow
-		this.config = new InternalConfig(initConfig);
-		this.rtenv = null;
-	}
-
-	/**
-	 * Load the engine from the specified base path.
-	 *
-	 * @param {string} basePath Base path of the engine to load.
-	 * @param {number=} [size=0] The file size if known.
-	 * @returns {Promise} A Promise that resolves once the engine is loaded.
-	 *
-	 * @function Engine.load
-	 */
-	Engine.load = function (basePath, size) {
-		if (loadPromise == null) {
-			loadPath = basePath;
-			loadPromise = preloader.loadPromise(`${loadPath}.wasm`, size, true);
-			requestAnimationFrame(preloader.animateProgress);
-		}
-		return loadPromise;
-	};
-
-	/**
-	 * Unload the engine to free memory.
-	 *
-	 * This method will be called automatically depending on the configuration. See :js:attr:`unloadAfterInit`.
-	 *
-	 * @function Engine.unload
-	 */
-	Engine.unload = function () {
-		loadPromise = null;
-	};
-
-	/**
-	 * Check whether WebGL is available. Optionally, specify a particular version of WebGL to check for.
-	 *
-	 * @param {number=} [majorVersion=1] The major WebGL version to check for.
-	 * @returns {boolean} If the given major version of WebGL is available.
-	 * @function Engine.isWebGLAvailable
-	 */
-	Engine.isWebGLAvailable = function (majorVersion = 1) {
-		try {
-			return !!document.createElement('canvas').getContext(['webgl', 'webgl2'][majorVersion - 1]);
-		} catch (e) { /* Not available */ }
-		return false;
-	};
-
-	/**
-	 * Safe Engine constructor, creates a new prototype for every new instance to avoid prototype pollution.
-	 * @ignore
-	 * @constructor
-	 */
-	function SafeEngine(initConfig) {
-		const proto = /** @lends Engine.prototype */ {
-			/**
-			 * Initialize the engine instance. Optionally, pass the base path to the engine to load it,
-			 * if it hasn't been loaded yet. See :js:meth:`Engine.load`.
-			 *
-			 * @param {string=} basePath Base path of the engine to load.
-			 * @return {Promise} A ``Promise`` that resolves once the engine is loaded and initialized.
-			 */
-			init: function (basePath) {
-				if (initPromise) {
-					return initPromise;
-				}
-				if (loadPromise == null) {
-					if (!basePath) {
-						initPromise = Promise.reject(new Error('A base path must be provided when calling `init` and the engine is not loaded.'));
-						return initPromise;
-					}
-					Engine.load(basePath, this.config.fileSizes[`${basePath}.wasm`]);
-				}
-				const me = this;
-				function doInit(promise) {
-					// Care! Promise chaining is bogus with old emscripten versions.
-					// This caused a regression with the Mono build (which uses an older emscripten version).
-					// Make sure to test that when refactoring.
-					return new Promise(function (resolve, reject) {
-						promise.then(function (response) {
-							const cloned = new Response(response.clone().body, { 'headers': [['content-type', 'application/wasm']] });
-							Godot(me.config.getModuleConfig(loadPath, cloned)).then(function (module) {
-								const paths = me.config.persistentPaths;
-								module['initFS'](paths).then(function (err) {
-									me.rtenv = module;
-									if (me.config.unloadAfterInit) {
-										Engine.unload();
-									}
-									resolve();
-								});
-							});
-						});
-					});
-				}
-				preloader.setProgressFunc(this.config.onProgress);
-				initPromise = doInit(loadPromise);
-				return initPromise;
-			},
-
-			/**
-			 * Load a file so it is available in the instance's file system once it runs. Must be called **before** starting the
-			 * instance.
-			 *
-			 * If not provided, the ``path`` is derived from the URL of the loaded file.
-			 *
-			 * @param {string|ArrayBuffer} file The file to preload.
-			 *
-			 * If a ``string`` the file will be loaded from that path.
-			 *
-			 * If an ``ArrayBuffer`` or a view on one, the buffer will used as the content of the file.
-			 *
-			 * @param {string=} path Path by which the file will be accessible. Required, if ``file`` is not a string.
-			 *
-			 * @returns {Promise} A Promise that resolves once the file is loaded.
-			 */
-			preloadFile: function (file, path) {
-				return preloader.preload(file, path, this.config.fileSizes[file]);
-			},
-
-			/**
-			 * Start the engine instance using the given override configuration (if any).
-			 * :js:meth:`startGame <Engine.prototype.startGame>` can be used in typical cases instead.
-			 *
-			 * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`.
-			 * The engine must be loaded beforehand.
-			 *
-			 * Fails if a canvas cannot be found on the page, or not specified in the configuration.
-			 *
-			 * @param {EngineConfig} override An optional configuration override.
-			 * @return {Promise} Promise that resolves once the engine started.
-			 */
-			start: function (override) {
-				this.config.update(override);
-				const me = this;
-				return me.init().then(function () {
-					if (!me.rtenv) {
-						return Promise.reject(new Error('The engine must be initialized before it can be started'));
-					}
-
-					let config = {};
-					try {
-						config = me.config.getGodotConfig(function () {
-							me.rtenv = null;
-						});
-					} catch (e) {
-						return Promise.reject(e);
-					}
-					// Godot configuration.
-					me.rtenv['initConfig'](config);
-
-					// Preload GDNative libraries.
-					const libs = [];
-					me.config.gdnativeLibs.forEach(function (lib) {
-						libs.push(me.rtenv['loadDynamicLibrary'](lib, { 'loadAsync': true }));
-					});
-					return Promise.all(libs).then(function () {
-						return new Promise(function (resolve, reject) {
-							preloader.preloadedFiles.forEach(function (file) {
-								me.rtenv['copyToFS'](file.path, file.buffer);
-							});
-							preloader.preloadedFiles.length = 0; // Clear memory
-							me.rtenv['callMain'](me.config.args);
-							initPromise = null;
-							if (me.config.serviceWorker && 'serviceWorker' in navigator) {
-								navigator.serviceWorker.register(me.config.serviceWorker);
-							}
-							resolve();
-						});
-					});
-				});
-			},
-
-			/**
-			 * Start the game instance using the given configuration override (if any).
-			 *
-			 * This will initialize the instance if it is not initialized. For manual initialization, see :js:meth:`init <Engine.prototype.init>`.
-			 *
-			 * This will load the engine if it is not loaded, and preload the main pck.
-			 *
-			 * This method expects the initial config (or the override) to have both the :js:attr:`executable` and :js:attr:`mainPack`
-			 * properties set (normally done by the editor during export).
-			 *
-			 * @param {EngineConfig} override An optional configuration override.
-			 * @return {Promise} Promise that resolves once the game started.
-			 */
-			startGame: function (override) {
-				this.config.update(override);
-				// Add main-pack argument.
-				const exe = this.config.executable;
-				const pack = this.config.mainPack || `${exe}.pck`;
-				this.config.args = ['--main-pack', pack].concat(this.config.args);
-				// Start and init with execName as loadPath if not inited.
-				const me = this;
-				return Promise.all([
-					this.init(exe),
-					this.preloadFile(pack, pack),
-				]).then(function () {
-					return me.start.apply(me);
-				});
-			},
-
-			/**
-			 * Create a file at the specified ``path`` with the passed as ``buffer`` in the instance's file system.
-			 *
-			 * @param {string} path The location where the file will be created.
-			 * @param {ArrayBuffer} buffer The content of the file.
-			 */
-			copyToFS: function (path, buffer) {
-				if (this.rtenv == null) {
-					throw new Error('Engine must be inited before copying files');
-				}
-				this.rtenv['copyToFS'](path, buffer);
-			},
-
-			/**
-			 * Request that the current instance quit.
-			 *
-			 * This is akin the user pressing the close button in the window manager, and will
-			 * have no effect if the engine has crashed, or is stuck in a loop.
-			 *
-			 */
-			requestQuit: function () {
-				if (this.rtenv) {
-					this.rtenv['request_quit']();
-				}
-			},
-		};
-
-		Engine.prototype = proto;
-		// Closure compiler exported instance methods.
-		Engine.prototype['init'] = Engine.prototype.init;
-		Engine.prototype['preloadFile'] = Engine.prototype.preloadFile;
-		Engine.prototype['start'] = Engine.prototype.start;
-		Engine.prototype['startGame'] = Engine.prototype.startGame;
-		Engine.prototype['copyToFS'] = Engine.prototype.copyToFS;
-		Engine.prototype['requestQuit'] = Engine.prototype.requestQuit;
-		// Also expose static methods as instance methods
-		Engine.prototype['load'] = Engine.load;
-		Engine.prototype['unload'] = Engine.unload;
-		Engine.prototype['isWebGLAvailable'] = Engine.isWebGLAvailable;
-		return new Engine(initConfig);
-	}
-
-	// Closure compiler exported static methods.
-	SafeEngine['load'] = Engine.load;
-	SafeEngine['unload'] = Engine.unload;
-	SafeEngine['isWebGLAvailable'] = Engine.isWebGLAvailable;
-
-	return SafeEngine;
-}());
-if (typeof window !== 'undefined') {
-	window['Engine'] = Engine;
-}
diff --git a/platform/javascript/js/engine/preloader.js b/platform/javascript/js/engine/preloader.js
deleted file mode 100644
index 564c68d264..0000000000
--- a/platform/javascript/js/engine/preloader.js
+++ /dev/null
@@ -1,133 +0,0 @@
-const Preloader = /** @constructor */ function () { // eslint-disable-line no-unused-vars
-	function getTrackedResponse(response, load_status) {
-		function onloadprogress(reader, controller) {
-			return reader.read().then(function (result) {
-				if (load_status.done) {
-					return Promise.resolve();
-				}
-				if (result.value) {
-					controller.enqueue(result.value);
-					load_status.loaded += result.value.length;
-				}
-				if (!result.done) {
-					return onloadprogress(reader, controller);
-				}
-				load_status.done = true;
-				return Promise.resolve();
-			});
-		}
-		const reader = response.body.getReader();
-		return new Response(new ReadableStream({
-			start: function (controller) {
-				onloadprogress(reader, controller).then(function () {
-					controller.close();
-				});
-			},
-		}), { headers: response.headers });
-	}
-
-	function loadFetch(file, tracker, fileSize, raw) {
-		tracker[file] = {
-			total: fileSize || 0,
-			loaded: 0,
-			done: false,
-		};
-		return fetch(file).then(function (response) {
-			if (!response.ok) {
-				return Promise.reject(new Error(`Failed loading file '${file}'`));
-			}
-			const tr = getTrackedResponse(response, tracker[file]);
-			if (raw) {
-				return Promise.resolve(tr);
-			}
-			return tr.arrayBuffer();
-		});
-	}
-
-	function retry(func, attempts = 1) {
-		function onerror(err) {
-			if (attempts <= 1) {
-				return Promise.reject(err);
-			}
-			return new Promise(function (resolve, reject) {
-				setTimeout(function () {
-					retry(func, attempts - 1).then(resolve).catch(reject);
-				}, 1000);
-			});
-		}
-		return func().catch(onerror);
-	}
-
-	const DOWNLOAD_ATTEMPTS_MAX = 4;
-	const loadingFiles = {};
-	const lastProgress = { loaded: 0, total: 0 };
-	let progressFunc = null;
-
-	const animateProgress = function () {
-		let loaded = 0;
-		let total = 0;
-		let totalIsValid = true;
-		let progressIsFinal = true;
-
-		Object.keys(loadingFiles).forEach(function (file) {
-			const stat = loadingFiles[file];
-			if (!stat.done) {
-				progressIsFinal = false;
-			}
-			if (!totalIsValid || stat.total === 0) {
-				totalIsValid = false;
-				total = 0;
-			} else {
-				total += stat.total;
-			}
-			loaded += stat.loaded;
-		});
-		if (loaded !== lastProgress.loaded || total !== lastProgress.total) {
-			lastProgress.loaded = loaded;
-			lastProgress.total = total;
-			if (typeof progressFunc === 'function') {
-				progressFunc(loaded, total);
-			}
-		}
-		if (!progressIsFinal) {
-			requestAnimationFrame(animateProgress);
-		}
-	};
-
-	this.animateProgress = animateProgress;
-
-	this.setProgressFunc = function (callback) {
-		progressFunc = callback;
-	};
-
-	this.loadPromise = function (file, fileSize, raw = false) {
-		return retry(loadFetch.bind(null, file, loadingFiles, fileSize, raw), DOWNLOAD_ATTEMPTS_MAX);
-	};
-
-	this.preloadedFiles = [];
-	this.preload = function (pathOrBuffer, destPath, fileSize) {
-		let buffer = null;
-		if (typeof pathOrBuffer === 'string') {
-			const me = this;
-			return this.loadPromise(pathOrBuffer, fileSize).then(function (buf) {
-				me.preloadedFiles.push({
-					path: destPath || pathOrBuffer,
-					buffer: buf,
-				});
-				return Promise.resolve();
-			});
-		} else if (pathOrBuffer instanceof ArrayBuffer) {
-			buffer = new Uint8Array(pathOrBuffer);
-		} else if (ArrayBuffer.isView(pathOrBuffer)) {
-			buffer = new Uint8Array(pathOrBuffer.buffer);
-		}
-		if (buffer) {
-			this.preloadedFiles.push({
-				path: destPath,
-				buffer: pathOrBuffer,
-			});
-			return Promise.resolve();
-		}
-		return Promise.reject(new Error('Invalid object for preloading'));
-	};
-};