melonjs 14.1.1 → 14.2.0

package/dist/melonjs.mjs/node_modules/core-js/internals/indexed-object.js

@@ -0,0 +1,28 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import functionUncurryThis from './function-uncurry-this.js';
+import fails$1 from './fails.js';
+import classofRaw from './classof-raw.js';
+
+var uncurryThis = functionUncurryThis;
+var fails = fails$1;
+var classof = classofRaw;
+
+var $Object = Object;
+var split = uncurryThis(''.split);
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var indexedObject = fails(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return !$Object('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classof(it) == 'String' ? split(it, '') : $Object(it);
+} : $Object;
+
+export { indexedObject as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/inspect-source.js

@@ -0,0 +1,27 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import functionUncurryThis from './function-uncurry-this.js';
+import isCallable$1 from './is-callable.js';
+import sharedStore from './shared-store.js';
+
+var uncurryThis = functionUncurryThis;
+var isCallable = isCallable$1;
+var store = sharedStore;
+
+var functionToString = uncurryThis(Function.toString);
+
+// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+if (!isCallable(store.inspectSource)) {
+  store.inspectSource = function (it) {
+    return functionToString(it);
+  };
+}
+
+var inspectSource = store.inspectSource;
+
+export { inspectSource as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/internal-state.js

@@ -0,0 +1,88 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import weakMapBasicDetection from './weak-map-basic-detection.js';
+import global$1 from './global.js';
+import isObject$1 from './is-object.js';
+import createNonEnumerableProperty$1 from './create-non-enumerable-property.js';
+import hasOwnProperty_1 from './has-own-property.js';
+import sharedStore from './shared-store.js';
+import sharedKey$1 from './shared-key.js';
+import hiddenKeys$1 from './hidden-keys.js';
+
+var NATIVE_WEAK_MAP = weakMapBasicDetection;
+var global = global$1;
+var isObject = isObject$1;
+var createNonEnumerableProperty = createNonEnumerableProperty$1;
+var hasOwn = hasOwnProperty_1;
+var shared = sharedStore;
+var sharedKey = sharedKey$1;
+var hiddenKeys = hiddenKeys$1;
+
+var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+var TypeError = global.TypeError;
+var WeakMap = global.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('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (NATIVE_WEAK_MAP || shared.state) {
+  var store = shared.state || (shared.state = new WeakMap());
+  /* eslint-disable no-self-assign -- prototype methods protection */
+  store.get = store.get;
+  store.has = store.has;
+  store.set = store.set;
+  /* eslint-enable no-self-assign -- prototype methods protection */
+  set = function (it, metadata) {
+    if (store.has(it)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    store.set(it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return store.get(it) || {};
+  };
+  has = function (it) {
+    return store.has(it);
+  };
+} else {
+  var STATE = sharedKey('state');
+  hiddenKeys[STATE] = true;
+  set = function (it, metadata) {
+    if (hasOwn(it, STATE)) throw TypeError(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    createNonEnumerableProperty(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return hasOwn(it, STATE) ? it[STATE] : {};
+  };
+  has = function (it) {
+    return hasOwn(it, STATE);
+  };
+}
+
+var internalState = {
+  set: set,
+  get: get,
+  has: has,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+export { internalState as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/is-callable.js

@@ -0,0 +1,22 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import documentAll_1 from './document-all.js';
+
+var $documentAll = documentAll_1;
+
+var documentAll = $documentAll.all;
+
+// `IsCallable` abstract operation
+// https://tc39.es/ecma262/#sec-iscallable
+var isCallable = $documentAll.IS_HTMLDDA ? function (argument) {
+  return typeof argument == 'function' || argument === documentAll;
+} : function (argument) {
+  return typeof argument == 'function';
+};
+
+export { isCallable as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/is-forced.js

@@ -0,0 +1,34 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import fails$1 from './fails.js';
+import isCallable$1 from './is-callable.js';
+
+var fails = fails$1;
+var isCallable = isCallable$1;
+
+var replacement = /#|\.prototype\./;
+
+var isForced = function (feature, detection) {
+  var value = data[normalize(feature)];
+  return value == POLYFILL ? true
+    : value == NATIVE ? false
+    : isCallable(detection) ? fails(detection)
+    : !!detection;
+};
+
+var normalize = isForced.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data = isForced.data = {};
+var NATIVE = isForced.NATIVE = 'N';
+var POLYFILL = isForced.POLYFILL = 'P';
+
+var isForced_1 = isForced;
+
+export { isForced_1 as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/is-null-or-undefined.js

@@ -0,0 +1,14 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+// we can't use just `it == null` since of `document.all` special case
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+var isNullOrUndefined = function (it) {
+  return it === null || it === undefined;
+};
+
+export { isNullOrUndefined as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/is-object.js

@@ -0,0 +1,22 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import isCallable$1 from './is-callable.js';
+import documentAll_1 from './document-all.js';
+
+var isCallable = isCallable$1;
+var $documentAll = documentAll_1;
+
+var documentAll = $documentAll.all;
+
+var isObject = $documentAll.IS_HTMLDDA ? function (it) {
+  return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;
+} : function (it) {
+  return typeof it == 'object' ? it !== null : isCallable(it);
+};
+
+export { isObject as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/is-symbol.js

@@ -0,0 +1,27 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import getBuiltIn$1 from './get-built-in.js';
+import isCallable$1 from './is-callable.js';
+import objectIsPrototypeOf from './object-is-prototype-of.js';
+import useSymbolAsUid from './use-symbol-as-uid.js';
+
+var getBuiltIn = getBuiltIn$1;
+var isCallable = isCallable$1;
+var isPrototypeOf = objectIsPrototypeOf;
+var USE_SYMBOL_AS_UID = useSymbolAsUid;
+
+var $Object = Object;
+
+var isSymbol = USE_SYMBOL_AS_UID ? function (it) {
+  return typeof it == 'symbol';
+} : function (it) {
+  var $Symbol = getBuiltIn('Symbol');
+  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+};
+
+export { isSymbol as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/length-of-array-like.js

@@ -0,0 +1,18 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import toLength$1 from './to-length.js';
+
+var toLength = toLength$1;
+
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+var lengthOfArrayLike = function (obj) {
+  return toLength(obj.length);
+};
+
+export { lengthOfArrayLike as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/make-built-in.js

@@ -0,0 +1,68 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { m as makeBuiltIn$1 } from '../../../_virtual/make-built-in.js';
+import fails$1 from './fails.js';
+import isCallable$1 from './is-callable.js';
+import hasOwnProperty_1 from './has-own-property.js';
+import descriptors from './descriptors.js';
+import functionName from './function-name.js';
+import inspectSource$1 from './inspect-source.js';
+import internalState from './internal-state.js';
+
+var fails = fails$1;
+var isCallable = isCallable$1;
+var hasOwn = hasOwnProperty_1;
+var DESCRIPTORS = descriptors;
+var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
+var inspectSource = inspectSource$1;
+var InternalStateModule = internalState;
+
+var enforceInternalState = InternalStateModule.enforce;
+var getInternalState = InternalStateModule.get;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty = Object.defineProperty;
+
+var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+});
+
+var TEMPLATE = String(String).split('String');
+
+var makeBuiltIn = makeBuiltIn$1.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(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
+    else value.name = name;
+  }
+  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+    defineProperty(value, 'length', { value: options.arity });
+  }
+  try {
+    if (options && hasOwn(options, 'constructor') && options.constructor) {
+      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
+    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+    } else if (value.prototype) value.prototype = undefined;
+  } catch (error) { /* empty */ }
+  var state = enforceInternalState(value);
+  if (!hasOwn(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(function toString() {
+  return isCallable(this) && getInternalState(this).source || inspectSource(this);
+}, 'toString');
+
+var exports = makeBuiltIn$1.exports;
+export { exports as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/math-trunc.js

@@ -0,0 +1,19 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+var ceil = Math.ceil;
+var floor = Math.floor;
+
+// `Math.trunc` method
+// https://tc39.es/ecma262/#sec-math.trunc
+// eslint-disable-next-line es/no-math-trunc -- safe
+var mathTrunc = Math.trunc || function trunc(x) {
+  var n = +x;
+  return (n > 0 ? floor : ceil)(n);
+};
+
+export { mathTrunc as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/object-define-property.js

@@ -0,0 +1,58 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __exports as objectDefineProperty } from '../../../_virtual/object-define-property.js';
+export { __exports as default } from '../../../_virtual/object-define-property.js';
+import descriptors from './descriptors.js';
+import ie8DomDefine from './ie8-dom-define.js';
+import v8PrototypeDefineBug from './v8-prototype-define-bug.js';
+import anObject$1 from './an-object.js';
+import toPropertyKey$1 from './to-property-key.js';
+
+var DESCRIPTORS = descriptors;
+var IE8_DOM_DEFINE = ie8DomDefine;
+var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
+var anObject = anObject$1;
+var toPropertyKey = toPropertyKey$1;
+
+var $TypeError = TypeError;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var $defineProperty = Object.defineProperty;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var ENUMERABLE = 'enumerable';
+var CONFIGURABLE = 'configurable';
+var WRITABLE = 'writable';
+
+// `Object.defineProperty` method
+// https://tc39.es/ecma262/#sec-object.defineproperty
+objectDefineProperty.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPropertyKey(P);
+  anObject(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 in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+        writable: false
+      };
+    }
+  } return $defineProperty(O, P, Attributes);
+} : $defineProperty : function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPropertyKey(P);
+  anObject(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return $defineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw $TypeError('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};

package/dist/melonjs.mjs/node_modules/core-js/internals/object-get-own-property-descriptor.js

@@ -0,0 +1,41 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __exports as objectGetOwnPropertyDescriptor } from '../../../_virtual/object-get-own-property-descriptor.js';
+export { __exports as default } from '../../../_virtual/object-get-own-property-descriptor.js';
+import descriptors from './descriptors.js';
+import functionCall from './function-call.js';
+import './object-property-is-enumerable.js';
+import createPropertyDescriptor$1 from './create-property-descriptor.js';
+import toIndexedObject$1 from './to-indexed-object.js';
+import toPropertyKey$1 from './to-property-key.js';
+import hasOwnProperty_1 from './has-own-property.js';
+import ie8DomDefine from './ie8-dom-define.js';
+import { __exports as objectPropertyIsEnumerable } from '../../../_virtual/object-property-is-enumerable.js';
+
+var DESCRIPTORS = descriptors;
+var call = functionCall;
+var propertyIsEnumerableModule = objectPropertyIsEnumerable;
+var createPropertyDescriptor = createPropertyDescriptor$1;
+var toIndexedObject = toIndexedObject$1;
+var toPropertyKey = toPropertyKey$1;
+var hasOwn = hasOwnProperty_1;
+var IE8_DOM_DEFINE = ie8DomDefine;
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+objectGetOwnPropertyDescriptor.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject(O);
+  P = toPropertyKey(P);
+  if (IE8_DOM_DEFINE) try {
+    return $getOwnPropertyDescriptor(O, P);
+  } catch (error) { /* empty */ }
+  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+};

package/dist/melonjs.mjs/node_modules/core-js/internals/object-get-own-property-names.js

@@ -0,0 +1,23 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __exports as objectGetOwnPropertyNames } from '../../../_virtual/object-get-own-property-names.js';
+export { __exports as default } from '../../../_virtual/object-get-own-property-names.js';
+import objectKeysInternal from './object-keys-internal.js';
+import enumBugKeys$1 from './enum-bug-keys.js';
+
+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/no-object-getownpropertynames -- safe
+objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return internalObjectKeys(O, hiddenKeys);
+};

package/dist/melonjs.mjs/node_modules/core-js/internals/object-get-own-property-symbols.js

@@ -0,0 +1,12 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __exports as objectGetOwnPropertySymbols } from '../../../_virtual/object-get-own-property-symbols.js';
+export { __exports as default } from '../../../_virtual/object-get-own-property-symbols.js';
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols;

package/dist/melonjs.mjs/node_modules/core-js/internals/object-is-prototype-of.js

@@ -0,0 +1,14 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import functionUncurryThis from './function-uncurry-this.js';
+
+var uncurryThis = functionUncurryThis;
+
+var objectIsPrototypeOf = uncurryThis({}.isPrototypeOf);
+
+export { objectIsPrototypeOf as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/object-keys-internal.js

@@ -0,0 +1,35 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import functionUncurryThis from './function-uncurry-this.js';
+import hasOwnProperty_1 from './has-own-property.js';
+import toIndexedObject$1 from './to-indexed-object.js';
+import arrayIncludes from './array-includes.js';
+import hiddenKeys$1 from './hidden-keys.js';
+
+var uncurryThis = functionUncurryThis;
+var hasOwn = hasOwnProperty_1;
+var toIndexedObject = toIndexedObject$1;
+var indexOf = arrayIncludes.indexOf;
+var hiddenKeys = hiddenKeys$1;
+
+var push = uncurryThis([].push);
+
+var objectKeysInternal = function (object, names) {
+  var O = toIndexedObject(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (hasOwn(O, key = names[i++])) {
+    ~indexOf(result, key) || push(result, key);
+  }
+  return result;
+};
+
+export { objectKeysInternal as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/object-property-is-enumerable.js

@@ -0,0 +1,23 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import { __exports as objectPropertyIsEnumerable } from '../../../_virtual/object-property-is-enumerable.js';
+export { __exports as default } from '../../../_virtual/object-property-is-enumerable.js';
+
+var $propertyIsEnumerable = {}.propertyIsEnumerable;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor && !$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(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;

package/dist/melonjs.mjs/node_modules/core-js/internals/ordinary-to-primitive.js

@@ -0,0 +1,28 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import functionCall from './function-call.js';
+import isCallable$1 from './is-callable.js';
+import isObject$1 from './is-object.js';
+
+var call = functionCall;
+var isCallable = isCallable$1;
+var isObject = isObject$1;
+
+var $TypeError = TypeError;
+
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+var ordinaryToPrimitive = function (input, pref) {
+  var fn, val;
+  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
+  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+  throw $TypeError("Can't convert object to primitive value");
+};
+
+export { ordinaryToPrimitive as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/own-keys.js

@@ -0,0 +1,31 @@
+/*!
+ * melonJS Game Engine - v14.1.3
+ * http://www.melonjs.org
+ * melonjs is licensed under the MIT License.
+ * http://www.opensource.org/licenses/mit-license
+ * @copyright (C) 2011 - 2022 Olivier Biot (AltByte Pte Ltd)
+ */
+import getBuiltIn$1 from './get-built-in.js';
+import functionUncurryThis from './function-uncurry-this.js';
+import './object-get-own-property-names.js';
+import './object-get-own-property-symbols.js';
+import anObject$1 from './an-object.js';
+import { __exports as objectGetOwnPropertyNames } from '../../../_virtual/object-get-own-property-names.js';
+import { __exports as objectGetOwnPropertySymbols } from '../../../_virtual/object-get-own-property-symbols.js';
+
+var getBuiltIn = getBuiltIn$1;
+var uncurryThis = functionUncurryThis;
+var getOwnPropertyNamesModule = objectGetOwnPropertyNames;
+var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
+var anObject = anObject$1;
+
+var concat = uncurryThis([].concat);
+
+// all object keys, includes non-enumerable and symbols
+var ownKeys = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+export { ownKeys as default };