melonjs 14.3.0 → 14.5.0

package/src/video/webgl/compositors/webgl_compositor.js

@@ -0,0 +1,300 @@
+import Vector2d from "../../../math/vector2.js";
+import GLShader from "../glshader.js";
+import VertexArrayBuffer from "../buffer/vertex.js";
+import { isPowerOfTwo } from "../../../math/math.js";
+import primitiveVertex from "./../shaders/primitive.vert";
+import primitiveFragment from "./../shaders/primitive.frag";
+import quadVertex from "./../shaders/quad.vert";
+import quadFragment from "./../shaders/quad.frag";
+import Compositor from "./compositor.js";
+
+// a pool of resuable vectors
+var V_ARRAY = [
+    new Vector2d(),
+    new Vector2d(),
+    new Vector2d(),
+    new Vector2d()
+];
+
+/**
+ * @classdesc
+ * A WebGL Compositor object. This class handles all of the WebGL state<br>
+ * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
+ * @augments Compositor
+ */
+ export default class WebGLCompositor extends Compositor {
+
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init (renderer) {
+        super.init(renderer);
+
+        // list of active texture units
+        this.currentTextureUnit = -1;
+        this.boundTextures = [];
+
+        // Load and create shader programs
+        this.primitiveShader = new GLShader(this.gl, primitiveVertex, primitiveFragment);
+        this.quadShader = new GLShader(this.gl, quadVertex, quadFragment);
+
+        /// define all vertex attributes
+        this.addAttribute("aVertex", 2, this.gl.FLOAT, false, 0 * Float32Array.BYTES_PER_ELEMENT); // 0
+        this.addAttribute("aRegion", 2, this.gl.FLOAT, false, 2 * Float32Array.BYTES_PER_ELEMENT); // 1
+        this.addAttribute("aColor",  4, this.gl.UNSIGNED_BYTE, true, 4 * Float32Array.BYTES_PER_ELEMENT); // 2
+
+        this.vertexBuffer = new VertexArrayBuffer(this.vertexSize, 6); // 6 vertices per quad
+
+        // vertex buffer
+        this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.gl.createBuffer());
+        this.gl.bufferData(this.gl.ARRAY_BUFFER, this.vertexBuffer.buffer, this.gl.STREAM_DRAW);
+    }
+
+    /**
+     * Reset compositor internal state
+     * @ignore
+     */
+    reset() {
+        super.reset();
+
+        // delete all related bound texture
+        for (var i = 0; i < this.renderer.maxTextures; i++) {
+            var texture2D = this.getTexture2D(i);
+            if (typeof texture2D !== "undefined") {
+                this.deleteTexture2D(texture2D);
+            }
+        }
+        this.currentTextureUnit = -1;
+
+        // set the quad shader as the default program
+        this.useShader(this.quadShader);
+    }
+
+    /**
+     * Create a WebGL texture from an image
+     * @param {number} unit - Destination texture unit
+     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} image - Source image
+     * @param {number} filter - gl.LINEAR or gl.NEAREST
+     * @param {string} [repeat="no-repeat"] - Image repeat behavior (see {@link ImageLayer#repeat})
+     * @param {number} [w] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [h] - Source image height (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [b] - Source image border (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {boolean} [premultipliedAlpha=true] - Multiplies the alpha channel into the other color channels
+     * @param {boolean} [mipmap=true] - Whether mipmap levels should be generated for this texture
+     * @returns {WebGLTexture} a WebGL texture
+     */
+    createTexture2D(unit, image, filter, repeat = "no-repeat", w, h, b, premultipliedAlpha = true, mipmap = true) {
+        var gl = this.gl;
+        var isPOT = isPowerOfTwo(w || image.width) && isPowerOfTwo(h || image.height);
+        var texture = gl.createTexture();
+        var rs = (repeat.search(/^repeat(-x)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+        var rt = (repeat.search(/^repeat(-y)?$/) === 0) && (isPOT || this.renderer.WebGLVersion > 1) ? gl.REPEAT : gl.CLAMP_TO_EDGE;
+
+        this.bindTexture2D(texture, unit);
+
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, rs);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, rt);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filter);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filter);
+        gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultipliedAlpha);
+        if (w || h || b) {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, w, h, b, gl.RGBA, gl.UNSIGNED_BYTE, image);
+        }
+        else {
+            gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+        }
+
+        // generate the sprite mimap (used when scaling) if a PowerOfTwo texture
+        if (isPOT && mipmap !== false) {
+            gl.generateMipmap(gl.TEXTURE_2D);
+        }
+
+        return texture;
+    }
+
+    /**
+     * delete the given WebGL texture
+     * @param {WebGLTexture} [texture] - a WebGL texture to delete
+     * @param {number} [unit] - Texture unit to delete
+     */
+    deleteTexture2D(texture) {
+        this.gl.deleteTexture(texture);
+        this.unbindTexture2D(texture);
+    }
+
+    /**
+     * returns the WebGL texture associated to the given texture unit
+     * @param {number} unit - Texture unit to which a texture is bound
+     * @returns {WebGLTexture} texture a WebGL texture
+     */
+    getTexture2D(unit) {
+        return this.boundTextures[unit];
+    }
+
+    /**
+     * assign the given WebGL texture to the current batch
+     * @param {WebGLTexture} texture - a WebGL texture
+     * @param {number} unit - Texture unit to which the given texture is bound
+     */
+    bindTexture2D(texture, unit) {
+        var gl = this.gl;
+
+        if (texture !== this.boundTextures[unit]) {
+            this.flush();
+            if (this.currentTextureUnit !== unit) {
+                this.currentTextureUnit = unit;
+                gl.activeTexture(gl.TEXTURE0 + unit);
+            }
+
+            gl.bindTexture(gl.TEXTURE_2D, texture);
+            this.boundTextures[unit] = texture;
+
+        } else if (this.currentTextureUnit !== unit) {
+            this.flush();
+            this.currentTextureUnit = unit;
+            gl.activeTexture(gl.TEXTURE0 + unit);
+        }
+    }
+
+    /**
+     * unbind the given WebGL texture, forcing it to be reuploaded
+     * @param {WebGLTexture} [texture] - a WebGL texture
+     * @param {number} [unit] - a WebGL texture
+     * @returns {number} unit the unit number that was associated with the given texture
+     */
+    unbindTexture2D(texture, unit) {
+        if (typeof unit === "undefined") {
+            unit = this.boundTextures.indexOf(texture);
+        }
+        if (unit !== -1) {
+            delete this.boundTextures[unit];
+            if (unit === this.currentTextureUnit) {
+                this.currentTextureUnit = -1;
+            }
+        }
+        return unit;
+    }
+
+    /**
+     * @ignore
+     */
+    uploadTexture(texture, w, h, b, force = false) {
+        var unit = this.renderer.cache.getUnit(texture);
+        var texture2D = this.boundTextures[unit];
+
+        if (typeof texture2D === "undefined" || force) {
+            this.createTexture2D(
+                unit,
+                texture.getTexture(),
+                this.renderer.settings.antiAlias ? this.gl.LINEAR : this.gl.NEAREST,
+                texture.repeat,
+                w,
+                h,
+                b,
+                texture.premultipliedAlpha
+            );
+        } else {
+            this.bindTexture2D(texture2D, unit);
+        }
+
+        return this.currentTextureUnit;
+    }
+
+
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader) {
+        if (this.activeShader !== shader) {
+            this.flush();
+            this.activeShader = shader;
+            this.activeShader.bind();
+            this.activeShader.setUniform("uProjectionMatrix", this.renderer.projectionMatrix);
+            this.activeShader.setVertexAttributes(this.gl, this.attributes, this.vertexByteSize);
+        }
+    }
+
+    /**
+     * Add a textured quad
+     * @param {TextureAtlas} texture - Source texture atlas
+     * @param {number} x - Destination x-coordinate
+     * @param {number} y - Destination y-coordinate
+     * @param {number} w - Destination width
+     * @param {number} h - Destination height
+     * @param {number} u0 - Texture UV (u0) value.
+     * @param {number} v0 - Texture UV (v0) value.
+     * @param {number} u1 - Texture UV (u1) value.
+     * @param {number} v1 - Texture UV (v1) value.
+     * @param {number} tint - tint color to be applied to the texture in UINT32 (argb) format
+     */
+    addQuad(texture, x, y, w, h, u0, v0, u1, v1, tint) {
+
+        if (this.color.alpha < 1 / 255) {
+            // Fast path: don't send fully transparent quads
+            return;
+        }
+
+        this.useShader(this.quadShader);
+
+        if (this.vertexBuffer.isFull(6)) {
+            // is the vertex buffer full if we add 6 more vertices
+            this.flush();
+        }
+
+        // upload and activate the texture if necessary
+        var unit = this.uploadTexture(texture);
+        // set fragement sampler accordingly
+        this.quadShader.setUniform("uSampler", unit);
+
+        // Transform vertices
+        var m = this.viewMatrix,
+            vec0 = V_ARRAY[0].set(x, y),
+            vec1 = V_ARRAY[1].set(x + w, y),
+            vec2 = V_ARRAY[2].set(x, y + h),
+            vec3 = V_ARRAY[3].set(x + w, y + h);
+
+        if (!m.isIdentity()) {
+            m.apply(vec0);
+            m.apply(vec1);
+            m.apply(vec2);
+            m.apply(vec3);
+        }
+
+        this.vertexBuffer.push(vec0.x, vec0.y, u0, v0, tint);
+        this.vertexBuffer.push(vec1.x, vec1.y, u1, v0, tint);
+        this.vertexBuffer.push(vec2.x, vec2.y, u0, v1, tint);
+        this.vertexBuffer.push(vec2.x, vec2.y, u0, v1, tint);
+        this.vertexBuffer.push(vec1.x, vec1.y, u1, v0, tint);
+        this.vertexBuffer.push(vec3.x, vec3.y, u1, v1, tint);
+    }
+
+    /**
+     * Draw an array of vertices
+     * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
+     * @param {Point[]} verts - an array of vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(mode, verts, vertexCount = verts.length) {
+        // use the primitive shader
+        this.useShader(this.primitiveShader);
+        // Set the line color
+        this.primitiveShader.setUniform("uColor", this.color);
+
+        var m = this.viewMatrix;
+        var vertex = this.vertexBuffer;
+        var m_isIdentity = m.isIdentity();
+
+        for (var i = 0; i < vertexCount; i++) {
+            if (!m_isIdentity) {
+                m.apply(verts[i]);
+            }
+            vertex.push(verts[i].x, verts[i].y);
+        }
+
+        // flush
+        this.flush(mode);
+    }
+}

package/src/video/webgl/webgl_renderer.js

@@ -1,6 +1,6 @@
 import Color from "./../../math/color.js";
 import Matrix2d from "./../../math/matrix2.js";
-import WebGLCompositor from "./webgl_compositor.js";
+import WebGLCompositor from "./compositors/webgl_compositor.js";
 import Renderer from "./../renderer.js";
 import TextureCache from "./../texture/cache.js";
 import { TextureAtlas, createAtlas } from "./../texture/atlas.js";

package/dist/melonjs.mjs/node_modules/core-js/es/string/trim-end.js

@@ -1,13 +0,0 @@
-/*!
- * 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 '../../modules/es.string.trim-end.js';
-import entryUnbind$1 from '../../internals/entry-unbind.js';
-
-var entryUnbind = entryUnbind$1;
-
-entryUnbind('String', 'trimRight');

package/dist/melonjs.mjs/node_modules/core-js/es/string/trim-start.js

@@ -1,13 +0,0 @@
-/*!
- * 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 '../../modules/es.string.trim-start.js';
-import entryUnbind$1 from '../../internals/entry-unbind.js';
-
-var entryUnbind = entryUnbind$1;
-
-entryUnbind('String', 'trimLeft');

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

@@ -1,22 +0,0 @@
-/*!
- * 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 tryToString$1 from './try-to-string.js';
-
-var isCallable = isCallable$1;
-var tryToString = tryToString$1;
-
-var $TypeError = TypeError;
-
-// `Assert: IsCallable(argument) is true`
-var aCallable = function (argument) {
-  if (isCallable(argument)) return argument;
-  throw $TypeError(tryToString(argument) + ' is not a function');
-};
-
-export { aCallable as default };

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

@@ -1,21 +0,0 @@
-/*!
- * 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 isObject$1 from './is-object.js';
-
-var isObject = isObject$1;
-
-var $String = String;
-var $TypeError = TypeError;
-
-// `Assert: Type(argument) is Object`
-var anObject = function (argument) {
-  if (isObject(argument)) return argument;
-  throw $TypeError($String(argument) + ' is not an object');
-};
-
-export { anObject as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/array-includes.js

@@ -1,45 +0,0 @@
-/*!
- * 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 toIndexedObject$1 from './to-indexed-object.js';
-import toAbsoluteIndex$1 from './to-absolute-index.js';
-import lengthOfArrayLike$1 from './length-of-array-like.js';
-
-var toIndexedObject = toIndexedObject$1;
-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($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)
-};
-
-export { arrayIncludes as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/classof-raw.js

@@ -1,19 +0,0 @@
-/*!
- * 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 toString = uncurryThis({}.toString);
-var stringSlice = uncurryThis(''.slice);
-
-var classofRaw = function (it) {
-  return stringSlice(toString(it), 8, -1);
-};
-
-export { classofRaw as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/classof.js

@@ -1,43 +0,0 @@
-/*!
- * 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 toStringTagSupport from './to-string-tag-support.js';
-import isCallable$1 from './is-callable.js';
-import classofRaw$1 from './classof-raw.js';
-import wellKnownSymbol$1 from './well-known-symbol.js';
-
-var TO_STRING_TAG_SUPPORT = toStringTagSupport;
-var isCallable = isCallable$1;
-var classofRaw = classofRaw$1;
-var wellKnownSymbol = wellKnownSymbol$1;
-
-var TO_STRING_TAG = wellKnownSymbol('toStringTag');
-var $Object = Object;
-
-// ES3 wrong here
-var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
-
-// fallback for IE11 Script Access Denied error
-var tryGet = function (it, key) {
-  try {
-    return it[key];
-  } catch (error) { /* empty */ }
-};
-
-// getting tag from ES6+ `Object.prototype.toString`
-var classof = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
-  var O, tag, result;
-  return it === undefined ? 'Undefined' : it === null ? 'Null'
-    // @@toStringTag case
-    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
-    // builtinTag case
-    : CORRECT_ARGUMENTS ? classofRaw(O)
-    // ES3 arguments fallback
-    : (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
-};
-
-export { classof as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/copy-constructor-properties.js

@@ -1,32 +0,0 @@
-/*!
- * 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 hasOwnProperty_1 from './has-own-property.js';
-import ownKeys$1 from './own-keys.js';
-import './object-get-own-property-descriptor.js';
-import './object-define-property.js';
-import { __exports as objectDefineProperty } from '../../../_virtual/object-define-property.js';
-import { __exports as objectGetOwnPropertyDescriptor } from '../../../_virtual/object-get-own-property-descriptor.js';
-
-var hasOwn = hasOwnProperty_1;
-var ownKeys = ownKeys$1;
-var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor;
-var definePropertyModule = objectDefineProperty;
-
-var copyConstructorProperties = 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));
-    }
-  }
-};
-
-export { copyConstructorProperties as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/create-non-enumerable-property.js

@@ -1,24 +0,0 @@
-/*!
- * 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 descriptors from './descriptors.js';
-import './object-define-property.js';
-import createPropertyDescriptor$1 from './create-property-descriptor.js';
-import { __exports as objectDefineProperty } from '../../../_virtual/object-define-property.js';
-
-var DESCRIPTORS = descriptors;
-var definePropertyModule = objectDefineProperty;
-var createPropertyDescriptor = createPropertyDescriptor$1;
-
-var createNonEnumerableProperty = DESCRIPTORS ? function (object, key, value) {
-  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
-} : function (object, key, value) {
-  object[key] = value;
-  return object;
-};
-
-export { createNonEnumerableProperty as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/create-property-descriptor.js

@@ -1,17 +0,0 @@
-/*!
- * 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 createPropertyDescriptor = function (bitmap, value) {
-  return {
-    enumerable: !(bitmap & 1),
-    configurable: !(bitmap & 2),
-    writable: !(bitmap & 4),
-    value: value
-  };
-};
-
-export { createPropertyDescriptor as default };

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

@@ -1,43 +0,0 @@
-/*!
- * 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 './object-define-property.js';
-import './make-built-in.js';
-import defineGlobalProperty$1 from './define-global-property.js';
-import { __exports as objectDefineProperty } from '../../../_virtual/object-define-property.js';
-import { m as makeBuiltIn$1 } from '../../../_virtual/make-built-in.js';
-
-var isCallable = isCallable$1;
-var definePropertyModule = objectDefineProperty;
-var makeBuiltIn = makeBuiltIn$1.exports;
-var defineGlobalProperty = defineGlobalProperty$1;
-
-var defineBuiltIn = function (O, key, value, options) {
-  if (!options) options = {};
-  var simple = options.enumerable;
-  var name = options.name !== undefined ? options.name : key;
-  if (isCallable(value)) makeBuiltIn(value, name, options);
-  if (options.global) {
-    if (simple) O[key] = value;
-    else defineGlobalProperty(key, value);
-  } else {
-    try {
-      if (!options.unsafe) delete O[key];
-      else if (O[key]) simple = true;
-    } catch (error) { /* empty */ }
-    if (simple) O[key] = value;
-    else definePropertyModule.f(O, key, {
-      value: value,
-      enumerable: false,
-      configurable: !options.nonConfigurable,
-      writable: !options.nonWritable
-    });
-  } return O;
-};
-
-export { defineBuiltIn as default };

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

@@ -1,23 +0,0 @@
-/*!
- * 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 global$1 from './global.js';
-
-var global = global$1;
-
-// eslint-disable-next-line es/no-object-defineproperty -- safe
-var defineProperty = Object.defineProperty;
-
-var defineGlobalProperty = function (key, value) {
-  try {
-    defineProperty(global, key, { value: value, configurable: true, writable: true });
-  } catch (error) {
-    global[key] = value;
-  } return value;
-};
-
-export { defineGlobalProperty as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/descriptors.js

@@ -1,18 +0,0 @@
-/*!
- * 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';
-
-var fails = fails$1;
-
-// Detect IE8's incomplete defineProperty implementation
-var descriptors = !fails(function () {
-  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
-  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
-});
-
-export { descriptors as default };

package/dist/melonjs.mjs/node_modules/core-js/internals/document-all.js

@@ -1,18 +0,0 @@
-/*!
- * 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 documentAll = typeof document == 'object' && document.all;
-
-// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
-var IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;
-
-var documentAll_1 = {
-  all: documentAll,
-  IS_HTMLDDA: IS_HTMLDDA
-};
-
-export { documentAll_1 as default };