melonjs 10.6.0 → 10.7.1

package/dist/melonjs.module.js

@@ -1,22 +1,1022 @@
 /*!
- * melonJS Game Engine - v10.6.0
+ * melonJS Game Engine - v10.7.1
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
  * @copyright (C) 2011 - 2022 Olivier Biot
  */
-if (typeof window !== "undefined") {
-    if (typeof window.console === "undefined") {
-        window.console = {};
-        window.console.log = function() {};
-        window.console.assert = function() {};
-        window.console.warn = function() {};
-        window.console.error = function() {
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var check = function (it) {
+  return it && it.Math == Math && it;
+};
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global$m =
+  // eslint-disable-next-line es-x/no-global-this -- safe
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self == 'object' && self) ||
+  check(typeof commonjsGlobal == 'object' && commonjsGlobal) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  (function () { return this; })() || Function('return this')();
+
+var objectGetOwnPropertyDescriptor = {};
+
+var fails$8 = function (exec) {
+  try {
+    return !!exec();
+  } catch (error) {
+    return true;
+  }
+};
+
+var fails$7 = fails$8;
+
+// Detect IE8's incomplete defineProperty implementation
+var descriptors = !fails$7(function () {
+  // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
+  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
+});
+
+var fails$6 = fails$8;
+
+var functionBindNative = !fails$6(function () {
+  // eslint-disable-next-line es-x/no-function-prototype-bind -- safe
+  var test = (function () { /* empty */ }).bind();
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return typeof test != 'function' || test.hasOwnProperty('prototype');
+});
+
+var NATIVE_BIND$1 = functionBindNative;
+
+var call$4 = Function.prototype.call;
+
+var functionCall = NATIVE_BIND$1 ? call$4.bind(call$4) : function () {
+  return call$4.apply(call$4, arguments);
+};
+
+var objectPropertyIsEnumerable = {};
+
+var $propertyIsEnumerable = {}.propertyIsEnumerable;
+// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor$1 && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+  var descriptor = getOwnPropertyDescriptor$1(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;
+
+var createPropertyDescriptor$2 = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+var NATIVE_BIND = functionBindNative;
+
+var FunctionPrototype$1 = Function.prototype;
+var bind = FunctionPrototype$1.bind;
+var call$3 = FunctionPrototype$1.call;
+var uncurryThis$9 = NATIVE_BIND && bind.bind(call$3, call$3);
+
+var functionUncurryThis = NATIVE_BIND ? function (fn) {
+  return fn && uncurryThis$9(fn);
+} : function (fn) {
+  return fn && function () {
+    return call$3.apply(fn, arguments);
+  };
+};
+
+var uncurryThis$8 = functionUncurryThis;
+
+var toString$2 = uncurryThis$8({}.toString);
+var stringSlice = uncurryThis$8(''.slice);
+
+var classofRaw = function (it) {
+  return stringSlice(toString$2(it), 8, -1);
+};
+
+var global$l = global$m;
+var uncurryThis$7 = functionUncurryThis;
+var fails$5 = fails$8;
+var classof = classofRaw;
+
+var Object$3 = global$l.Object;
+var split = uncurryThis$7(''.split);
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var indexedObject = fails$5(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return !Object$3('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classof(it) == 'String' ? split(it, '') : Object$3(it);
+} : Object$3;
+
+var global$k = global$m;
+
+var TypeError$7 = global$k.TypeError;
+
+// `RequireObjectCoercible` abstract operation
+// https://tc39.es/ecma262/#sec-requireobjectcoercible
+var requireObjectCoercible$2 = function (it) {
+  if (it == undefined) throw TypeError$7("Can't call method on " + it);
+  return it;
+};
+
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject = indexedObject;
+var requireObjectCoercible$1 = requireObjectCoercible$2;
+
+var toIndexedObject$3 = function (it) {
+  return IndexedObject(requireObjectCoercible$1(it));
+};
+
+// `IsCallable` abstract operation
+// https://tc39.es/ecma262/#sec-iscallable
+var isCallable$a = function (argument) {
+  return typeof argument == 'function';
+};
+
+var isCallable$9 = isCallable$a;
+
+var isObject$5 = function (it) {
+  return typeof it == 'object' ? it !== null : isCallable$9(it);
+};
+
+var global$j = global$m;
+var isCallable$8 = isCallable$a;
+
+var aFunction = function (argument) {
+  return isCallable$8(argument) ? argument : undefined;
+};
+
+var getBuiltIn$3 = function (namespace, method) {
+  return arguments.length < 2 ? aFunction(global$j[namespace]) : global$j[namespace] && global$j[namespace][method];
+};
+
+var uncurryThis$6 = functionUncurryThis;
+
+var objectIsPrototypeOf = uncurryThis$6({}.isPrototypeOf);
+
+var getBuiltIn$2 = getBuiltIn$3;
+
+var engineUserAgent = getBuiltIn$2('navigator', 'userAgent') || '';
+
+var global$i = global$m;
+var userAgent = engineUserAgent;
+
+var process$1 = global$i.process;
+var Deno = global$i.Deno;
+var versions = process$1 && process$1.versions || Deno && Deno.version;
+var v8 = versions && versions.v8;
+var match, version$1;
+
+if (v8) {
+  match = v8.split('.');
+  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+  // but their correct versions are not interesting for us
+  version$1 = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+}
+
+// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+// so check `userAgent` even if `.v8` exists, but 0
+if (!version$1 && userAgent) {
+  match = userAgent.match(/Edge\/(\d+)/);
+  if (!match || match[1] >= 74) {
+    match = userAgent.match(/Chrome\/(\d+)/);
+    if (match) version$1 = +match[1];
+  }
+}
+
+var engineV8Version = version$1;
+
+/* eslint-disable es-x/no-symbol -- required for testing */
+
+var V8_VERSION = engineV8Version;
+var fails$4 = fails$8;
+
+// eslint-disable-next-line es-x/no-object-getownpropertysymbols -- required for testing
+var nativeSymbol = !!Object.getOwnPropertySymbols && !fails$4(function () {
+  var symbol = Symbol();
+  // Chrome 38 Symbol has incorrect toString conversion
+  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+  return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
+    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+});
+
+/* eslint-disable es-x/no-symbol -- required for testing */
+
+var NATIVE_SYMBOL$1 = nativeSymbol;
+
+var useSymbolAsUid = NATIVE_SYMBOL$1
+  && !Symbol.sham
+  && typeof Symbol.iterator == 'symbol';
+
+var global$h = global$m;
+var getBuiltIn$1 = getBuiltIn$3;
+var isCallable$7 = isCallable$a;
+var isPrototypeOf = objectIsPrototypeOf;
+var USE_SYMBOL_AS_UID$1 = useSymbolAsUid;
+
+var Object$2 = global$h.Object;
+
+var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) {
+  return typeof it == 'symbol';
+} : function (it) {
+  var $Symbol = getBuiltIn$1('Symbol');
+  return isCallable$7($Symbol) && isPrototypeOf($Symbol.prototype, Object$2(it));
+};
+
+var global$g = global$m;
+
+var String$2 = global$g.String;
+
+var tryToString$1 = function (argument) {
+  try {
+    return String$2(argument);
+  } catch (error) {
+    return 'Object';
+  }
+};
+
+var global$f = global$m;
+var isCallable$6 = isCallable$a;
+var tryToString = tryToString$1;
+
+var TypeError$6 = global$f.TypeError;
+
+// `Assert: IsCallable(argument) is true`
+var aCallable$1 = function (argument) {
+  if (isCallable$6(argument)) return argument;
+  throw TypeError$6(tryToString(argument) + ' is not a function');
+};
+
+var aCallable = aCallable$1;
+
+// `GetMethod` abstract operation
+// https://tc39.es/ecma262/#sec-getmethod
+var getMethod$1 = function (V, P) {
+  var func = V[P];
+  return func == null ? undefined : aCallable(func);
+};
+
+var global$e = global$m;
+var call$2 = functionCall;
+var isCallable$5 = isCallable$a;
+var isObject$4 = isObject$5;
+
+var TypeError$5 = global$e.TypeError;
+
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+var ordinaryToPrimitive$1 = function (input, pref) {
+  var fn, val;
+  if (pref === 'string' && isCallable$5(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
+  if (isCallable$5(fn = input.valueOf) && !isObject$4(val = call$2(fn, input))) return val;
+  if (pref !== 'string' && isCallable$5(fn = input.toString) && !isObject$4(val = call$2(fn, input))) return val;
+  throw TypeError$5("Can't convert object to primitive value");
+};
+
+var shared$3 = {exports: {}};
+
+var global$d = global$m;
+
+// eslint-disable-next-line es-x/no-object-defineproperty -- safe
+var defineProperty$1 = Object.defineProperty;
+
+var setGlobal$3 = function (key, value) {
+  try {
+    defineProperty$1(global$d, key, { value: value, configurable: true, writable: true });
+  } catch (error) {
+    global$d[key] = value;
+  } return value;
+};
+
+var global$c = global$m;
+var setGlobal$2 = setGlobal$3;
+
+var SHARED = '__core-js_shared__';
+var store$3 = global$c[SHARED] || setGlobal$2(SHARED, {});
+
+var sharedStore = store$3;
+
+var store$2 = sharedStore;
+
+(shared$3.exports = function (key, value) {
+  return store$2[key] || (store$2[key] = value !== undefined ? value : {});
+})('versions', []).push({
+  version: '3.22.4',
+  mode: 'global',
+  copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
+  license: 'https://github.com/zloirock/core-js/blob/v3.22.4/LICENSE',
+  source: 'https://github.com/zloirock/core-js'
+});
+
+var global$b = global$m;
+var requireObjectCoercible = requireObjectCoercible$2;
+
+var Object$1 = global$b.Object;
+
+// `ToObject` abstract operation
+// https://tc39.es/ecma262/#sec-toobject
+var toObject$1 = function (argument) {
+  return Object$1(requireObjectCoercible(argument));
+};
+
+var uncurryThis$5 = functionUncurryThis;
+var toObject = toObject$1;
+
+var hasOwnProperty = uncurryThis$5({}.hasOwnProperty);
+
+// `HasOwnProperty` abstract operation
+// https://tc39.es/ecma262/#sec-hasownproperty
+// eslint-disable-next-line es-x/no-object-hasown -- safe
+var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) {
+  return hasOwnProperty(toObject(it), key);
+};
+
+var uncurryThis$4 = functionUncurryThis;
+
+var id = 0;
+var postfix = Math.random();
+var toString$1 = uncurryThis$4(1.0.toString);
+
+var uid$2 = function (key) {
+  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$1(++id + postfix, 36);
+};
+
+var global$a = global$m;
+var shared$2 = shared$3.exports;
+var hasOwn$6 = hasOwnProperty_1;
+var uid$1 = uid$2;
+var NATIVE_SYMBOL = nativeSymbol;
+var USE_SYMBOL_AS_UID = useSymbolAsUid;
+
+var WellKnownSymbolsStore = shared$2('wks');
+var Symbol$1 = global$a.Symbol;
+var symbolFor = Symbol$1 && Symbol$1['for'];
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1;
+
+var wellKnownSymbol$1 = function (name) {
+  if (!hasOwn$6(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
+    var description = 'Symbol.' + name;
+    if (NATIVE_SYMBOL && hasOwn$6(Symbol$1, name)) {
+      WellKnownSymbolsStore[name] = Symbol$1[name];
+    } else if (USE_SYMBOL_AS_UID && symbolFor) {
+      WellKnownSymbolsStore[name] = symbolFor(description);
+    } else {
+      WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
+    }
+  } return WellKnownSymbolsStore[name];
+};
+
+var global$9 = global$m;
+var call$1 = functionCall;
+var isObject$3 = isObject$5;
+var isSymbol$1 = isSymbol$2;
+var getMethod = getMethod$1;
+var ordinaryToPrimitive = ordinaryToPrimitive$1;
+var wellKnownSymbol = wellKnownSymbol$1;
+
+var TypeError$4 = global$9.TypeError;
+var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+
+// `ToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-toprimitive
+var toPrimitive$1 = function (input, pref) {
+  if (!isObject$3(input) || isSymbol$1(input)) return input;
+  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+  var result;
+  if (exoticToPrim) {
+    if (pref === undefined) pref = 'default';
+    result = call$1(exoticToPrim, input, pref);
+    if (!isObject$3(result) || isSymbol$1(result)) return result;
+    throw TypeError$4("Can't convert object to primitive value");
+  }
+  if (pref === undefined) pref = 'number';
+  return ordinaryToPrimitive(input, pref);
+};
+
+var toPrimitive = toPrimitive$1;
+var isSymbol = isSymbol$2;
+
+// `ToPropertyKey` abstract operation
+// https://tc39.es/ecma262/#sec-topropertykey
+var toPropertyKey$2 = function (argument) {
+  var key = toPrimitive(argument, 'string');
+  return isSymbol(key) ? key : key + '';
+};
+
+var global$8 = global$m;
+var isObject$2 = isObject$5;
+
+var document$1 = global$8.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS$1 = isObject$2(document$1) && isObject$2(document$1.createElement);
+
+var documentCreateElement = function (it) {
+  return EXISTS$1 ? document$1.createElement(it) : {};
+};
+
+var DESCRIPTORS$5 = descriptors;
+var fails$3 = fails$8;
+var createElement = documentCreateElement;
+
+// Thanks to IE8 for its funny defineProperty
+var ie8DomDefine = !DESCRIPTORS$5 && !fails$3(function () {
+  // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
+  return Object.defineProperty(createElement('div'), 'a', {
+    get: function () { return 7; }
+  }).a != 7;
+});
+
+var DESCRIPTORS$4 = descriptors;
+var call = functionCall;
+var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+var createPropertyDescriptor$1 = createPropertyDescriptor$2;
+var toIndexedObject$2 = toIndexedObject$3;
+var toPropertyKey$1 = toPropertyKey$2;
+var hasOwn$5 = hasOwnProperty_1;
+var IE8_DOM_DEFINE$1 = ie8DomDefine;
+
+// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS$4 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject$2(O);
+  P = toPropertyKey$1(P);
+  if (IE8_DOM_DEFINE$1) try {
+    return $getOwnPropertyDescriptor$1(O, P);
+  } catch (error) { /* empty */ }
+  if (hasOwn$5(O, P)) return createPropertyDescriptor$1(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+};
+
+var objectDefineProperty = {};
+
+var DESCRIPTORS$3 = descriptors;
+var fails$2 = fails$8;
+
+// V8 ~ Chrome 36-
+// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+var v8PrototypeDefineBug = DESCRIPTORS$3 && fails$2(function () {
+  // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
+  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+    value: 42,
+    writable: false
+  }).prototype != 42;
+});
+
+var global$7 = global$m;
+var isObject$1 = isObject$5;
+
+var String$1 = global$7.String;
+var TypeError$3 = global$7.TypeError;
+
+// `Assert: Type(argument) is Object`
+var anObject$2 = function (argument) {
+  if (isObject$1(argument)) return argument;
+  throw TypeError$3(String$1(argument) + ' is not an object');
+};
+
+var global$6 = global$m;
+var DESCRIPTORS$2 = descriptors;
+var IE8_DOM_DEFINE = ie8DomDefine;
+var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
+var anObject$1 = anObject$2;
+var toPropertyKey = toPropertyKey$2;
+
+var TypeError$2 = global$6.TypeError;
+// eslint-disable-next-line es-x/no-object-defineproperty -- safe
+var $defineProperty = Object.defineProperty;
+// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var ENUMERABLE = 'enumerable';
+var CONFIGURABLE$1 = 'configurable';
+var WRITABLE = 'writable';
+
+// `Object.defineProperty` method
+// https://tc39.es/ecma262/#sec-object.defineproperty
+objectDefineProperty.f = DESCRIPTORS$2 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+  anObject$1(O);
+  P = toPropertyKey(P);
+  anObject$1(Attributes);
+  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+    var current = $getOwnPropertyDescriptor(O, P);
+    if (current && current[WRITABLE]) {
+      O[P] = Attributes.value;
+      Attributes = {
+        configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1],
+        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+        writable: false
+      };
+    }
+  } return $defineProperty(O, P, Attributes);
+} : $defineProperty : function defineProperty(O, P, Attributes) {
+  anObject$1(O);
+  P = toPropertyKey(P);
+  anObject$1(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return $defineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw TypeError$2('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+var DESCRIPTORS$1 = descriptors;
+var definePropertyModule$1 = objectDefineProperty;
+var createPropertyDescriptor = createPropertyDescriptor$2;
+
+var createNonEnumerableProperty$3 = DESCRIPTORS$1 ? function (object, key, value) {
+  return definePropertyModule$1.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+var makeBuiltIn$2 = {exports: {}};
+
+var DESCRIPTORS = descriptors;
+var hasOwn$4 = hasOwnProperty_1;
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
+var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+
+var EXISTS = hasOwn$4(FunctionPrototype, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
+var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+
+var functionName = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+var uncurryThis$3 = functionUncurryThis;
+var isCallable$4 = isCallable$a;
+var store$1 = sharedStore;
+
+var functionToString = uncurryThis$3(Function.toString);
+
+// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+if (!isCallable$4(store$1.inspectSource)) {
+  store$1.inspectSource = function (it) {
+    return functionToString(it);
+  };
+}
+
+var inspectSource$2 = store$1.inspectSource;
+
+var global$5 = global$m;
+var isCallable$3 = isCallable$a;
+var inspectSource$1 = inspectSource$2;
+
+var WeakMap$1 = global$5.WeakMap;
+
+var nativeWeakMap = isCallable$3(WeakMap$1) && /native code/.test(inspectSource$1(WeakMap$1));
+
+var shared$1 = shared$3.exports;
+var uid = uid$2;
+
+var keys = shared$1('keys');
+
+var sharedKey$1 = function (key) {
+  return keys[key] || (keys[key] = uid(key));
+};
+
+var hiddenKeys$3 = {};
+
+var NATIVE_WEAK_MAP = nativeWeakMap;
+var global$4 = global$m;
+var uncurryThis$2 = functionUncurryThis;
+var isObject = isObject$5;
+var createNonEnumerableProperty$2 = createNonEnumerableProperty$3;
+var hasOwn$3 = hasOwnProperty_1;
+var shared = sharedStore;
+var sharedKey = sharedKey$1;
+var hiddenKeys$2 = hiddenKeys$3;
+
+var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+var TypeError$1 = global$4.TypeError;
+var WeakMap = global$4.WeakMap;
+var set, get, has;
+
+var enforce = function (it) {
+  return has(it) ? get(it) : set(it, {});
+};
+
+var getterFor = function (TYPE) {
+  return function (it) {
+    var state;
+    if (!isObject(it) || (state = get(it)).type !== TYPE) {
+      throw TypeError$1('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (NATIVE_WEAK_MAP || shared.state) {
+  var store = shared.state || (shared.state = new WeakMap());
+  var wmget = uncurryThis$2(store.get);
+  var wmhas = uncurryThis$2(store.has);
+  var wmset = uncurryThis$2(store.set);
+  set = function (it, metadata) {
+    if (wmhas(store, it)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    wmset(store, it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return wmget(store, it) || {};
+  };
+  has = function (it) {
+    return wmhas(store, it);
+  };
+} else {
+  var STATE = sharedKey('state');
+  hiddenKeys$2[STATE] = true;
+  set = function (it, metadata) {
+    if (hasOwn$3(it, STATE)) throw new TypeError$1(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    createNonEnumerableProperty$2(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return hasOwn$3(it, STATE) ? it[STATE] : {};
+  };
+  has = function (it) {
+    return hasOwn$3(it, STATE);
+  };
+}
+
+var internalState = {
+  set: set,
+  get: get,
+  has: has,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+var fails$1 = fails$8;
+var isCallable$2 = isCallable$a;
+var hasOwn$2 = hasOwnProperty_1;
+var defineProperty = objectDefineProperty.f;
+var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
+var inspectSource = inspectSource$2;
+var InternalStateModule = internalState;
+
+var enforceInternalState = InternalStateModule.enforce;
+var getInternalState = InternalStateModule.get;
+
+var CONFIGURABLE_LENGTH = !fails$1(function () {
+  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+});
+
+var TEMPLATE = String(String).split('String');
+
+var makeBuiltIn$1 = makeBuiltIn$2.exports = function (value, name, options) {
+  if (String(name).slice(0, 7) === 'Symbol(') {
+    name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
+  }
+  if (options && options.getter) name = 'get ' + name;
+  if (options && options.setter) name = 'set ' + name;
+  if (!hasOwn$2(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+    defineProperty(value, 'name', { value: name, configurable: true });
+  }
+  if (CONFIGURABLE_LENGTH && options && hasOwn$2(options, 'arity') && value.length !== options.arity) {
+    defineProperty(value, 'length', { value: options.arity });
+  }
+  var state = enforceInternalState(value);
+  if (!hasOwn$2(state, 'source')) {
+    state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
+  } return value;
+};
+
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+// eslint-disable-next-line no-extend-native -- required
+Function.prototype.toString = makeBuiltIn$1(function toString() {
+  return isCallable$2(this) && getInternalState(this).source || inspectSource(this);
+}, 'toString');
+
+var global$3 = global$m;
+var isCallable$1 = isCallable$a;
+var createNonEnumerableProperty$1 = createNonEnumerableProperty$3;
+var makeBuiltIn = makeBuiltIn$2.exports;
+var setGlobal$1 = setGlobal$3;
+
+var defineBuiltIn$1 = function (O, key, value, options) {
+  var unsafe = options ? !!options.unsafe : false;
+  var simple = options ? !!options.enumerable : false;
+  var noTargetGet = options ? !!options.noTargetGet : false;
+  var name = options && options.name !== undefined ? options.name : key;
+  if (isCallable$1(value)) makeBuiltIn(value, name, options);
+  if (O === global$3) {
+    if (simple) O[key] = value;
+    else setGlobal$1(key, value);
+    return O;
+  } else if (!unsafe) {
+    delete O[key];
+  } else if (!noTargetGet && O[key]) {
+    simple = true;
+  }
+  if (simple) O[key] = value;
+  else createNonEnumerableProperty$1(O, key, value);
+  return O;
+};
+
+var objectGetOwnPropertyNames = {};
+
+var ceil = Math.ceil;
+var floor = Math.floor;
+
+// `ToIntegerOrInfinity` abstract operation
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+var toIntegerOrInfinity$2 = function (argument) {
+  var number = +argument;
+  // eslint-disable-next-line no-self-compare -- safe
+  return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);
+};
+
+var toIntegerOrInfinity$1 = toIntegerOrInfinity$2;
+
+var max = Math.max;
+var min$1 = Math.min;
+
+// Helper for a popular repeating case of the spec:
+// Let integer be ? ToInteger(index).
+// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+var toAbsoluteIndex$1 = function (index, length) {
+  var integer = toIntegerOrInfinity$1(index);
+  return integer < 0 ? max(integer + length, 0) : min$1(integer, length);
+};
+
+var toIntegerOrInfinity = toIntegerOrInfinity$2;
+
+var min = Math.min;
+
+// `ToLength` abstract operation
+// https://tc39.es/ecma262/#sec-tolength
+var toLength$1 = function (argument) {
+  return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+var toLength = toLength$1;
+
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+var lengthOfArrayLike$1 = function (obj) {
+  return toLength(obj.length);
+};
+
+var toIndexedObject$1 = toIndexedObject$3;
+var toAbsoluteIndex = toAbsoluteIndex$1;
+var lengthOfArrayLike = lengthOfArrayLike$1;
+
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIndexedObject$1($this);
+    var length = lengthOfArrayLike(O);
+    var index = toAbsoluteIndex(fromIndex, length);
+    var value;
+    // Array#includes uses SameValueZero equality algorithm
+    // eslint-disable-next-line no-self-compare -- NaN check
+    if (IS_INCLUDES && el != el) while (length > index) {
+      value = O[index++];
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (value != value) return true;
+    // Array#indexOf ignores holes, Array#includes - not
+    } else for (;length > index; index++) {
+      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+
+var arrayIncludes = {
+  // `Array.prototype.includes` method
+  // https://tc39.es/ecma262/#sec-array.prototype.includes
+  includes: createMethod(true),
+  // `Array.prototype.indexOf` method
+  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+  indexOf: createMethod(false)
+};
+
+var uncurryThis$1 = functionUncurryThis;
+var hasOwn$1 = hasOwnProperty_1;
+var toIndexedObject = toIndexedObject$3;
+var indexOf = arrayIncludes.indexOf;
+var hiddenKeys$1 = hiddenKeys$3;
+
+var push$1 = uncurryThis$1([].push);
+
+var objectKeysInternal = function (object, names) {
+  var O = toIndexedObject(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !hasOwn$1(hiddenKeys$1, key) && hasOwn$1(O, key) && push$1(result, key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (hasOwn$1(O, key = names[i++])) {
+    ~indexOf(result, key) || push$1(result, key);
+  }
+  return result;
+};
+
+// IE8- don't enum bug keys
+var enumBugKeys$1 = [
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf'
+];
+
+var internalObjectKeys = objectKeysInternal;
+var enumBugKeys = enumBugKeys$1;
+
+var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+
+// `Object.getOwnPropertyNames` method
+// https://tc39.es/ecma262/#sec-object.getownpropertynames
+// eslint-disable-next-line es-x/no-object-getownpropertynames -- safe
+objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return internalObjectKeys(O, hiddenKeys);
+};
+
+var objectGetOwnPropertySymbols = {};
+
+// eslint-disable-next-line es-x/no-object-getownpropertysymbols -- safe
+objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;
+
+var getBuiltIn = getBuiltIn$3;
+var uncurryThis = functionUncurryThis;
+var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
+var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
+var anObject = anObject$2;
+
+var concat = uncurryThis([].concat);
+
+// all object keys, includes non-enumerable and symbols
+var ownKeys$1 = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+var hasOwn = hasOwnProperty_1;
+var ownKeys = ownKeys$1;
+var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
+var definePropertyModule = objectDefineProperty;
+
+var copyConstructorProperties$1 = function (target, source, exceptions) {
+  var keys = ownKeys(source);
+  var defineProperty = definePropertyModule.f;
+  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+    }
+  }
+};
+
+var fails = fails$8;
+var isCallable = isCallable$a;
+
+var replacement = /#|\.prototype\./;
+
+var isForced$1 = function (feature, detection) {
+  var value = data$1[normalize$1(feature)];
+  return value == POLYFILL ? true
+    : value == NATIVE ? false
+    : isCallable(detection) ? fails(detection)
+    : !!detection;
+};
+
+var normalize$1 = isForced$1.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data$1 = isForced$1.data = {};
+var NATIVE = isForced$1.NATIVE = 'N';
+var POLYFILL = isForced$1.POLYFILL = 'P';
+
+var isForced_1 = isForced$1;
+
+var global$2 = global$m;
+var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f;
+var createNonEnumerableProperty = createNonEnumerableProperty$3;
+var defineBuiltIn = defineBuiltIn$1;
+var setGlobal = setGlobal$3;
+var copyConstructorProperties = copyConstructorProperties$1;
+var isForced = isForced_1;
+
+/*
+  options.target      - name of the target object
+  options.global      - target is the global object
+  options.stat        - export as static methods of target
+  options.proto       - export as prototype methods of target
+  options.real        - real prototype method for the `pure` version
+  options.forced      - export even if the native feature is available
+  options.bind        - bind methods to the target, required for the `pure` version
+  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version
+  options.unsafe      - use the simple assignment of property instead of delete + defineProperty
+  options.sham        - add a flag to not completely full polyfills
+  options.enumerable  - export as enumerable property
+  options.noTargetGet - prevent calling a getter on target
+  options.name        - the .name of the function if it does not match the key
+*/
+var _export = function (options, source) {
+  var TARGET = options.target;
+  var GLOBAL = options.global;
+  var STATIC = options.stat;
+  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+  if (GLOBAL) {
+    target = global$2;
+  } else if (STATIC) {
+    target = global$2[TARGET] || setGlobal(TARGET, {});
+  } else {
+    target = (global$2[TARGET] || {}).prototype;
+  }
+  if (target) for (key in source) {
+    sourceProperty = source[key];
+    if (options.noTargetGet) {
+      descriptor = getOwnPropertyDescriptor(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
+    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+    // contained in target
+    if (!FORCED && targetProperty !== undefined) {
+      if (typeof sourceProperty == typeof targetProperty) continue;
+      copyConstructorProperties(sourceProperty, targetProperty);
+    }
+    // add a flag to not completely full polyfills
+    if (options.sham || (targetProperty && targetProperty.sham)) {
+      createNonEnumerableProperty(sourceProperty, 'sham', true);
+    }
+    defineBuiltIn(target, key, sourceProperty, options);
+  }
+};
+
+var $ = _export;
+var global$1 = global$m;
+
+// `globalThis` object
+// https://tc39.es/ecma262/#sec-globalthis
+$({ global: true }, {
+  globalThis: global$1
+});
+
+if (typeof globalThis !== "undefined") {
+    if (typeof globalThis.console === "undefined") {
+        globalThis.console = {};
+        globalThis.console.log = function() {};
+        globalThis.console.assert = function() {};
+        globalThis.console.warn = function() {};
+        globalThis.console.error = function() {
             alert(Array.prototype.slice.call(arguments).join(", "));
         };
     }
 }
 
+if ("performance" in globalThis === false) {
+    globalThis.performance = {};
+}
+
+Date.now = (Date.now || function () {  // thanks IE8
+    return new Date().getTime();
+});
+
+if ("now" in globalThis.performance === false) {
+
+    var nowOffset = Date.now();
+
+    if (performance.timing && performance.timing.navigationStart) {
+      nowOffset = performance.timing.navigationStart;
+    }
+
+    globalThis.performance.now = function now() {
+      return Date.now() - nowOffset;
+  };
+}
+
 /**
  * a collection of string utility functions
  * @namespace utils.string
@@ -104,13 +1104,13 @@ function toHex$1(str) {
 }
 
 var stringUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    capitalize: capitalize,
-    trimLeft: trimLeft,
-    trimRight: trimRight,
-    isNumeric: isNumeric,
-    isBoolean: isBoolean,
-    toHex: toHex$1
+	__proto__: null,
+	capitalize: capitalize,
+	trimLeft: trimLeft,
+	trimRight: trimRight,
+	isNumeric: isNumeric,
+	isBoolean: isBoolean,
+	toHex: toHex$1
 });
 
 /**
@@ -130,12 +1130,12 @@ var vendors$1 = [ "ms", "MS", "moz", "webkit", "o" ];
  * @name prefixed
  * @function
  * @param {string} name Property name
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {string} Value of property
  * @memberof utils.agent
  */
 function prefixed(name, obj) {
-    obj = obj || window;
+    obj = obj || globalThis;
     if (name in obj) {
         return obj[name];
     }
@@ -156,12 +1156,12 @@ function prefixed(name, obj) {
  * @function
  * @param {string} name Property name
  * @param {string} value Property value
- * @param {object} [obj=window] Object or element reference to access
+ * @param {object} [obj=globalThis] Object or element reference to access
  * @returns {boolean} true if one of the vendor-prefixed property was found
  * @memberof utils.agent
  */
 function setPrefixed(name, value, obj) {
-    obj = obj || window;
+    obj = obj || globalThis;
     if (name in obj) {
         obj[name] = value;
         return;
@@ -181,9 +1181,9 @@ function setPrefixed(name, value, obj) {
 }
 
 var agentUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    prefixed: prefixed,
-    setPrefixed: setPrefixed
+	__proto__: null,
+	prefixed: prefixed,
+	setPrefixed: setPrefixed
 });
 
 /**
@@ -398,22 +1398,22 @@ function toBeCloseTo(expected, actual, precision = 2) {
 }
 
 var math = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    DEG_TO_RAD: DEG_TO_RAD,
-    RAD_TO_DEG: RAD_TO_DEG,
-    TAU: TAU,
-    ETA: ETA,
-    EPSILON: EPSILON,
-    isPowerOfTwo: isPowerOfTwo,
-    nextPowerOfTwo: nextPowerOfTwo,
-    degToRad: degToRad,
-    radToDeg: radToDeg,
-    clamp: clamp,
-    random: random$1,
-    randomFloat: randomFloat,
-    weightedRandom: weightedRandom$1,
-    round: round,
-    toBeCloseTo: toBeCloseTo
+	__proto__: null,
+	DEG_TO_RAD: DEG_TO_RAD,
+	RAD_TO_DEG: RAD_TO_DEG,
+	TAU: TAU,
+	ETA: ETA,
+	EPSILON: EPSILON,
+	isPowerOfTwo: isPowerOfTwo,
+	nextPowerOfTwo: nextPowerOfTwo,
+	degToRad: degToRad,
+	radToDeg: radToDeg,
+	clamp: clamp,
+	random: random$1,
+	randomFloat: randomFloat,
+	weightedRandom: weightedRandom$1,
+	round: round,
+	toBeCloseTo: toBeCloseTo
 });
 
 /**
@@ -471,10 +1471,10 @@ function weightedRandom(arr) {
 }
 
 var arrayUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    remove: remove,
-    random: random,
-    weightedRandom: weightedRandom
+	__proto__: null,
+	remove: remove,
+	random: random,
+	weightedRandom: weightedRandom
 });
 
 /**
@@ -513,9 +1513,9 @@ function getExtension(path) {
 }
 
 var fileUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    getBasename: getBasename,
-    getExtension: getExtension
+	__proto__: null,
+	getBasename: getBasename,
+	getExtension: getExtension
 });
 
 /**
@@ -555,13 +1555,13 @@ function defer(func, thisArg, ...args) {
  * @returns {Function} the function that will be throttled
  */
 function throttle(fn, delay, no_trailing) {
-    var last = window.performance.now(), deferTimer;
+    var last = globalThis.performance.now(), deferTimer;
     // `no_trailing` defaults to false.
     if (typeof no_trailing !== "boolean") {
         no_trailing = false;
     }
     return function () {
-        var now = window.performance.now();
+        var now = globalThis.performance.now();
         var elasped = now - last;
         var args = arguments;
         if (elasped < delay) {
@@ -582,9 +1582,9 @@ function throttle(fn, delay, no_trailing) {
 }
 
 var fnUtils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    defer: defer,
-    throttle: throttle
+	__proto__: null,
+	defer: defer,
+	throttle: throttle
 });
 
 var objectClass = {};
@@ -766,14 +1766,14 @@ function getInstanceCount() {
 }
 
 var pooling = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    register: register,
-    pull: pull,
-    purge: purge,
-    push: push,
-    exists: exists,
-    poolable: poolable,
-    getInstanceCount: getInstanceCount
+	__proto__: null,
+	register: register,
+	pull: pull,
+	purge: purge,
+	push: push,
+	exists: exists,
+	poolable: poolable,
+	getInstanceCount: getInstanceCount
 });
 
 /**
@@ -2384,72 +3384,73 @@ class Matrix3d {
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     rotate(angle, v) {
-        var a = this.val,
-            x = v.x,
-            y = v.y,
-            z = v.z;
-
-        var len = Math.sqrt(x * x + y * y + z * z);
-
-        var s, c, t;
-        var a00, a01, a02, a03;
-        var a10, a11, a12, a13;
-        var a20, a21, a22, a23;
-        var b00, b01, b02;
-        var b10, b11, b12;
-        var b20, b21, b22;
+        if (angle !== 0) {
+            var a = this.val,
+                x = v.x,
+                y = v.y,
+                z = v.z;
+
+            var len = Math.sqrt(x * x + y * y + z * z);
+
+            var s, c, t;
+            var a00, a01, a02, a03;
+            var a10, a11, a12, a13;
+            var a20, a21, a22, a23;
+            var b00, b01, b02;
+            var b10, b11, b12;
+            var b20, b21, b22;
+
+            if (len < EPSILON) {
+                return null;
+            }
+
+            len = 1 / len;
+            x *= len;
+            y *= len;
+            z *= len;
+
+            s = Math.sin(angle);
+            c = Math.cos(angle);
+            t = 1 - c;
+
+            a00 = a[0];
+            a01 = a[1];
+            a02 = a[2];
+            a03 = a[3];
+            a10 = a[4];
+            a11 = a[5];
+            a12 = a[6];
+            a13 = a[7];
+            a20 = a[8];
+            a21 = a[9];
+            a22 = a[10];
+            a23 = a[11];
 
-        if (len < EPSILON) {
-            return null;
+            // Construct the elements of the rotation matrix
+            b00 = x * x * t + c;
+            b01 = y * x * t + z * s;
+            b02 = z * x * t - y * s;
+            b10 = x * y * t - z * s;
+            b11 = y * y * t + c;
+            b12 = z * y * t + x * s;
+            b20 = x * z * t + y * s;
+            b21 = y * z * t - x * s;
+            b22 = z * z * t + c;
+
+            // Perform rotation-specific matrix multiplication
+            a[0] = a00 * b00 + a10 * b01 + a20 * b02;
+            a[1] = a01 * b00 + a11 * b01 + a21 * b02;
+            a[2] = a02 * b00 + a12 * b01 + a22 * b02;
+            a[3] = a03 * b00 + a13 * b01 + a23 * b02;
+            a[4] = a00 * b10 + a10 * b11 + a20 * b12;
+            a[5] = a01 * b10 + a11 * b11 + a21 * b12;
+            a[6] = a02 * b10 + a12 * b11 + a22 * b12;
+            a[7] = a03 * b10 + a13 * b11 + a23 * b12;
+            a[8] = a00 * b20 + a10 * b21 + a20 * b22;
+            a[9] = a01 * b20 + a11 * b21 + a21 * b22;
+            a[10] = a02 * b20 + a12 * b21 + a22 * b22;
+            a[11] = a03 * b20 + a13 * b21 + a23 * b22;
         }
-
-        len = 1 / len;
-        x *= len;
-        y *= len;
-        z *= len;
-
-        s = Math.sin(angle);
-        c = Math.cos(angle);
-        t = 1 - c;
-
-        a00 = a[0];
-        a01 = a[1];
-        a02 = a[2];
-        a03 = a[3];
-        a10 = a[4];
-        a11 = a[5];
-        a12 = a[6];
-        a13 = a[7];
-        a20 = a[8];
-        a21 = a[9];
-        a22 = a[10];
-        a23 = a[11];
-
-        // Construct the elements of the rotation matrix
-        b00 = x * x * t + c;
-        b01 = y * x * t + z * s;
-        b02 = z * x * t - y * s;
-        b10 = x * y * t - z * s;
-        b11 = y * y * t + c;
-        b12 = z * y * t + x * s;
-        b20 = x * z * t + y * s;
-        b21 = y * z * t - x * s;
-        b22 = z * z * t + c;
-
-        // Perform rotation-specific matrix multiplication
-        a[0] = a00 * b00 + a10 * b01 + a20 * b02;
-        a[1] = a01 * b00 + a11 * b01 + a21 * b02;
-        a[2] = a02 * b00 + a12 * b01 + a22 * b02;
-        a[3] = a03 * b00 + a13 * b01 + a23 * b02;
-        a[4] = a00 * b10 + a10 * b11 + a20 * b12;
-        a[5] = a01 * b10 + a11 * b11 + a21 * b12;
-        a[6] = a02 * b10 + a12 * b11 + a22 * b12;
-        a[7] = a03 * b10 + a13 * b11 + a23 * b12;
-        a[8] = a00 * b20 + a10 * b21 + a20 * b22;
-        a[9] = a01 * b20 + a11 * b21 + a21 * b22;
-        a[10] = a02 * b20 + a12 * b21 + a22 * b22;
-        a[11] = a03 * b20 + a13 * b21 + a23 * b22;
-
         return this;
     }
 
@@ -3103,8 +4104,6 @@ class Matrix2d {
     }
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 var eventemitter3 = {exports: {}};
 
 (function (module) {
@@ -3804,7 +4803,7 @@ const DRAGEND = "me.game.dragend";
  * @memberof event
  * @see event.on
  */
-const WINDOW_ONRESIZE = "window.onresize";
+const WINDOW_ONRESIZE = "globalThis.onresize";
 
 /**
  * Event for when the canvas is resized <br>
@@ -3844,7 +4843,7 @@ const VIEWPORT_ONRESIZE = "viewport.onresize";
  * @memberof event
  * @see event.on
  */
-const WINDOW_ONORIENTATION_CHANGE = "window.orientationchange";
+const WINDOW_ONORIENTATION_CHANGE = "globalThis.orientationchange";
 
 /**
  * Event for when the (browser) window is scrolled <br>
@@ -3856,7 +4855,7 @@ const WINDOW_ONORIENTATION_CHANGE = "window.orientationchange";
  * @memberof event
  * @see event.on
  */
-const WINDOW_ONSCROLL = "window.onscroll";
+const WINDOW_ONSCROLL = "globalThis.onscroll";
 
 /**
  * Event for when the viewport position is updated <br>
@@ -3871,8 +4870,8 @@ const WINDOW_ONSCROLL = "window.onscroll";
 const VIEWPORT_ONCHANGE = "viewport.onchange";
 
 /**
- * Event for when WebGL context is lost <br>
- * Data passed : {me.WebGLRenderer} the current webgl renderer instance`
+ * Event for when the current context is lost <br>
+ * Data passed : {me.Renderer} the current renderer instance
  * @public
  * @constant
  * @type {string}
@@ -3880,19 +4879,19 @@ const VIEWPORT_ONCHANGE = "viewport.onchange";
  * @memberof event
  * @see event.on
  */
-const WEBGL_ONCONTEXT_LOST = "renderer.webglcontextlost";
+const ONCONTEXT_LOST = "renderer.contextlost";
 
 /**
- * Event for when WebGL context is restored <br>
- * Data passed : {me.WebGLRenderer} the current webgl renderer instance`
+ * Event for when the current context is restored <br>
+ * Data passed : {me.Renderer} the current renderer instance`
  * @public
  * @constant
  * @type {string}
- * @name WEBGL_ONCONTEXT_RESTORED
+ * @name ONCONTEXT_RESTORED
  * @memberof event
  * @see event.on
  */
-const WEBGL_ONCONTEXT_RESTORED = "renderer.webglcontextrestored";
+const ONCONTEXT_RESTORED = "renderer.contextrestored";
 
 /**
  * calls each of the listeners registered for a given event.
@@ -3948,45 +4947,45 @@ function off(eventName, listener) {
     return eventEmitter.off(eventName, listener);
 }
 
-var event = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    BOOT: BOOT,
-    STATE_PAUSE: STATE_PAUSE,
-    STATE_RESUME: STATE_RESUME,
-    STATE_STOP: STATE_STOP,
-    STATE_RESTART: STATE_RESTART,
-    VIDEO_INIT: VIDEO_INIT,
-    GAME_INIT: GAME_INIT,
-    GAME_RESET: GAME_RESET,
-    GAME_BEFORE_UPDATE: GAME_BEFORE_UPDATE,
-    GAME_AFTER_UPDATE: GAME_AFTER_UPDATE,
-    GAME_UPDATE: GAME_UPDATE,
-    GAME_BEFORE_DRAW: GAME_BEFORE_DRAW,
-    GAME_AFTER_DRAW: GAME_AFTER_DRAW,
-    LEVEL_LOADED: LEVEL_LOADED,
-    LOADER_COMPLETE: LOADER_COMPLETE,
-    LOADER_PROGRESS: LOADER_PROGRESS,
-    KEYDOWN: KEYDOWN,
-    KEYUP: KEYUP,
-    GAMEPAD_CONNECTED: GAMEPAD_CONNECTED,
-    GAMEPAD_DISCONNECTED: GAMEPAD_DISCONNECTED,
-    GAMEPAD_UPDATE: GAMEPAD_UPDATE,
-    POINTERMOVE: POINTERMOVE,
-    POINTERLOCKCHANGE: POINTERLOCKCHANGE,
-    DRAGSTART: DRAGSTART,
-    DRAGEND: DRAGEND,
-    WINDOW_ONRESIZE: WINDOW_ONRESIZE,
-    CANVAS_ONRESIZE: CANVAS_ONRESIZE,
-    VIEWPORT_ONRESIZE: VIEWPORT_ONRESIZE,
-    WINDOW_ONORIENTATION_CHANGE: WINDOW_ONORIENTATION_CHANGE,
-    WINDOW_ONSCROLL: WINDOW_ONSCROLL,
-    VIEWPORT_ONCHANGE: VIEWPORT_ONCHANGE,
-    WEBGL_ONCONTEXT_LOST: WEBGL_ONCONTEXT_LOST,
-    WEBGL_ONCONTEXT_RESTORED: WEBGL_ONCONTEXT_RESTORED,
-    emit: emit,
-    on: on,
-    once: once,
-    off: off
+var event$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	BOOT: BOOT,
+	STATE_PAUSE: STATE_PAUSE,
+	STATE_RESUME: STATE_RESUME,
+	STATE_STOP: STATE_STOP,
+	STATE_RESTART: STATE_RESTART,
+	VIDEO_INIT: VIDEO_INIT,
+	GAME_INIT: GAME_INIT,
+	GAME_RESET: GAME_RESET,
+	GAME_BEFORE_UPDATE: GAME_BEFORE_UPDATE,
+	GAME_AFTER_UPDATE: GAME_AFTER_UPDATE,
+	GAME_UPDATE: GAME_UPDATE,
+	GAME_BEFORE_DRAW: GAME_BEFORE_DRAW,
+	GAME_AFTER_DRAW: GAME_AFTER_DRAW,
+	LEVEL_LOADED: LEVEL_LOADED,
+	LOADER_COMPLETE: LOADER_COMPLETE,
+	LOADER_PROGRESS: LOADER_PROGRESS,
+	KEYDOWN: KEYDOWN,
+	KEYUP: KEYUP,
+	GAMEPAD_CONNECTED: GAMEPAD_CONNECTED,
+	GAMEPAD_DISCONNECTED: GAMEPAD_DISCONNECTED,
+	GAMEPAD_UPDATE: GAMEPAD_UPDATE,
+	POINTERMOVE: POINTERMOVE,
+	POINTERLOCKCHANGE: POINTERLOCKCHANGE,
+	DRAGSTART: DRAGSTART,
+	DRAGEND: DRAGEND,
+	WINDOW_ONRESIZE: WINDOW_ONRESIZE,
+	CANVAS_ONRESIZE: CANVAS_ONRESIZE,
+	VIEWPORT_ONRESIZE: VIEWPORT_ONRESIZE,
+	WINDOW_ONORIENTATION_CHANGE: WINDOW_ONORIENTATION_CHANGE,
+	WINDOW_ONSCROLL: WINDOW_ONSCROLL,
+	VIEWPORT_ONCHANGE: VIEWPORT_ONCHANGE,
+	ONCONTEXT_LOST: ONCONTEXT_LOST,
+	ONCONTEXT_RESTORED: ONCONTEXT_RESTORED,
+	emit: emit,
+	on: on,
+	once: once,
+	off: off
 });
 
 var howler = {};
@@ -10158,6 +11157,21 @@ class Rect extends Polygon {
         this.pos.y = value - (this.height / 2);
     }
 
+    /**
+     * center the rectangle position around the given coordinates
+     * @name centerOn
+     * @memberof Rect.prototype
+     * @function
+     * @param {number} x the x coordinate around which to center this rectangle
+     * @param {number} x the y coordinate around which to center this rectangle
+     * @returns {Rect} this rectangle
+     */
+    centerOn(x, y) {
+        this.centerX = x;
+        this.centerY = y;
+        return this;
+    }
+
     /**
      * resize the rectangle
      * @name resize
@@ -10664,9 +11678,11 @@ var KEY = {
 function initKeyboardEvent() {
     // make sure the keyboard is enable
     if (keyBoardEventTarget === null && device$1.isMobile === false) {
-        keyBoardEventTarget = window;
-        keyBoardEventTarget.addEventListener("keydown", keyDownEvent, false);
-        keyBoardEventTarget.addEventListener("keyup", keyUpEvent, false);
+        keyBoardEventTarget = globalThis;
+        if (typeof keyBoardEventTarget.addEventListener === "function") {
+            keyBoardEventTarget.addEventListener("keydown", keyDownEvent, false);
+            keyBoardEventTarget.addEventListener("keyup", keyUpEvent, false);
+        }
     }
 }
 /**
@@ -11591,7 +12607,7 @@ class Pointer extends Bounds$1 {
         this.gameScreenY = this.y = tmpVec.y;
 
         // true if not originally a pointer event
-        this.isNormalized = !device$1.PointerEvent || (device$1.PointerEvent && !(event instanceof window.PointerEvent));
+        this.isNormalized = !device$1.PointerEvent || (device$1.PointerEvent && !(event instanceof globalThis.PointerEvent));
 
         this.locked = locked;
         this.movementX = event.movementX || 0;
@@ -12189,8 +13205,8 @@ function globalToLocal(x, y, v) {
     v = v || pull("Vector2d");
     var rect = device$1.getElementBounds(renderer.getScreenCanvas());
     var pixelRatio = device$1.devicePixelRatio;
-    x -= rect.left + (window.pageXOffset || 0);
-    y -= rect.top + (window.pageYOffset || 0);
+    x -= rect.left + (globalThis.pageXOffset || 0);
+    y -= rect.top + (globalThis.pageYOffset || 0);
     var scale = scaleRatio;
     if (scale.x !== 1.0 || scale.y !== 1.0) {
         x /= scale.x;
@@ -12405,7 +13421,6 @@ function releaseAllPointerEvents(region) {
  * @memberof input
  * @public
  * @function
- * @param {Function} [success] callback if the request is successful
  * @returns {boolean} return true if the request was successfully submitted
  * @example
  * // register on the pointer lock change event
@@ -12703,17 +13718,19 @@ var updateGamepads = function () {
  * gamepad connected callback
  * @ignore
  */
-window.addEventListener("gamepadconnected", function (e) {
-    emit(GAMEPAD_CONNECTED, e.gamepad);
-}, false);
+if (globalThis.navigator && typeof globalThis.navigator.getGamepads === "function") {
+    globalThis.addEventListener("gamepadconnected", function (e) {
+        emit(GAMEPAD_CONNECTED, e.gamepad);
+    }, false);
 
-/**
- * gamepad disconnected callback
- * @ignore
- */
-window.addEventListener("gamepaddisconnected", function (e) {
-    emit(GAMEPAD_DISCONNECTED, e.gamepad);
-}, false);
+    /**
+     * gamepad disconnected callback
+     * @ignore
+     */
+    globalThis.addEventListener("gamepaddisconnected", function (e) {
+        emit(GAMEPAD_DISCONNECTED, e.gamepad);
+    }, false);
+}
 
 /*
  * PUBLIC STUFF
@@ -12951,36 +13968,36 @@ var setGamepadMapping = addMapping;
 var preventDefault = true;
 
 var input = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    preventDefault: preventDefault,
-    get pointerEventTarget () { return pointerEventTarget; },
-    pointer: pointer,
-    get locked () { return locked; },
-    get throttlingInterval () { return throttlingInterval; },
-    globalToLocal: globalToLocal,
-    setTouchAction: setTouchAction,
-    bindPointer: bindPointer,
-    unbindPointer: unbindPointer,
-    registerPointerEvent: registerPointerEvent,
-    releasePointerEvent: releasePointerEvent,
-    releaseAllPointerEvents: releaseAllPointerEvents,
-    requestPointerLock: requestPointerLock,
-    exitPointerLock: exitPointerLock,
-    get keyBoardEventTarget () { return keyBoardEventTarget; },
-    KEY: KEY,
-    initKeyboardEvent: initKeyboardEvent,
-    isKeyPressed: isKeyPressed,
-    keyStatus: keyStatus,
-    triggerKeyEvent: triggerKeyEvent,
-    bindKey: bindKey,
-    getBindingKey: getBindingKey,
-    unlockKey: unlockKey,
-    unbindKey: unbindKey,
-    GAMEPAD: GAMEPAD,
-    bindGamepad: bindGamepad,
-    unbindGamepad: unbindGamepad,
-    setGamepadDeadzone: setGamepadDeadzone,
-    setGamepadMapping: setGamepadMapping
+	__proto__: null,
+	preventDefault: preventDefault,
+	get pointerEventTarget () { return pointerEventTarget; },
+	pointer: pointer,
+	get locked () { return locked; },
+	get throttlingInterval () { return throttlingInterval; },
+	globalToLocal: globalToLocal,
+	setTouchAction: setTouchAction,
+	bindPointer: bindPointer,
+	unbindPointer: unbindPointer,
+	registerPointerEvent: registerPointerEvent,
+	releasePointerEvent: releasePointerEvent,
+	releaseAllPointerEvents: releaseAllPointerEvents,
+	requestPointerLock: requestPointerLock,
+	exitPointerLock: exitPointerLock,
+	get keyBoardEventTarget () { return keyBoardEventTarget; },
+	KEY: KEY,
+	initKeyboardEvent: initKeyboardEvent,
+	isKeyPressed: isKeyPressed,
+	keyStatus: keyStatus,
+	triggerKeyEvent: triggerKeyEvent,
+	bindKey: bindKey,
+	getBindingKey: getBindingKey,
+	unlockKey: unlockKey,
+	unbindKey: unbindKey,
+	GAMEPAD: GAMEPAD,
+	bindGamepad: bindGamepad,
+	unbindGamepad: unbindGamepad,
+	setGamepadDeadzone: setGamepadDeadzone,
+	setGamepadMapping: setGamepadMapping
 });
 
 /**
@@ -14603,11 +15620,11 @@ function testEllipsePolygon(a, ellipseA, b, polyB, response) {
 }
 
 var SAT = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    testPolygonPolygon: testPolygonPolygon,
-    testEllipseEllipse: testEllipseEllipse,
-    testPolygonEllipse: testPolygonEllipse,
-    testEllipsePolygon: testEllipsePolygon
+	__proto__: null,
+	testPolygonPolygon: testPolygonPolygon,
+	testEllipseEllipse: testEllipseEllipse,
+	testPolygonEllipse: testPolygonEllipse,
+	testEllipsePolygon: testEllipsePolygon
 });
 
 // a dummy object when using Line for raycasting
@@ -17302,7 +18319,7 @@ let sortOn = "z";
  * @name lastUpdate
  * @memberof game
  */
-let lastUpdate = window.performance.now();
+let lastUpdate = globalThis.performance.now();
 
 /**
  * Fired when a level is fully loaded and all entities instantiated. <br>
@@ -17392,7 +18409,7 @@ function update$1(time, stage) {
         accumulatorUpdateDelta = (timer$1.interpolation) ? updateDelta : Math.max(updateDelta, updateAverageDelta);
 
         while (accumulator >= accumulatorUpdateDelta || timer$1.interpolation) {
-            lastUpdateStart = window.performance.now();
+            lastUpdateStart = globalThis.performance.now();
 
             // game update event
             if (state.isPaused() !== true) {
@@ -17402,7 +18419,7 @@ function update$1(time, stage) {
             // update all objects (and pass the elapsed time since last frame)
             isDirty = stage.update(updateDelta) || isDirty;
 
-            lastUpdate = window.performance.now();
+            lastUpdate = globalThis.performance.now();
             updateAverageDelta = lastUpdate - lastUpdateStart;
 
             accumulator -= accumulatorUpdateDelta;
@@ -17426,7 +18443,7 @@ function draw(stage) {
 
     if (renderer.isContextValid === true && (isDirty || isAlwaysDirty)) {
         // publish notification
-        emit(GAME_BEFORE_DRAW, window.performance.now());
+        emit(GAME_BEFORE_DRAW, globalThis.performance.now());
 
         // prepare renderer to draw a new frame
         renderer.clear();
@@ -17441,24 +18458,24 @@ function draw(stage) {
         renderer.flush();
 
         // publish notification
-        emit(GAME_AFTER_DRAW, window.performance.now());
+        emit(GAME_AFTER_DRAW, globalThis.performance.now());
     }
 }
 
 var game = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get viewport () { return viewport; },
-    get world () { return world; },
-    mergeGroup: mergeGroup,
-    sortOn: sortOn,
-    get lastUpdate () { return lastUpdate; },
-    onLevelLoaded: onLevelLoaded,
-    reset: reset,
-    updateFrameRate: updateFrameRate,
-    getParentContainer: getParentContainer,
-    repaint: repaint,
-    update: update$1,
-    draw: draw
+	__proto__: null,
+	get viewport () { return viewport; },
+	get world () { return world; },
+	mergeGroup: mergeGroup,
+	sortOn: sortOn,
+	get lastUpdate () { return lastUpdate; },
+	onLevelLoaded: onLevelLoaded,
+	reset: reset,
+	updateFrameRate: updateFrameRate,
+	getParentContainer: getParentContainer,
+	repaint: repaint,
+	update: update$1,
+	draw: draw
 });
 
 // some ref shortcut
@@ -18556,7 +19573,7 @@ function _startRunLoop() {
         timer$1.reset();
 
         // start the main loop
-        _animFrameId = window.requestAnimationFrame(_renderFrame);
+        _animFrameId = globalThis.requestAnimationFrame(_renderFrame);
     }
 }
 
@@ -18596,7 +19613,7 @@ function _renderFrame(time) {
     draw(stage);
     // schedule the next frame update
     if (_animFrameId !== -1) {
-        _animFrameId = window.requestAnimationFrame(_renderFrame);
+        _animFrameId = globalThis.requestAnimationFrame(_renderFrame);
     }
 }
 
@@ -18606,7 +19623,7 @@ function _renderFrame(time) {
  */
 function _stopRunLoop() {
     // cancel any previous animationRequestFrame
-    window.cancelAnimationFrame(_animFrameId);
+    globalThis.cancelAnimationFrame(_animFrameId);
     _animFrameId = -1;
 }
 
@@ -18779,7 +19796,7 @@ var state = {
             }
 
             // store time when stopped
-            _pauseTime = window.performance.now();
+            _pauseTime = globalThis.performance.now();
 
             // publish the stop notification
             emit(STATE_STOP);
@@ -18805,7 +19822,7 @@ var state = {
             }
 
             // store time when paused
-            _pauseTime = window.performance.now();
+            _pauseTime = globalThis.performance.now();
 
             // publish the pause event
             emit(STATE_PAUSE);
@@ -18830,7 +19847,7 @@ var state = {
             }
 
             // calculate the elpased time
-            _pauseTime = window.performance.now() - _pauseTime;
+            _pauseTime = globalThis.performance.now() - _pauseTime;
 
             // force repaint
             repaint();
@@ -18858,7 +19875,7 @@ var state = {
             }
 
             // calculate the elpased time
-            _pauseTime = window.performance.now() - _pauseTime;
+            _pauseTime = globalThis.performance.now() - _pauseTime;
 
             // publish the resume event
             emit(STATE_RESUME, _pauseTime);
@@ -19199,7 +20216,7 @@ function decodeBase64AsArray(input, bytes) {
     bytes = bytes || 1;
 
     var i, j, len;
-    var dec = window.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
+    var dec = globalThis.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
     var ar = new Uint32Array(dec.length / bytes);
 
     for (i = 0, len = dec.length / bytes; i < len; i++) {
@@ -21479,9 +22496,9 @@ class Renderer {
         if (device$1.ejecta === true) {
             // a main canvas is already automatically created by Ejecta
             this.canvas = document.getElementById("canvas");
-        } else if (typeof window.canvas !== "undefined") {
+        } else if (typeof globalThis.canvas !== "undefined") {
             // a global canvas is available, e.g. webapp adapter for wechat
-            this.canvas = window.canvas;
+            this.canvas = globalThis.canvas;
         } else if (typeof this.settings.canvas !== "undefined") {
             this.canvas = this.settings.canvas;
         } else {
@@ -21908,6 +22925,18 @@ class CanvasRenderer extends Renderer {
             // enable the tile texture seam fix with the canvas renderer
             this.uvOffset = 1;
         }
+
+        // context lost & restore event for canvas
+        this.getScreenCanvas().addEventListener("contextlost", (e) => {
+            e.preventDefault();
+            this.isContextValid = false;
+            event.emit(event.ONCONTEXT_LOST, this);
+        }, false );
+        // ctx.restoreContext()
+        this.getScreenCanvas().addEventListener("contextrestored", () => {
+            this.isContextValid = true;
+            event.emit(event.ONCONTEXT_RESTORED, this);
+        }, false );
     }
 
     /**
@@ -21938,7 +22967,7 @@ class CanvasRenderer extends Renderer {
      * <img src="images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
      * <img src="images/multiply-blendmode.png" width="510"/> <br>
-     * - "lighter" : where both content overlap the color is determined by adding color values. <br>
+     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
@@ -21946,7 +22975,7 @@ class CanvasRenderer extends Renderer {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @memberof CanvasRenderer.prototype
      * @function
-     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter, "screen"
+     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter, "additive", "screen"
      * @param {CanvasRenderingContext2D} [context]
      */
     setBlendMode(mode = "normal", context) {
@@ -21958,6 +22987,7 @@ class CanvasRenderer extends Renderer {
                 break;
 
             case "lighter" :
+            case "additive" :
                 context.globalCompositeOperation = "lighter";
                 break;
 
@@ -26384,7 +27414,7 @@ function preloadTMX(tmxData, onload, onerror) {
                     case "tsx":
                         // ie9 does not fully implement the responseXML
                         if (device$1.ua.match(/msie/i) || !xmlhttp.responseXML) {
-                            if (window.DOMParser) {
+                            if (globalThis.DOMParser) {
                                 // manually create the XML DOM
                                 result = (new DOMParser()).parseFromString(xmlhttp.responseText, "text/xml");
                             } else {
@@ -27484,35 +28514,35 @@ function unloadAll() {
 }
 
 var audio = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    stopOnAudioError: stopOnAudioError,
-    init: init$1,
-    hasFormat: hasFormat,
-    hasAudio: hasAudio,
-    enable: enable,
-    disable: disable,
-    load: load,
-    play: play,
-    fade: fade,
-    seek: seek,
-    rate: rate,
-    stop: stop,
-    pause: pause,
-    resume: resume,
-    playTrack: playTrack,
-    stopTrack: stopTrack,
-    pauseTrack: pauseTrack,
-    resumeTrack: resumeTrack,
-    getCurrentTrack: getCurrentTrack,
-    setVolume: setVolume,
-    getVolume: getVolume,
-    mute: mute,
-    unmute: unmute,
-    muteAll: muteAll,
-    unmuteAll: unmuteAll,
-    muted: muted,
-    unload: unload,
-    unloadAll: unloadAll
+	__proto__: null,
+	stopOnAudioError: stopOnAudioError,
+	init: init$1,
+	hasFormat: hasFormat,
+	hasAudio: hasAudio,
+	enable: enable,
+	disable: disable,
+	load: load,
+	play: play,
+	fade: fade,
+	seek: seek,
+	rate: rate,
+	stop: stop,
+	pause: pause,
+	resume: resume,
+	playTrack: playTrack,
+	stopTrack: stopTrack,
+	pauseTrack: pauseTrack,
+	resumeTrack: resumeTrack,
+	getCurrentTrack: getCurrentTrack,
+	setVolume: setVolume,
+	getVolume: getVolume,
+	mute: mute,
+	unmute: unmute,
+	muteAll: muteAll,
+	unmuteAll: unmuteAll,
+	muted: muted,
+	unload: unload,
+	unloadAll: unloadAll
 });
 
 /**
@@ -27669,8 +28699,8 @@ let swipeEnabled = true;
  */
 function _disableSwipeFn(e) {
     e.preventDefault();
-    if (typeof window.scroll === "function") {
-        window.scroll(0, 0);
+    if (typeof globalThis.scroll === "function") {
+        globalThis.scroll(0, 0);
     }
     return false;
 }
@@ -27685,24 +28715,27 @@ function _domReady() {
     // Make sure that the DOM is not already loaded
     if (!isReady) {
         // be sure document.body is there
-        if (!document.body) {
+        if (!device.nodeJS && !document.body) {
             return setTimeout(_domReady, 13);
         }
 
         // clean up loading event
-        if (document.removeEventListener) {
-            document.removeEventListener(
+        if (typeof globalThis.document !== "undefined" && typeof globalThis.document.removeEventListener === "function") {
+            globalThis.document.removeEventListener(
                 "DOMContentLoaded",
                 this._domReady,
                 false
             );
         }
-        // remove the event on window.onload (always added in `onReady`)
-        window.removeEventListener("load", _domReady, false);
+
+        if (typeof globalThis.removeEventListener === "function") {
+            // remove the event on globalThis.onload (always added in `onReady`)
+            globalThis.removeEventListener("load", _domReady, false);
+        }
 
         // execute all callbacks
         while (readyList.length) {
-            readyList.shift().call(window, []);
+            readyList.shift().call(globalThis, []);
         }
 
         // Remember that the DOM is ready
@@ -27740,7 +28773,7 @@ function _detectDevice() {
                          device.BlackBerry ||
                          device.Kindle || false;
     // ejecta
-    device.ejecta = (typeof window.ejecta !== "undefined");
+    device.ejecta = (typeof globalThis.ejecta !== "undefined");
     // Wechat
     device.isWeixin = /MicroMessenger/i.test(device.ua);
 }
@@ -27760,46 +28793,44 @@ function _checkCapabilities() {
     }
 
     // Touch/Gesture Event feature detection
-    device.TouchEvent = !!("ontouchstart" in window);
-    device.PointerEvent = !!window.PointerEvent;
-    window.gesture = prefixed("gesture");
+    device.TouchEvent = !!("ontouchstart" in globalThis);
+    device.PointerEvent = !!globalThis.PointerEvent;
+    globalThis.gesture = prefixed("gesture");
 
     // detect touch capabilities
     device.touch = device.TouchEvent || device.PointerEvent;
 
     // max amount of touch points ; always at least return 1 (e.g. headless chrome will return 0)
-    device.maxTouchPoints = device.touch ? (device.PointerEvent ? navigator.maxTouchPoints || 1 : 10) : 1;
+    device.maxTouchPoints = device.touch ? (device.PointerEvent ? globalThis.navigator.maxTouchPoints || 1 : 10) : 1;
 
     // detect wheel event support
     // Modern browsers support "wheel", Webkit and IE support at least "mousewheel
-    device.wheel = ("onwheel" in document.createElement("div"));
+    device.wheel = typeof globalThis.document !== "undefined" && "onwheel" in globalThis.document.createElement("div");
 
     // pointerlock detection (pointerLockElement can be null when the feature is supported)
-    device.hasPointerLockSupport = typeof document.pointerLockElement !== "undefined";
+    device.hasPointerLockSupport = typeof globalThis.document !== "undefined" && typeof globalThis.document.pointerLockElement !== "undefined";
 
     // device orientation and motion detection
-    device.hasDeviceOrientation = !!window.DeviceOrientationEvent;
-    device.hasAccelerometer = !!window.DeviceMotionEvent;
+    device.hasDeviceOrientation = !!globalThis.DeviceOrientationEvent;
+    device.hasAccelerometer = !!globalThis.DeviceMotionEvent;
 
     // support the ScreenOrientation API
     device.ScreenOrientation = (typeof screen !== "undefined") &&
                                (typeof screen.orientation !== "undefined");
 
     // fullscreen api detection & polyfill when possible
-    device.hasFullscreenSupport = prefixed("fullscreenEnabled", document) ||
-                                document.mozFullScreenEnabled;
+    device.hasFullscreenSupport = typeof globalThis.document !== "undefined" && (prefixed("fullscreenEnabled", globalThis.document) || globalThis.document.mozFullScreenEnabled);
 
-    document.exitFullscreen = prefixed("cancelFullScreen", document) ||
-                              prefixed("exitFullscreen", document);
+    if (device.hasFullscreenSupport === true) {
+        globalThis.document.exitFullscreen = typeof globalThis.document !== "undefined" && (prefixed("cancelFullScreen", globalThis.document) || prefixed("exitFullscreen", globalThis.document));
+    }
 
-    // vibration API poyfill
-    navigator.vibrate = prefixed("vibrate", navigator);
 
     // web Audio detection
-    device.hasWebAudio = !!(window.AudioContext || window.webkitAudioContext);
+    device.hasWebAudio = !!(globalThis.AudioContext || globalThis.webkitAudioContext);
 
     try {
-        device.localStorage = !!window.localStorage;
+        device.localStorage = !!globalThis.localStorage;
     } catch (e) {
         // the above generates an exception when cookies are blocked
         device.localStorage = false;
@@ -27809,75 +28840,78 @@ function _checkCapabilities() {
         // some browser (e.g. Safari) implements WebGL1 and WebGL2 contexts only
         // https://bugzilla.mozilla.org/show_bug.cgi?id=801176
         device.OffscreenCanvas =
-            (typeof window.OffscreenCanvas !== "undefined") &&
+            (typeof globalThis.OffscreenCanvas !== "undefined") &&
             ((new OffscreenCanvas(0, 0).getContext( "2d" )) !== null);
     } catch (e) {
         device.OffscreenCanvas = false;
     }
 
-    // set pause/stop action on losing focus
-    window.addEventListener("blur", function () {
-        if (device.stopOnBlur) {
-            state.stop(true);
-        }
-        if (device.pauseOnBlur) {
-            state.pause(true);
-        }
-    }, false);
-    // set restart/resume action on gaining focus
-    window.addEventListener("focus", function () {
-        if (device.stopOnBlur) {
-            state.restart(true);
-        }
-        if (device.resumeOnFocus) {
-            state.resume(true);
-        }
-        // force focus if autofocus is on
-        if (device.autoFocus) {
-            device.focus();
-        }
-    }, false);
-
-
-    // Set the name of the hidden property and the change event for visibility
-    var hidden, visibilityChange;
-    if (typeof document.hidden !== "undefined") {
-        // Opera 12.10 and Firefox 18 and later support
-        hidden = "hidden";
-        visibilityChange = "visibilitychange";
-    } else if (typeof document.mozHidden !== "undefined") {
-        hidden = "mozHidden";
-        visibilityChange = "mozvisibilitychange";
-    } else if (typeof document.msHidden !== "undefined") {
-        hidden = "msHidden";
-        visibilityChange = "msvisibilitychange";
-    } else if (typeof document.webkitHidden !== "undefined") {
-        hidden = "webkitHidden";
-        visibilityChange = "webkitvisibilitychange";
-    }
-
-    // register on the event if supported
-    if (typeof (visibilityChange) === "string") {
-        // add the corresponding event listener
-        document.addEventListener(visibilityChange,
-            function () {
-                if (document[hidden]) {
-                    if (device.stopOnBlur) {
-                        state.stop(true);
-                    }
-                    if (device.pauseOnBlur) {
-                        state.pause(true);
-                    }
-                } else {
-                    if (device.stopOnBlur) {
-                        state.restart(true);
-                    }
-                    if (device.resumeOnFocus) {
-                        state.resume(true);
+    if (typeof globalThis.addEventListener === "function") {
+        // set pause/stop action on losing focus
+        globalThis.addEventListener("blur", function () {
+            if (device.stopOnBlur) {
+                state.stop(true);
+            }
+            if (device.pauseOnBlur) {
+                state.pause(true);
+            }
+        }, false);
+        // set restart/resume action on gaining focus
+        globalThis.addEventListener("focus", function () {
+            if (device.stopOnBlur) {
+                state.restart(true);
+            }
+            if (device.resumeOnFocus) {
+                state.resume(true);
+            }
+            // force focus if autofocus is on
+            if (device.autoFocus) {
+                device.focus();
+            }
+        }, false);
+    }
+
+    if (typeof globalThis.document !== "undefined") {
+        // Set the name of the hidden property and the change event for visibility
+        var hidden, visibilityChange;
+        if (typeof globalThis.document.hidden !== "undefined") {
+            // Opera 12.10 and Firefox 18 and later support
+            hidden = "hidden";
+            visibilityChange = "visibilitychange";
+        } else if (typeof globalThis.document.mozHidden !== "undefined") {
+            hidden = "mozHidden";
+            visibilityChange = "mozvisibilitychange";
+        } else if (typeof globalThis.document.msHidden !== "undefined") {
+            hidden = "msHidden";
+            visibilityChange = "msvisibilitychange";
+        } else if (typeof globalThis.document.webkitHidden !== "undefined") {
+            hidden = "webkitHidden";
+            visibilityChange = "webkitvisibilitychange";
+        }
+
+        // register on the event if supported
+        if (typeof (visibilityChange) === "string") {
+            // add the corresponding event listener
+            globalThis.document.addEventListener(visibilityChange,
+                function () {
+                    if (globalThis.document[hidden]) {
+                        if (device.stopOnBlur) {
+                            state.stop(true);
+                        }
+                        if (device.pauseOnBlur) {
+                            state.pause(true);
+                        }
+                    } else {
+                        if (device.stopOnBlur) {
+                            state.restart(true);
+                        }
+                        if (device.resumeOnFocus) {
+                            state.resume(true);
+                        }
                     }
-                }
-            }, false
-        );
+                }, false
+            );
+        }
     }
 }
 
@@ -27897,7 +28931,7 @@ let device = {
      * @name ua
      * @memberof device
      */
-    ua : navigator.userAgent,
+    ua : typeof globalThis.navigator !== "undefined" ? globalThis.navigator.userAgent : "",
 
     /**
      * Browser Local Storage capabilities <br>
@@ -27971,7 +29005,7 @@ let device = {
      * @name nativeBase64
      * @memberof device
      */
-    nativeBase64 : (typeof(window.atob) === "function"),
+    nativeBase64 : (typeof(globalThis.atob) === "function"),
 
     /**
      * Return the maximum number of simultaneous touch contact points are supported by the current device.
@@ -28050,24 +29084,33 @@ let device = {
      */
     linux : false,
 
-   /**
-    * equals to true if the game is running under Ejecta.
-    * @type {boolean}
-    * @readonly
-    * @see http://impactjs.com/ejecta
-    * @name ejecta
-    * @memberof device
-    */
+    /**
+     * equals to true if the game is running under Ejecta.
+     * @type {boolean}
+     * @readonly
+     * @see http://impactjs.com/ejecta
+     * @name ejecta
+     * @memberof device
+     */
     ejecta : false,
 
     /**
-     * equals to true if the game is running under Wechat.
+     * equals to true if the  is running under Wechat.
      * @type {boolean}
      * @readonly
      * @name isWeixin
      * @memberof device
      */
-     isWeixin : false,
+    isWeixin : false,
+
+    /**
+     * equals to true if running under node.js
+     * @type {boolean}
+     * @readonly
+     * @name nodeJS
+     * @memberof device
+     */
+    nodeJS : (typeof process !== "undefined") && (process.release.name === "node"),
 
     /**
      * equals to true if the device is running on ChromeOS.
@@ -28182,7 +29225,7 @@ let device = {
      * @name language
      * @memberof device
      */
-    language : navigator.language || navigator.browserLanguage || navigator.userLanguage || "en",
+    language : typeof globalThis.navigator !== "undefined" ? globalThis.navigator.language || globalThis.navigator.browserLanguage || globalThis.navigator.userLanguage || "en" : "en",
 
     /**
      * Specify whether to pause the game when losing focus
@@ -28274,7 +29317,7 @@ let device = {
         // If the DOM is already ready
         if (isReady) {
             // Execute the function immediately
-            fn.call(window, []);
+            fn.call(globalThis, []);
         }
         else {
             // Add the function to the wait list
@@ -28283,17 +29326,17 @@ let device = {
             // attach listeners if not yet done
             if (!readyBound) {
                 // directly call domReady if document is already "ready"
-                if (document.readyState === "complete") {
+                if (device.nodeJS === true || (typeof globalThis.document !== "undefined" && globalThis.document.readyState === "complete")) {
                     // defer the fn call to ensure our script is fully loaded
-                    window.setTimeout(_domReady, 0);
+                    globalThis.setTimeout(_domReady, 0);
                 }
                 else {
-                    if (document.addEventListener) {
+                    if (typeof globalThis.document !== "undefined" && typeof globalThis.document.addEventListener === "function") {
                         // Use the handy event callback
-                        document.addEventListener("DOMContentLoaded", _domReady, false);
+                        globalThis.document.addEventListener("DOMContentLoaded", _domReady, false);
                     }
-                    // A fallback to window.onload, that will always work
-                    window.addEventListener("load", _domReady, false);
+                    // A fallback to globalThis.onload, that will always work
+                    globalThis.addEventListener("load", _domReady, false);
                 }
                 readyBound = true;
             }
@@ -28308,11 +29351,11 @@ let device = {
     enableSwipe(enable) {
         if (enable !== false) {
             if (swipeEnabled === false) {
-                window.document.removeEventListener("touchmove", _disableSwipeFn, false);
+                globalThis.document.removeEventListener("touchmove", _disableSwipeFn, false);
                 swipeEnabled = true;
             }
         } else if (swipeEnabled === true) {
-            window.document.addEventListener("touchmove", _disableSwipeFn, false);
+            globalThis.document.addEventListener("touchmove", _disableSwipeFn, false);
             swipeEnabled = false;
         }
     },
@@ -28366,7 +29409,7 @@ let device = {
         var PORTRAIT = "portrait";
         var LANDSCAPE = "landscape";
 
-        var screen = window.screen;
+        var screen = globalThis.screen;
 
         // first try using "standard" values
         if (this.ScreenOrientation === true) {
@@ -28381,12 +29424,12 @@ let device = {
         }
 
         // check using the deprecated API
-        if (typeof window.orientation === "number") {
-            return (Math.abs(window.orientation) === 90) ? LANDSCAPE : PORTRAIT;
+        if (typeof globalThis.orientation === "number") {
+            return (Math.abs(globalThis.orientation) === 90) ? LANDSCAPE : PORTRAIT;
         }
 
         // fallback to window size check
-        return (window.outerWidth > window.outerHeight) ? LANDSCAPE : PORTRAIT;
+        return (globalThis.outerWidth > globalThis.outerHeight) ? LANDSCAPE : PORTRAIT;
     },
 
     /**
@@ -28398,7 +29441,7 @@ let device = {
      * @returns {boolean} true if the orientation was unsuccessfully locked
      */
     lockOrientation(orientation) {
-        var screen = window.screen;
+        var screen = globalThis.screen;
         if (typeof screen !== "undefined") {
             var _lockOrientation = prefixed("lockOrientation", screen);
             if (typeof _lockOrientation !== "undefined") {
@@ -28416,7 +29459,7 @@ let device = {
      * @returns {boolean} true if the orientation was unsuccessfully unlocked
      */
     unlockOrientation() {
-        var screen = window.screen;
+        var screen = globalThis.screen;
         if (typeof screen !== "undefined") {
             var _unlockOrientation = prefixed("unlockOrientation", screen);
             if (typeof _unlockOrientation !== "undefined") {
@@ -28515,8 +29558,8 @@ let device = {
         if (typeof element === "object" && element !== document.body && typeof element.getBoundingClientRect !== "undefined") {
             return element.getBoundingClientRect();
         } else {
-            _domRect.width = _domRect.right = window.innerWidth;
-            _domRect.height = _domRect.bottom = window.innerHeight;
+            _domRect.width = _domRect.right = globalThis.innerWidth;
+            _domRect.height = _domRect.bottom = globalThis.innerHeight;
             return _domRect;
         }    },
 
@@ -28547,7 +29590,7 @@ let device = {
                 stencil: true,
                 failIfMajorPerformanceCaveat : options.failIfMajorPerformanceCaveat
             };
-            _supported = !! (window.WebGLRenderingContext && (canvas.getContext("webgl", ctxOptions) || canvas.getContext("experimental-webgl", ctxOptions)));
+            _supported = !! (globalThis.WebGLRenderingContext && (canvas.getContext("webgl", ctxOptions) || canvas.getContext("experimental-webgl", ctxOptions)));
         } catch (e) {
             _supported = false;
         }
@@ -28582,8 +29625,8 @@ let device = {
      *  }
      */
     focus() {
-        if (typeof (window.focus) === "function") {
-            window.focus();
+        if (typeof (globalThis.focus) === "function") {
+            globalThis.focus();
         }
     },
 
@@ -28637,13 +29680,13 @@ let device = {
                     .then(response => {
                         if (response === "granted") {
                             // add a listener for the devicemotion event
-                            window.addEventListener("devicemotion", this.onDeviceMotion, false);
+                            globalThis.addEventListener("devicemotion", this.onDeviceMotion, false);
                             accelInitialized = true;
                         }
                     }).catch(console.error);
             } else {
                 // add a listener for the devicemotion event
-                window.addEventListener("devicemotion", this.onDeviceMotion, false);
+                globalThis.addEventListener("devicemotion", this.onDeviceMotion, false);
                 accelInitialized = true;
             }
         }
@@ -28657,7 +29700,7 @@ let device = {
     unwatchAccelerometer() {
         if (accelInitialized) {
             // remove the listener for the devicemotion event
-            window.removeEventListener("devicemotion", this.onDeviceMotion, false);
+            globalThis.removeEventListener("devicemotion", this.onDeviceMotion, false);
             accelInitialized = false;
         }
     },
@@ -28687,12 +29730,12 @@ let device = {
                 DeviceOrientationEvent.requestPermission()
                     .then(response => {
                         if (response === "granted") {
-                            window.addEventListener("deviceorientation", this.onDeviceRotate, false);
+                            globalThis.addEventListener("deviceorientation", this.onDeviceRotate, false);
                             deviceOrientationInitialized = true;
                         }
                     }).catch(console.error);
             } else {
-                window.addEventListener("deviceorientation", this.onDeviceRotate, false);
+                globalThis.addEventListener("deviceorientation", this.onDeviceRotate, false);
                 deviceOrientationInitialized = true;
             }
         }
@@ -28705,7 +29748,7 @@ let device = {
      */
     unwatchDeviceOrientation() {
         if (deviceOrientationInitialized) {
-            window.removeEventListener("deviceorientation", this.onDeviceRotate, false);
+            globalThis.removeEventListener("deviceorientation", this.onDeviceRotate, false);
             deviceOrientationInitialized = false;
         }
     },
@@ -28728,8 +29771,8 @@ let device = {
      * me.device.vibrate(0);
      */
     vibrate(pattern) {
-        if (navigator.vibrate) {
-            navigator.vibrate(pattern);
+        if (typeof globalThis.navigator !== "undefined" && typeof globalThis.navigator.vibrate === "function") {
+            globalThis.navigator.vibrate(pattern);
         }
     }
 
@@ -28749,7 +29792,7 @@ Object.defineProperty(device, "devicePixelRatio", {
      * @ignore
      */
     get: function () {
-        return (window.devicePixelRatio || 1);
+        return (globalThis.devicePixelRatio || 1);
     }
 });
 
@@ -29073,7 +30116,7 @@ class GLShader {
         this.uniforms = extractUniforms(this.gl, this);
 
         // destroy the shader on context lost (will be recreated on context restore)
-        on(WEBGL_ONCONTEXT_LOST, this.destroy, this);
+        on(ONCONTEXT_LOST, this.destroy, this);
     }
 
     /**
@@ -29969,19 +31012,19 @@ class WebGLRenderer extends Renderer {
         // Create a texture cache
         this.cache = new TextureCache(this.maxTextures);
 
-        // to simulate context lost and restore :
+        // to simulate context lost and restore in WebGL:
         // var ctx = me.video.renderer.context.getExtension('WEBGL_lose_context');
         // ctx.loseContext()
         this.getScreenCanvas().addEventListener("webglcontextlost", (e) => {
             e.preventDefault();
             this.isContextValid = false;
-            emit(WEBGL_ONCONTEXT_LOST, this);
+            emit(ONCONTEXT_LOST, this);
         }, false );
         // ctx.restoreContext()
         this.getScreenCanvas().addEventListener("webglcontextrestored", () => {
             this.reset();
             this.isContextValid = true;
-            emit(WEBGL_ONCONTEXT_RESTORED, this);
+            emit(ONCONTEXT_RESTORED, this);
         }, false );
     }
 
@@ -30376,7 +31419,7 @@ class WebGLRenderer extends Renderer {
      * <img src="images/normal-blendmode.png" width="510"/> <br>
      * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
      * <img src="images/multiply-blendmode.png" width="510"/> <br>
-     * - "lighter" : where both content overlap the color is determined by adding color values. <br>
+     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
      * <img src="images/lighter-blendmode.png" width="510"/> <br>
      * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
      * <img src="images/screen-blendmode.png" width="510"/> <br>
@@ -30384,7 +31427,7 @@ class WebGLRenderer extends Renderer {
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @memberof WebGLRenderer.prototype
      * @function
-     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "screen"
+     * @param {string} [mode="normal"] blend mode : "normal", "multiply", "lighter", "additive", "screen"
      * @param {WebGLRenderingContext} [gl]
      */
     setBlendMode(mode = "normal", gl = this.gl) {
@@ -30400,6 +31443,7 @@ class WebGLRenderer extends Renderer {
                     break;
 
                 case "lighter" :
+                case "additive" :
                     gl.blendFunc(gl.ONE, gl.ONE);
                     break;
 
@@ -31011,7 +32055,7 @@ var designHeight = 0;
 
 // default video settings
 var settings = {
-    parent : document.body,
+    parent : undefined,
     renderer : 2, // AUTO
     doubleBuffering : false,
     autoScale : false,
@@ -31056,8 +32100,8 @@ function onresize() {
         var canvasMaxWidth = Infinity;
         var canvasMaxHeight = Infinity;
 
-        if (window.getComputedStyle) {
-            var style = window.getComputedStyle(renderer.getScreenCanvas(), null);
+        if (globalThis.getComputedStyle) {
+            var style = globalThis.getComputedStyle(renderer.getScreenCanvas(), null);
             canvasMaxWidth = parseInt(style.maxWidth, 10) || Infinity;
             canvasMaxHeight = parseInt(style.maxHeight, 10) || Infinity;
         }
@@ -31267,7 +32311,7 @@ function init(width, height, options) {
     settings.zoomY = height * scaleRatio.y;
 
     //add a channel for the onresize/onorientationchange event
-    window.addEventListener(
+    globalThis.addEventListener(
         "resize",
         utils.function.throttle(
             function (e) {
@@ -31277,7 +32321,7 @@ function init(width, height, options) {
     );
 
     // Screen Orientation API
-    window.addEventListener(
+    globalThis.addEventListener(
         "orientationchange",
         function (e) {
             emit(WINDOW_ONORIENTATION_CHANGE, e);
@@ -31285,7 +32329,7 @@ function init(width, height, options) {
         false
     );
     // pre-fixed implementation on mozzila
-    window.addEventListener(
+    globalThis.addEventListener(
         "onmozorientationchange",
         function (e) {
             emit(WINDOW_ONORIENTATION_CHANGE, e);
@@ -31294,13 +32338,13 @@ function init(width, height, options) {
     );
 
     if (device$1.ScreenOrientation === true) {
-        window.screen.orientation.onchange = function (e) {
+        globalThis.screen.orientation.onchange = function (e) {
             emit(WINDOW_ONORIENTATION_CHANGE, e);
         };
     }
 
     // Automatically update relative canvas position on scroll
-    window.addEventListener("scroll", utils.function.throttle(
+    globalThis.addEventListener("scroll", utils.function.throttle(
         function (e) {
             emit(WINDOW_ONSCROLL, e);
         }, 100
@@ -31327,14 +32371,14 @@ function init(width, height, options) {
     }
 
     // add our canvas (default to document.body if settings.parent is undefined)
-    parent = device$1.getElement(settings.parent);
+    parent = device$1.getElement(typeof settings.parent !== "undefined" ? settings.parent : document.body);
     parent.appendChild(renderer.getScreenCanvas());
 
     // trigger an initial resize();
     onresize();
 
     // add an observer to detect when the dom tree is modified
-    if ("MutationObserver" in window) {
+    if ("MutationObserver" in globalThis) {
         // Create an observer instance linked to the callback function
         var observer = new MutationObserver(onresize.bind(this));
 
@@ -31353,7 +32397,7 @@ function init(width, height, options) {
             renderType + " renderer" + gpu_renderer + " | " +
             audioType + " | " +
             "pixel ratio " + device$1.devicePixelRatio + " | " +
-            (device$1.isMobile ? "mobile" : "desktop") + " | " +
+            (device$1.nodeJS ? "node.js" : device$1.isMobile ? "mobile" : "desktop") + " | " +
             device$1.getScreenOrientation() + " | " +
             device$1.language
         );
@@ -31440,17 +32484,17 @@ function scale(x, y) {
 }
 
 var video = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    CANVAS: CANVAS,
-    WEBGL: WEBGL,
-    AUTO: AUTO,
-    get parent () { return parent; },
-    scaleRatio: scaleRatio,
-    get renderer () { return renderer; },
-    init: init,
-    createCanvas: createCanvas,
-    getParent: getParent,
-    scale: scale
+	__proto__: null,
+	CANVAS: CANVAS,
+	WEBGL: WEBGL,
+	AUTO: AUTO,
+	get parent () { return parent; },
+	scaleRatio: scaleRatio,
+	get renderer () { return renderer; },
+	init: init,
+	createCanvas: createCanvas,
+	getParent: getParent,
+	scale: scale
 });
 
 /**
@@ -31549,12 +32593,17 @@ var utils = {
         var hash = {};
 
         if (typeof url === "undefined") {
-            var location = document.location;
+            if (typeof globalThis.document !== "undefined") {
+                var location = globalThis.document.location;
 
-            if (location && location.hash) {
-                url = location.hash;
+                if (location && location.hash) {
+                    url = location.hash;
+                } else {
+                    // No "document.location" exist for Wechat mini game platform.
+                    return hash;
+                }
             } else {
-                // No "document.location" exist for Wechat mini game platform.
+                // "document" undefined on node.js
                 return hash;
             }
         } else {
@@ -31743,7 +32792,7 @@ var timer = {
          */
         reset() {
             // set to "now"
-            last = now = window.performance.now();
+            last = now = globalThis.performance.now();
             delta = 0;
             // reset delta counting variables
             framedelta = 0;
@@ -31882,23 +32931,23 @@ var x;
 
 // standardized functions
 // https://developer.mozilla.org/fr/docs/Web/API/Window/requestAnimationFrame
-var requestAnimationFrame = window.requestAnimationFrame;
-var cancelAnimationFrame = window.cancelAnimationFrame;
+var requestAnimationFrame = globalThis.requestAnimationFrame;
+var cancelAnimationFrame = globalThis.cancelAnimationFrame;
 
 // get prefixed rAF and cAF is standard one not supported
 for (x = 0; x < vendors.length && !requestAnimationFrame; ++x) {
-    requestAnimationFrame = window[vendors[x] + "RequestAnimationFrame"];
+    requestAnimationFrame = globalThis[vendors[x] + "RequestAnimationFrame"];
 }
 for (x = 0; x < vendors.length && !cancelAnimationFrame; ++x) {
-    cancelAnimationFrame = window[vendors[x] + "CancelAnimationFrame"] ||
-                           window[vendors[x] + "CancelRequestAnimationFrame"];
+    cancelAnimationFrame = globalThis[vendors[x] + "CancelAnimationFrame"] ||
+                           globalThis[vendors[x] + "CancelRequestAnimationFrame"];
 }
 
 if (!requestAnimationFrame || !cancelAnimationFrame) {
     requestAnimationFrame = function (callback) {
-        var currTime = window.performance.now();
+        var currTime = globalThis.performance.now();
         var timeToCall = Math.max(0, (1000 / timer$1.maxfps) - (currTime - lastTime));
-        var id = window.setTimeout(function () {
+        var id = globalThis.setTimeout(function () {
             callback(currTime + timeToCall);
         }, timeToCall);
         lastTime = currTime + timeToCall;
@@ -31906,12 +32955,12 @@ if (!requestAnimationFrame || !cancelAnimationFrame) {
     };
 
     cancelAnimationFrame = function (id) {
-        window.clearTimeout(id);
+        globalThis.clearTimeout(id);
     };
 
     // put back in global namespace
-    window.requestAnimationFrame = requestAnimationFrame;
-    window.cancelAnimationFrame = cancelAnimationFrame;
+    globalThis.requestAnimationFrame = requestAnimationFrame;
+    globalThis.cancelAnimationFrame = cancelAnimationFrame;
 }
 
 /**
@@ -31930,10 +32979,10 @@ class BasePlugin {
          * this can be overridden by the plugin
          * @public
          * @type {string}
-         * @default "10.6.0"
+         * @default "10.7.1"
          * @name plugin.Base#version
          */
-        this.version = "10.6.0";
+        this.version = "10.7.1";
     }
 }
 
@@ -33679,11 +34728,6 @@ class BitmapText extends Renderable {
             this.floating = !!settings.floating;
         }
 
-        // resize if necessary
-        if (typeof settings.size === "number" && settings.size !== 1.0) {
-            this.resize(settings.size);
-        }
-
         // apply given fillstyle
         if (typeof settings.fillStyle !== "undefined") {
             if (settings.fillStyle instanceof Color) {
@@ -33704,6 +34748,11 @@ class BitmapText extends Renderable {
         // instance to text metrics functions
         this.metrics = new TextMetrics(this);
 
+        // resize if necessary
+        if (typeof settings.size === "number" && settings.size !== 1.0) {
+            this.resize(settings.size);
+        }
+
         // set the text
         this.setText(settings.text);
     }
@@ -34307,7 +35356,7 @@ class ImageLayer extends Sprite {
         this.repeat = settings.repeat || "repeat";
 
         // on context lost, all previous textures are destroyed
-        on(WEBGL_ONCONTEXT_RESTORED, this.createPattern, this);
+        on(ONCONTEXT_RESTORED, this.createPattern, this);
     }
 
     /**
@@ -34508,7 +35557,7 @@ class ImageLayer extends Sprite {
     destroy() {
         push(this.ratio);
         this.ratio = undefined;
-        off(WEBGL_ONCONTEXT_RESTORED, this.createPattern);
+        off(ONCONTEXT_RESTORED, this.createPattern);
         super.destroy();
     }
 
@@ -35352,143 +36401,63 @@ class DropTarget extends Renderable {
 }
 
 /**
- * @classdesc
- * Particle Container Object.
- * @class ParticleContainer
- * @augments Container
- * @param {ParticleEmitter} emitter the emitter which owns this container
+ * ParticleEmitterSettings contains the default settings for ParticleEmitter
+ * @see ParticleEmitter
+ * @namespace ParticleEmitterSettings
  */
-
-class ParticleContainer extends Container {
-
+const ParticleEmitterSettings = {
     /**
-     * @ignore
-     */
-    constructor(emitter) {
-        // call the super constructor
-        super(
-            viewport.pos.x,
-            viewport.pos.y,
-            viewport.width,
-            viewport.height
-        );
-
-        // don't sort the particles by z-index
-        this.autoSort = false;
-
-        // count the updates
-        this._updateCount = 0;
-
-        // internally store how much time was skipped when frames are skipped
-        this._dt = 0;
-
-        // cache the emitter for later use
-        this._emitter = emitter;
-
-        this.autoTransform = false;
-
-        this.anchorPoint.set(0, 0);
-
-        this.isKinematic = true;
-    }
-
-    /**
-     * @ignore
+     * Width of the particle spawn area.
+     * @type {number}
+     * @name width
+     * @memberof ParticleEmitterSettings
+     * @default 1
      */
-    update(dt) {
-        // skip frames if necessary
-        if (++this._updateCount > this._emitter.framesToSkip) {
-            this._updateCount = 0;
-        }
-        if (this._updateCount > 0) {
-            this._dt += dt;
-            return false;
-        }
-
-        // apply skipped delta time
-        dt += this._dt;
-        this._dt = 0;
-
-        // Update particles and remove them if they are dead
-        for (var i = this.children.length - 1; i >= 0; --i) {
-            var particle = this.children[i];
-            particle.inViewport = viewport.isVisible(particle, this.floating);
-            if (!particle.update(dt)) {
-                this.removeChildNow(particle);
-            }
-        }
-        return true;
-    }
+    width : 1,
 
     /**
-     * @ignore
+     * Height of the particle spawn area
+     * @public
+     * @type {number}
+     * @name height
+     * @memberof ParticleEmitterSettings
+     * @default 1
      */
-    draw(renderer, rect) {
-        if (this.children.length > 0) {
-            var context = renderer.getContext(),
-                gco;
-            // Check for additive draw
-            if (this._emitter.textureAdditive) {
-                gco = context.globalCompositeOperation;
-                context.globalCompositeOperation = "lighter";
-            }
+    height : 1,
 
-            super.draw(renderer, rect);
-
-            // Restore globalCompositeOperation
-            if (this._emitter.textureAdditive) {
-                context.globalCompositeOperation = gco;
-            }
-        }
-    }
-}
-
-// generate a default image for the particles
-var pixel = (function () {
-    var canvas = createCanvas(1, 1);
-    var context = canvas.getContext("2d");
-    context.fillStyle = "#fff";
-    context.fillRect(0, 0, 1, 1);
-    return canvas;
-})();
-
-/**
- * me.ParticleEmitterSettings contains the default settings for me.ParticleEmitter
- * @ignore
- * @class
- * @see ParticleEmitter
- */
-var ParticleEmitterSettings = {
     /**
-     * Width of the particle spawn area.<br>
+     * image used for particles texture
+     * (by default melonJS will create an white 8x8 texture image)
      * @public
-     * @type {number}
-     * @name width
+     * @type {HTMLCanvasElement}
+     * @name image
      * @memberof ParticleEmitterSettings
-     * @default 0
+     * @default undefined
+     * @see ParticleEmitterSettings.textureSize
      */
-    width : 0,
+    image : undefined,
 
     /**
-     * Height of the particle spawn area
+     * default texture size used for particles if no image is specified
+     * (by default melonJS will create an white 8x8 texture image)
      * @public
      * @type {number}
-     * @name height
+     * @name textureSize
      * @memberof ParticleEmitterSettings
-     * @default 0
+     * @default 8
+     * @see ParticleEmitterSettings.image
      */
-    height : 0,
+    textureSize : 8,
 
     /**
-     * Image used for particles
+     * tint to be applied to particles
      * @public
-     * @type {CanvasImageSource}
-     * @name image
+     * @type {string}
+     * @name tint
      * @memberof ParticleEmitterSettings
-     * @default 1x1 white pixel
-     * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-canvas-element.html#canvasimagesource
+     * @default "#fff"
      */
-    image : pixel,
+    tint : "#fff",
 
     /**
      * Total number of particles in the emitter
@@ -35511,7 +36480,7 @@ var ParticleEmitterSettings = {
     angle : Math.PI / 2,
 
     /**
-     * Variation in the start angle for particle launch in Radians
+     * Variation in the start angle for particle launch in Radians.
      * @public
      * @type {number}
      * @name angleVariation
@@ -35521,7 +36490,7 @@ var ParticleEmitterSettings = {
     angleVariation : 0,
 
     /**
-     * Minimum time each particle lives once it is emitted in ms
+     * Minimum time each particle lives once it is emitted in ms.
      * @public
      * @type {number}
      * @name minLife
@@ -35531,7 +36500,7 @@ var ParticleEmitterSettings = {
     minLife : 1000,
 
     /**
-     * Maximum time each particle lives once it is emitted in ms
+     * Maximum time each particle lives once it is emitted in ms.
      * @public
      * @type {number}
      * @name maxLife
@@ -35654,18 +36623,31 @@ var ParticleEmitterSettings = {
     followTrajectory : false,
 
     /**
-     * Enable the Texture Additive by canvas composite operation (lighter).<br>
-     * WARNING: Composite Operation may decreases performance!.<br>
+     * Enable the Texture Additive by composite operation ("additive" blendMode)
      * @public
      * @type {boolean}
      * @name textureAdditive
      * @default false
      * @memberof ParticleEmitterSettings
+     * @see ParticleEmitterSettings.blendMode
      */
     textureAdditive : false,
 
     /**
-     * Update particles only in the viewport, remove it when out of viewport.<br>
+     * the blend mode to be applied when rendering particles.
+     * (note: this will superseed the `textureAdditive` setting if different than "normal")
+     * @public
+     * @type {string}
+     * @name blendMode
+     * @default normal
+     * @memberof ParticleEmitterSettings
+     * @see CanvasRenderer#setBlendMode
+     * @see WebGLRenderer#setBlendMode
+     */
+    blendMode : "normal",
+
+    /**
+     * Update particles only in the viewport, remove it when out of viewport.
      * @public
      * @type {boolean}
      * @name onlyInViewport
@@ -35675,7 +36657,7 @@ var ParticleEmitterSettings = {
     onlyInViewport : true,
 
     /**
-     * Render particles in screen space. <br>
+     * Render particles in screen space.
      * @public
      * @type {boolean}
      * @name floating
@@ -35685,7 +36667,7 @@ var ParticleEmitterSettings = {
     floating : false,
 
     /**
-     * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).<br>
+     * Maximum number of particles launched each time in this emitter (used only if emitter is Stream).
      * @public
      * @type {number}
      * @name maxParticles
@@ -35695,8 +36677,7 @@ var ParticleEmitterSettings = {
     maxParticles : 10,
 
     /**
-     * How often a particle is emitted in ms (used only if emitter is Stream).<br>
-     * Necessary that value is greater than zero.<br>
+     * How often a particle is emitted in ms (used only if emitter is a Stream).
      * @public
      * @type {number}
      * @name frequency
@@ -35706,8 +36687,8 @@ var ParticleEmitterSettings = {
     frequency : 100,
 
     /**
-     * Duration that the emitter releases particles in ms (used only if emitter is Stream).<br>
-     * After this period, the emitter stop the launch of particles.<br>
+     * Duration that the emitter releases particles in ms (used only if emitter is Stream).
+     * After this period, the emitter stop the launch of particles.
      * @public
      * @type {number}
      * @name duration
@@ -35717,8 +36698,8 @@ var ParticleEmitterSettings = {
     duration : Infinity,
 
     /**
-     * Skip n frames after updating the particle system once. <br>
-     * This can be used to reduce the performance impact of emitters with many particles.<br>
+     * Skip n frames after updating the particle system once.
+     * This can be used to reduce the performance impact of emitters with many particles.
      * @public
      * @type {number}
      * @name framesToSkip
@@ -35728,44 +36709,64 @@ var ParticleEmitterSettings = {
     framesToSkip : 0
 };
 
+// default texture used when no sprite is defined
+let defaultParticleTexture;
+
+/**
+ * @ignore
+ */
+function createDefaultParticleTexture(w = 8, h = 8) {
+    if (typeof defaultParticleTexture === "undefined") {
+        defaultParticleTexture = createCanvas(w, h, true);
+        var context = defaultParticleTexture.getContext("2d");
+        context.fillStyle = "#fff";
+        context.fillRect(0, 0, w, h);
+    }
+    return defaultParticleTexture;
+}
 /**
+ * @classdesc
  * Particle Emitter Object.
- * @class
- * @augments Rect
- * @param {number} x x-position of the particle emitter
- * @param {number} y y-position of the particle emitter
- * @param {object} settings An object containing the settings for the particle emitter. See {@link ParticleEmitterSettings}
- * @example
- * // Create a basic emitter at position 100, 100
- * var emitter = new me.ParticleEmitter(100, 100);
- *
- * // Adjust the emitter properties
- * emitter.totalParticles = 200;
- * emitter.minLife = 1000;
- * emitter.maxLife = 3000;
- * emitter.z = 10;
- *
- * // Add the emitter to the game world
- * me.game.world.addChild(emitter);
- *
- * // Launch all particles one time and stop, like a explosion
- * emitter.burstParticles();
- *
- * // Launch constantly the particles, like a fountain
- * emitter.streamParticles();
- *
- * // At the end, remove emitter from the game world
- * // call this in onDestroyEvent function
- * me.game.world.removeChild(emitter);
+ * @augments Container
  */
-class ParticleEmitter extends Renderable {
-
+class ParticleEmitter extends Container {
     /**
-     * @ignore
+     * @param {number} x x position of the particle emitter
+     * @param {number} y y position of the particle emitter
+     * @param {ParticleEmitterSettings} [settings=ParticleEmitterSettings] the settings for the particle emitter.
+     * @example
+     * // Create a basic emitter at position 100, 100
+     * var emitter = new ParticleEmitter(100, 100);
+     *
+     * // Adjust the emitter properties
+     * emitter.totalParticles = 200;
+     * emitter.minLife = 1000;
+     * emitter.maxLife = 3000;
+     * emitter.z = 10;
+     *
+     * // Add the emitter to the game world
+     * me.game.world.addChild(emitter);
+     *
+     * // Launch all particles one time and stop, like a explosion
+     * emitter.burstParticles();
+     *
+     * // Launch constantly the particles, like a fountain
+     * emitter.streamParticles();
+     *
+     * // At the end, remove emitter from the game world
+     * // call this in onDestroyEvent function
+     * me.game.world.removeChild(emitter);
      */
-    constructor(x, y, settings) {
+    constructor(x, y, settings = {}) {
         // call the super constructor
-        super(x, y, Infinity, Infinity);
+        super(
+            x, y,
+            settings.width | 1,
+            settings.height | 1
+        );
+
+        // center the emitter around the given coordinates
+        this.centerOn(x, y);
 
         // Emitter is Stream, launch particles constantly
         /** @ignore */
@@ -35791,109 +36792,52 @@ class ParticleEmitter extends Renderable {
         // don't sort the particles by z-index
         this.autoSort = false;
 
-        this.container = new ParticleContainer(this);
-
-        // Reset the emitter to defaults
-        this.reset(settings);
-    }
+        // count the updates
+        this._updateCount = 0;
 
-    /**
-     * @ignore
-     */
-    get z() {
-        return this.container.pos.z;
-    }
+        // the emitter settings
+        this.settings = {};
 
-    /**
-     * @ignore
-     */
-    set z(value) {
-        this.container.pos.z = value;
-    }
+        // internally store how much time was skipped when frames are skipped
+        this._dt = 0;
 
-    /**
-     * Floating property for particles, value is forwarded to the particle container <br>
-     * @type {boolean}
-     * @name floating
-     * @memberof ParticleEmitter
-     */
-    get floating() {
-        return this.container.floating;
-    }
+        //this.anchorPoint.set(0, 0);
 
-    set floating(value) {
-        this.container.floating = value;
+        // Reset the emitter to defaults
+        this.reset(settings);
     }
 
     /**
-     * @ignore
+     * Reset the emitter with particle emitter settings.
+     * @param {object} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
      */
-    onActivateEvent() {
-        this.ancestor.addChild(this.container);
-        this.container.pos.z = this.pos.z;
-        if (!this.ancestor.autoSort) {
-            this.ancestor.sort();
-        }
-    }
+    reset(settings = {}) {
+        Object.assign(this.settings, ParticleEmitterSettings, settings);
 
-    /**
-     * @ignore
-     */
-    onDeactivateEvent() {
-        if (this.ancestor.hasChild(this.container)) {
-            this.ancestor.removeChildNow(this.container);
+        // Cache the image reference
+        if (typeof this.settings.image === "undefined") {
+            this.settings.image = createDefaultParticleTexture(settings.textureSize, settings.textureSize);
         }
-    }
 
-    /**
-     * @ignore
-     */
-    destroy() {
-        this.reset();
+        this.floating = this.settings.floating;
+
+        this.isDirty = true;
     }
 
     /**
-     * returns a random point inside the bounds x axis of this emitter
-     * @name getRandomPointX
-     * @memberof ParticleEmitter
-     * @function
+     * returns a random point on the x axis within the bounds of this emitter
      * @returns {number}
      */
     getRandomPointX() {
-        return this.pos.x + randomFloat(0, this.width);
+        return randomFloat(0, this.getBounds().width);
     }
 
     /**
-     * returns a random point inside the bounds y axis of this emitter
-     * @name getRandomPointY
-     * @memberof ParticleEmitter
-     * @function
+     * returns a random point on the y axis within the bounds this emitter
      * @returns {number}
      */
     getRandomPointY() {
-        return this.pos.y + randomFloat(0, this.height);
-    }
-
-    /**
-     * Reset the emitter with default values.<br>
-     * @function
-     * @param {object} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
-     * @name reset
-     * @memberof ParticleEmitter
-     */
-    reset(settings) {
-        // check if settings exists and create a dummy object if necessary
-        settings = settings || {};
-        var defaults = ParticleEmitterSettings;
-
-        var width = (typeof settings.width === "number") ? settings.width : defaults.width;
-        var height = (typeof settings.height === "number") ? settings.height : defaults.height;
-        this.resize(width, height);
-
-        Object.assign(this, defaults, settings);
-
-        // reset particle container values
-        this.container.reset();
+        return randomFloat(0, this.getBounds().height);
     }
 
     // Add count particles in the game world
@@ -35901,59 +36845,45 @@ class ParticleEmitter extends Renderable {
     addParticles(count) {
         for (var i = 0; i < ~~count; i++) {
             // Add particle to the container
-            var particle = pull("Particle", this);
-            this.container.addChild(particle);
+            this.addChild(pull("Particle", this), this.pos.z);
         }
+        this.isDirty = true;
     }
 
     /**
-     * Emitter is of type stream and is launching particles <br>
-     * @function
+     * Emitter is of type stream and is launching particles
      * @returns {boolean} Emitter is Stream and is launching particles
-     * @name isRunning
-     * @memberof ParticleEmitter
      */
     isRunning() {
         return this._enabled && this._stream;
     }
 
     /**
-     * Launch particles from emitter constantly <br>
-     * Particles example: Fountains
+     * Launch particles from emitter constantly (e.g. for stream)
      * @param {number} duration [optional] time that the emitter releases particles in ms
-     * @function
-     * @name streamParticles
-     * @memberof ParticleEmitter
      */
     streamParticles(duration) {
         this._enabled = true;
         this._stream = true;
-        this.frequency = Math.max(this.frequency, 1);
-        this._durationTimer = (typeof duration === "number") ? duration : this.duration;
+        this.settings.frequency = Math.max(1, this.settings.frequency);
+        this._durationTimer = (typeof duration === "number") ? duration : this.settings.duration;
     }
 
     /**
-     * Stop the emitter from generating new particles (used only if emitter is Stream) <br>
-     * @function
-     * @name stopStream
-     * @memberof ParticleEmitter
+     * Stop the emitter from generating new particles (used only if emitter is Stream)
      */
     stopStream() {
         this._enabled = false;
     }
 
     /**
-     * Launch all particles from emitter and stop <br>
-     * Particles example: Explosions <br>
+     * Launch all particles from emitter and stop (e.g. for explosion)
      * @param {number} total [optional] number of particles to launch
-     * @function
-     * @name burstParticles
-     * @memberof ParticleEmitter
      */
     burstParticles(total) {
         this._enabled = true;
         this._stream = false;
-        this.addParticles((typeof total === "number") ? total : this.totalParticles);
+        this.addParticles((typeof total === "number") ? total : this.settings.totalParticles);
         this._enabled = false;
     }
 
@@ -35961,6 +36891,22 @@ class ParticleEmitter extends Renderable {
      * @ignore
      */
     update(dt) {
+        // skip frames if necessary
+        if (++this._updateCount > this.settings.framesToSkip) {
+            this._updateCount = 0;
+        }
+        if (this._updateCount > 0) {
+            this._dt += dt;
+            return this.isDirty;
+        }
+
+        // apply skipped delta time
+        dt += this._dt;
+        this._dt = 0;
+
+        // Update particles
+        this.isDirty |= super.update(dt);
+
         // Launch new particles, if emitter is Stream
         if ((this._enabled) && (this._stream)) {
             // Check if the emitter has duration set
@@ -35969,7 +36915,7 @@ class ParticleEmitter extends Renderable {
 
                 if (this._durationTimer <= 0) {
                     this.stopStream();
-                    return false;
+                    return this.isDirty;
                 }
             }
 
@@ -35977,117 +36923,136 @@ class ParticleEmitter extends Renderable {
             this._frequencyTimer += dt;
 
             // Check for new particles launch
-            var particlesCount = this.container.children.length;
-            if ((particlesCount < this.totalParticles) && (this._frequencyTimer >= this.frequency)) {
-                if ((particlesCount + this.maxParticles) <= this.totalParticles) {
-                    this.addParticles(this.maxParticles);
+            var particlesCount = this.children.length;
+            if ((particlesCount < this.settings.totalParticles) && (this._frequencyTimer >= this.settings.frequency)) {
+                if ((particlesCount + this.settings.maxParticles) <= this.settings.totalParticles) {
+                    this.addParticles(this.settings.maxParticles);
                 }
                 else {
-                    this.addParticles(this.totalParticles - particlesCount);
+                    this.addParticles(this.settings.totalParticles - particlesCount);
                 }
-
                 this._frequencyTimer = 0;
+                this.isDirty = true;
             }
         }
-        return true;
+        return this.isDirty;
     }
 
+    /**
+     * Destroy function
+     * @ignore
+     */
+    destroy() {
+        // call the parent destroy method
+        super.destroy(arguments);
+        // clean emitter specific Properties
+        this.settings.image = undefined;
+        this.settings = undefined;
+    }
 }
 
 /**
  * @classdesc
  * Single Particle Object.
- * @class Particle
  * @augments Renderable
- * @param {ParticleEmitter} particle emitter
  */
 class Particle extends Renderable {
     /**
-     * @ignore
+     * @param {ParticleEmitter} emitter the particle emitter
      */
     constructor(emitter) {
         // Call the super constructor
         super(
             emitter.getRandomPointX(),
             emitter.getRandomPointY(),
-            emitter.image.width,
-            emitter.image.height
+            emitter.settings.image.width,
+            emitter.settings.image.height
         );
-
-        // particle velocity
-        this.vel = new Vector2d();
         this.onResetEvent(emitter, true);
     }
 
+    /**
+     * @ignore
+     */
     onResetEvent(emitter, newInstance = false) {
         if (newInstance === false) {
-            super.onResetEvent(
+            this.pos.set(
                 emitter.getRandomPointX(),
-                emitter.getRandomPointY(),
-                emitter.image.width,
-                emitter.image.height
+                emitter.getRandomPointY()
+            );
+            this.resize(
+                emitter.settings.image.width,
+                emitter.settings.image.height
             );
+        } else {
+            // particle velocity
+            this.vel = new Vector2d();
         }
 
+        this.image = emitter.settings.image;
+
         // Particle will always update
         this.alwaysUpdate = true;
 
-        // Cache the image reference
-        this.image = emitter.image;
+        if (typeof emitter.settings.tint === "string") {
+            this.tint.parseCSS(emitter.settings.tint);
+        }
+
+        if (emitter.settings.textureAdditive === true) {
+            this.blendMode = "additive";
+        }
+
+        if (emitter.settings.blendMode !== "normal") {
+            this.blendMode = emitter.settings.blendMode;
+        }
 
         // Set the start particle Angle and Speed as defined in emitter
-        var angle = emitter.angle + ((emitter.angleVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.angleVariation : 0);
-        var speed = emitter.speed + ((emitter.speedVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.speedVariation : 0);
+        var angle = emitter.settings.angle + ((emitter.settings.angleVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.settings.angleVariation : 0);
+        var speed = emitter.settings.speed + ((emitter.settings.speedVariation > 0) ? (randomFloat(0, 2) - 1) * emitter.settings.speedVariation : 0);
 
         // Set the start particle Velocity
         this.vel.set(speed * Math.cos(angle), -speed * Math.sin(angle));
 
         // Set the start particle Time of Life as defined in emitter
-        this.life = randomFloat(emitter.minLife, emitter.maxLife);
+        this.life = randomFloat(emitter.settings.minLife, emitter.settings.maxLife);
         this.startLife = this.life;
 
         // Set the start and end particle Scale as defined in emitter
         // clamp the values as minimum and maximum scales range
         this.startScale = clamp(
-            randomFloat(emitter.minStartScale, emitter.maxStartScale),
-            emitter.minStartScale,
-            emitter.maxStartScale
+            randomFloat(emitter.settings.minStartScale, emitter.settings.maxStartScale),
+            emitter.settings.minStartScale,
+            emitter.settings.maxStartScale
         );
         this.endScale = clamp(
-            randomFloat(emitter.minEndScale, emitter.maxEndScale),
-            emitter.minEndScale,
-            emitter.maxEndScale
+            randomFloat(emitter.settings.minEndScale, emitter.settings.maxEndScale),
+            emitter.settings.minEndScale,
+            emitter.settings.maxEndScale
         );
 
         // Set the particle Gravity and Wind (horizontal gravity) as defined in emitter
-        this.gravity = emitter.gravity;
-        this.wind = emitter.wind;
+        this.gravity = emitter.settings.gravity;
+        this.wind = emitter.settings.wind;
 
         // Set if the particle update the rotation in accordance the trajectory
-        this.followTrajectory = emitter.followTrajectory;
+        this.followTrajectory = emitter.settings.followTrajectory;
 
         // Set if the particle update only in Viewport
-        this.onlyInViewport = emitter.onlyInViewport;
-
-        // Set the particle Z Order
-        this.pos.z = emitter.z;
+        this.onlyInViewport = emitter.settings.onlyInViewport;
 
         // cache inverse of the expected delta time
         this._deltaInv = timer$1.maxfps / 1000;
 
         // Set the start particle rotation as defined in emitter
         // if the particle not follow trajectory
-        if (!emitter.followTrajectory) {
-            this.angle = randomFloat(emitter.minRotation, emitter.maxRotation);
+        if (!emitter.settings.followTrajectory) {
+            this.angle = randomFloat(emitter.settings.minRotation, emitter.settings.maxRotation);
         }
     }
 
     /**
      * Update the Particle <br>
      * This is automatically called by the game manager {@link game}
-     * @name update
-     * @memberof Particle
-     * @function
      * @ignore
      * @param {number} dt time since the last update in milliseconds
      */
@@ -36098,6 +37063,11 @@ class Particle extends Renderable {
         // Decrease particle life
         this.life = this.life > dt ? this.life - dt : 0;
 
+        if (this.life <= 0) {
+            this.ancestor.removeChild(this);
+            return false;
+        }
+
         // Calculate the particle Age Ratio
         var ageRatio = this.life / this.startLife;
 
@@ -36132,23 +37102,10 @@ class Particle extends Renderable {
             this.pos.x, this.pos.y, 1
         ).rotate(angle);
 
-        // Return true if the particle is not dead yet
-        return (this.inViewport || !this.onlyInViewport) && (this.life > 0);
-    }
-
-    /**
-     * @ignore
-     */
-    preDraw(renderer) {
+        // mark as dirty if the particle is not dead yet
+        this.isDirty = this.inViewport || !this.onlyInViewport;
 
-        // restore is called in postDraw
-        renderer.save();
-
-        // particle alpha value
-        renderer.setGlobalAlpha(renderer.globalAlpha() * this.alpha);
-
-        // translate to the defined anchor point and scale it
-        renderer.transform(this.currentTransform);
+        return super.update(dt);
     }
 
     /**
@@ -36527,7 +37484,7 @@ class DroptargetEntity extends DropTarget {
     }
 }
 
-// ES5 polyfills
+// ES5/ES6 polyfills
 
 
 /**
@@ -36537,7 +37494,7 @@ class DroptargetEntity extends DropTarget {
  * @name version
  * @type {string}
  */
-const version = "10.6.0";
+const version = "10.7.1";
 
 
 /**
@@ -36644,4 +37601,4 @@ device$1.onReady(function () {
     }
 });
 
-export { BitmapText, BitmapTextData, Body, Bounds$1 as Bounds, Camera2d, CanvasRenderer, Collectable, Color, ColorLayer, Container, Draggable, DraggableEntity, DropTarget, DroptargetEntity, Ellipse, Entity, GLShader, GUI_Object, ImageLayer, Line, math as Math, Matrix2d, Matrix3d, NineSliceSprite, ObservableVector2d, ObservableVector3d, Particle, ParticleEmitter, ParticleEmitterSettings, Pointer, Polygon, QuadTree, Rect, Renderable, Renderer, Sprite, Stage, TMXHexagonalRenderer, TMXIsometricRenderer, TMXLayer, TMXOrthogonalRenderer, TMXRenderer, TMXStaggeredRenderer, TMXTileMap, TMXTileset, TMXTilesetGroup, Text, TextureAtlas, Tile, Trigger, Tween, Vector2d, Vector3d, WebGLCompositor, WebGLRenderer, World, audio, boot, collision, device$1 as device, event, game, initialized, input, level, loader, plugin, plugins, pooling as pool, save, skipAutoInit, state, timer$1 as timer, utils, version, video, warning };
+export { BitmapText, BitmapTextData, Body, Bounds$1 as Bounds, Camera2d, CanvasRenderer, Collectable, Color, ColorLayer, Container, Draggable, DraggableEntity, DropTarget, DroptargetEntity, Ellipse, Entity, GLShader, GUI_Object, ImageLayer, Line, math as Math, Matrix2d, Matrix3d, NineSliceSprite, ObservableVector2d, ObservableVector3d, Particle, ParticleEmitter, ParticleEmitterSettings, Pointer, Polygon, QuadTree, Rect, Renderable, Renderer, Sprite, Stage, TMXHexagonalRenderer, TMXIsometricRenderer, TMXLayer, TMXOrthogonalRenderer, TMXRenderer, TMXStaggeredRenderer, TMXTileMap, TMXTileset, TMXTilesetGroup, Text, TextureAtlas, Tile, Trigger, Tween, Vector2d, Vector3d, WebGLCompositor, WebGLRenderer, World, audio, boot, collision, device$1 as device, event$1 as event, game, initialized, input, level, loader, plugin, plugins, pooling as pool, save, skipAutoInit, state, timer$1 as timer, utils, version, video, warning };