pixi.js 7.0.4 → 7.0.5

package/dist/pixi.js

@@ -1,6 +1,6 @@
 /*!
- * pixi.js - v7.0.4
- * Compiled Fri, 11 Nov 2022 12:31:03 UTC
+ * pixi.js - v7.0.5
+ * Compiled Mon, 12 Dec 2022 15:56:40 UTC
  *
  * pixi.js is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -211,7 +211,11 @@ var PIXI = (function (exports) {
     getNavigator: () => navigator,
     getBaseUrl: () => document.baseURI ?? window.location.href,
     getFontFaceSet: () => document.fonts,
-    fetch: (url, options) => fetch(url, options)
+    fetch: (url, options) => fetch(url, options),
+    parseXML: (xml) => {
+      const parser = new DOMParser();
+      return parser.parseFromString(xml, "text/xml");
+    }
   };
 
   var appleIphone = /iPhone/i;
@@ -385,7 +389,7 @@ var PIXI = (function (exports) {
       autoDensity: false,
       backgroundColor: 0,
       backgroundAlpha: 1,
-      useContextAlpha: true,
+      premultipliedAlpha: true,
       clearBeforeRender: true,
       preserveDrawingBuffer: false,
       width: 800,
@@ -424,6 +428,9 @@ var PIXI = (function (exports) {
   })(ExtensionType || {});
   const normalizeExtension = (ext) => {
     if (typeof ext === "function" || typeof ext === "object" && ext.extension) {
+      if (!ext.extension) {
+        throw new Error("Extension class must have an extension object");
+      }
       const metadata = typeof ext.extension !== "object" ? { type: ext.extension } : ext.extension;
       ext = { ...metadata, ref: ext };
     }
@@ -437,6 +444,7 @@ var PIXI = (function (exports) {
     }
     return ext;
   };
+  const normalizePriority = (ext, defaultPriority) => normalizeExtension(ext).priority ?? defaultPriority;
   const extensions$1 = {
     _addHandlers: {},
     _removeHandlers: {},
@@ -465,6 +473,9 @@ var PIXI = (function (exports) {
     handle(type, onAdd, onRemove) {
       const addHandlers = this._addHandlers;
       const removeHandlers = this._removeHandlers;
+      if (addHandlers[type] || removeHandlers[type]) {
+        throw new Error(`Extension type ${type} already has a handler`);
+      }
       addHandlers[type] = onAdd;
       removeHandlers[type] = onRemove;
       const queue = this._queue;
@@ -481,13 +492,13 @@ var PIXI = (function (exports) {
         delete map[extension.name];
       });
     },
-    handleByList(type, list) {
+    handleByList(type, list, defaultPriority = -1) {
       return this.handle(type, (extension) => {
         if (list.includes(extension.ref)) {
           return;
         }
         list.push(extension.ref);
-        list.sort((a, b) => (b.priority ?? -1) - (a.priority ?? -1));
+        list.sort((a, b) => normalizePriority(b, defaultPriority) - normalizePriority(a, defaultPriority));
       }, (extension) => {
         const index = list.indexOf(extension.ref);
         if (index !== -1) {
@@ -535,6 +546,9 @@ var PIXI = (function (exports) {
       this.y = y;
       return this;
     }
+    toString() {
+      return `[@pixi/math:Point x=${this.x} y=${this.y}]`;
+    }
   }
 
   const tempPoints$1 = [new Point(), new Point(), new Point(), new Point()];
@@ -683,6 +697,9 @@ var PIXI = (function (exports) {
       this.height = y2 - y1;
       return this;
     }
+    toString() {
+      return `[@pixi/math:Rectangle x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`;
+    }
   }
 
   class Circle {
@@ -709,6 +726,9 @@ var PIXI = (function (exports) {
     getBounds() {
       return new Rectangle(this.x - this.radius, this.y - this.radius, this.radius * 2, this.radius * 2);
     }
+    toString() {
+      return `[@pixi/math:Circle x=${this.x} y=${this.y} radius=${this.radius}]`;
+    }
   }
 
   class Ellipse {
@@ -735,6 +755,9 @@ var PIXI = (function (exports) {
     getBounds() {
       return new Rectangle(this.x - this.width, this.y - this.height, this.width, this.height);
     }
+    toString() {
+      return `[@pixi/math:Ellipse x=${this.x} y=${this.y} width=${this.width} height=${this.height}]`;
+    }
   }
 
   class Polygon {
@@ -772,6 +795,9 @@ var PIXI = (function (exports) {
       }
       return inside;
     }
+    toString() {
+      return `[@pixi/math:PolygoncloseStroke=${this.closeStroke}points=${this.points.reduce((pointsDesc, currentPoint) => `${pointsDesc}, ${currentPoint}`, "")}]`;
+    }
   }
 
   class RoundedRectangle {
@@ -818,6 +844,9 @@ var PIXI = (function (exports) {
       }
       return false;
     }
+    toString() {
+      return `[@pixi/math:RoundedRectangle x=${this.x} y=${this.y}width=${this.width} height=${this.height} radius=${this.radius}]`;
+    }
   }
 
   class ObservablePoint {
@@ -853,6 +882,9 @@ var PIXI = (function (exports) {
     equals(p) {
       return p.x === this._x && p.y === this._y;
     }
+    toString() {
+      return `[@pixi/math:ObservablePoint x=${0} y=${0} scope=${this.scope}]`;
+    }
     get x() {
       return this._x;
     }
@@ -1084,6 +1116,9 @@ var PIXI = (function (exports) {
       this.ty = matrix.ty;
       return this;
     }
+    toString() {
+      return `[@pixi/math:Matrix a=${this.a} b=${this.b} c=${this.c} d=${this.d} tx=${this.tx} ty=${this.ty}]`;
+    }
     static get IDENTITY() {
       return new Matrix();
     }
@@ -1207,6 +1242,9 @@ var PIXI = (function (exports) {
       this._sy = Math.cos(this._rotation - this.skew.x);
       this._localID++;
     }
+    toString() {
+      return `[@pixi/math:Transform position=(${this.position.x}, ${this.position.y}) rotation=${this.rotation} scale=(${this.scale.x}, ${this.scale.y}) skew=(${this.skew.x}, ${this.skew.y}) ]`;
+    }
     updateLocalTransform() {
       const lt = this.localTransform;
       if (this._localID !== this._currentLocalID) {
@@ -4533,9 +4571,36 @@ var PIXI = (function (exports) {
   settings.RETINA_PREFIX = /@([0-9\.]+)x/;
   settings.FAIL_IF_MAJOR_PERFORMANCE_CAVEAT = false;
 
+  const warnings = {};
+  function deprecation(version, message, ignoreDepth = 3) {
+    if (warnings[message]) {
+      return;
+    }
+    let stack = new Error().stack;
+    if (typeof stack === "undefined") {
+      console.warn("PixiJS Deprecation Warning: ", `${message}
+Deprecated since v${version}`);
+    } else {
+      stack = stack.split("\n").splice(ignoreDepth).join("\n");
+      if (console.groupCollapsed) {
+        console.groupCollapsed("%cPixiJS Deprecation Warning: %c%s", "color:#614108;background:#fffbe6", "font-weight:normal;color:#614108;background:#fffbe6", `${message}
+Deprecated since v${version}`);
+        console.warn(stack);
+        console.groupEnd();
+      } else {
+        console.warn("PixiJS Deprecation Warning: ", `${message}
+Deprecated since v${version}`);
+        console.warn(stack);
+      }
+    }
+    warnings[message] = true;
+  }
+
   function skipHello() {
+    deprecation("7.0.0", "skipHello is deprecated, please use PIXI.settings.RENDER_OPTIONS.hello");
   }
   function sayHello() {
+    deprecation("7.0.0", `sayHello is deprecated, please use Renderer's "hello" option`);
   }
 
   let supported;
@@ -5081,31 +5146,6 @@ var PIXI = (function (exports) {
     return ++nextUid;
   }
 
-  const warnings = {};
-  function deprecation(version, message, ignoreDepth = 3) {
-    if (warnings[message]) {
-      return;
-    }
-    let stack = new Error().stack;
-    if (typeof stack === "undefined") {
-      console.warn("PixiJS Deprecation Warning: ", `${message}
-Deprecated since v${version}`);
-    } else {
-      stack = stack.split("\n").splice(ignoreDepth).join("\n");
-      if (console.groupCollapsed) {
-        console.groupCollapsed("%cPixiJS Deprecation Warning: %c%s", "color:#614108;background:#fffbe6", "font-weight:normal;color:#614108;background:#fffbe6", `${message}
-Deprecated since v${version}`);
-        console.warn(stack);
-        console.groupEnd();
-      } else {
-        console.warn("PixiJS Deprecation Warning: ", `${message}
-Deprecated since v${version}`);
-        console.warn(stack);
-      }
-    }
-    warnings[message] = true;
-  }
-
   const ProgramCache = {};
   const TextureCache = /* @__PURE__ */ Object.create(null);
   const BaseTextureCache = /* @__PURE__ */ Object.create(null);
@@ -5161,58 +5201,49 @@ Deprecated since v${version}`);
     }
   }
 
+  function checkRow(data, width, y) {
+    for (let x = 0, index = 4 * y * width; x < width; ++x, index += 4) {
+      if (data[index + 3] !== 0)
+        return false;
+    }
+    return true;
+  }
+  function checkColumn(data, width, x, top, bottom) {
+    const stride = 4 * width;
+    for (let y = top, index = top * stride + 4 * x; y <= bottom; ++y, index += stride) {
+      if (data[index + 3] !== 0)
+        return false;
+    }
+    return true;
+  }
   function trimCanvas(canvas) {
-    let width = canvas.width;
-    let height = canvas.height;
+    let { width, height } = canvas;
     const context = canvas.getContext("2d", {
       willReadFrequently: true
     });
     const imageData = context.getImageData(0, 0, width, height);
-    const pixels = imageData.data;
-    const len = pixels.length;
-    const bound = {
-      top: null,
-      left: null,
-      right: null,
-      bottom: null
-    };
-    let data = null;
-    let i;
-    let x;
-    let y;
-    for (i = 0; i < len; i += 4) {
-      if (pixels[i + 3] !== 0) {
-        x = i / 4 % width;
-        y = ~~(i / 4 / width);
-        if (bound.top === null) {
-          bound.top = y;
-        }
-        if (bound.left === null) {
-          bound.left = x;
-        } else if (x < bound.left) {
-          bound.left = x;
-        }
-        if (bound.right === null) {
-          bound.right = x + 1;
-        } else if (bound.right < x) {
-          bound.right = x + 1;
-        }
-        if (bound.bottom === null) {
-          bound.bottom = y;
-        } else if (bound.bottom < y) {
-          bound.bottom = y;
-        }
-      }
-    }
-    if (bound.top !== null) {
-      width = bound.right - bound.left;
-      height = bound.bottom - bound.top + 1;
-      data = context.getImageData(bound.left, bound.top, width, height);
-    }
+    const data = imageData.data;
+    let top = 0;
+    let bottom = height - 1;
+    let left = 0;
+    let right = width - 1;
+    while (top < height && checkRow(data, width, top))
+      ++top;
+    if (top === height) {
+      return { width: 0, height: 0, data: null };
+    }
+    while (checkRow(data, width, bottom))
+      --bottom;
+    while (checkColumn(data, width, left, top, bottom))
+      ++left;
+    while (checkColumn(data, width, right, top, bottom))
+      --right;
+    width = right - left + 1;
+    height = bottom - top + 1;
     return {
-      height,
       width,
-      data
+      height,
+      data: context.getImageData(left, top, width, height)
     };
   }
 
@@ -5638,7 +5669,7 @@ Deprecated since v${version}`);
         if (!baseTexture.textureCacheIds.includes(id)) {
           baseTexture.textureCacheIds.push(id);
         }
-        if (BaseTextureCache[id]) {
+        if (BaseTextureCache[id] && BaseTextureCache[id] !== baseTexture) {
           console.warn(`BaseTexture added to the cache with an id [${id}] that already had an entry`);
         }
         BaseTextureCache[id] = baseTexture;
@@ -6606,6 +6637,9 @@ Deprecated since v${version}`);
       this.uvsFloat32[6] = this.x3;
       this.uvsFloat32[7] = this.y3;
     }
+    toString() {
+      return `[@pixi/core:TextureUvs x0=${this.x0} y0=${this.y0} x1=${this.x1} y1=${this.y1} x2=${this.x2} y2=${this.y2} x3=${this.x3} y3=${this.y3}]`;
+    }
   }
 
   const DEFAULT_UVS = new TextureUvs();
@@ -6795,7 +6829,7 @@ Deprecated since v${version}`);
         if (!texture.textureCacheIds.includes(id)) {
           texture.textureCacheIds.push(id);
         }
-        if (TextureCache[id]) {
+        if (TextureCache[id] && TextureCache[id] !== texture) {
           console.warn(`Texture added to the cache with an id [${id}] that already had an entry`);
         }
         TextureCache[id] = texture;
@@ -7443,7 +7477,7 @@ Deprecated since v${version}`);
   }
 
   const tempPoints = [new Point(), new Point(), new Point(), new Point()];
-  const tempMatrix$1 = new Matrix();
+  const tempMatrix$2 = new Matrix();
   class FilterSystem {
     constructor(renderer) {
       this.renderer = renderer;
@@ -7499,7 +7533,7 @@ Deprecated since v${version}`);
       state.sourceFrame.pad(padding);
       const sourceFrameProjected = this.tempRect.copyFrom(renderTextureSystem.sourceFrame);
       if (renderer.projection.transform) {
-        this.transformAABB(tempMatrix$1.copyFrom(renderer.projection.transform).invert(), sourceFrameProjected);
+        this.transformAABB(tempMatrix$2.copyFrom(renderer.projection.transform).invert(), sourceFrameProjected);
       }
       if (autoFit) {
         state.sourceFrame.fit(sourceFrameProjected);
@@ -7705,7 +7739,7 @@ Deprecated since v${version}`);
           return;
         }
       }
-      transform = transform ? tempMatrix$1.copyFrom(transform) : tempMatrix$1.identity();
+      transform = transform ? tempMatrix$2.copyFrom(transform) : tempMatrix$2.identity();
       transform.translate(-bindingSourceFrame.x, -bindingSourceFrame.y).scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height).translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
       this.transformAABB(transform, frame);
       frame.ceil(resolution);
@@ -7817,16 +7851,13 @@ Deprecated since v${version}`);
       this.gl = gl;
       this.renderer.gl = gl;
       this.renderer.CONTEXT_UID = CONTEXT_UID_COUNTER++;
-      if (gl.isContextLost() && gl.getExtension("WEBGL_lose_context")) {
-        gl.getExtension("WEBGL_lose_context").restoreContext();
-      }
     }
     init(options) {
       if (options.context) {
         this.initFromContext(options.context);
       } else {
         const alpha = this.renderer.background.alpha < 1;
-        const premultipliedAlpha = options.premultipliedAlpha ?? true;
+        const premultipliedAlpha = options.premultipliedAlpha;
         this.preserveDrawingBuffer = options.preserveDrawingBuffer;
         this.useContextAlpha = options.useContextAlpha;
         this.powerPreference = options.powerPreference;
@@ -7877,6 +7908,7 @@ Deprecated since v${version}`);
     getExtensions() {
       const { gl } = this;
       const common = {
+        loseContext: gl.getExtension("WEBGL_lose_context"),
         anisotropicFiltering: gl.getExtension("EXT_texture_filter_anisotropic"),
         floatTextureLinear: gl.getExtension("OES_texture_float_linear"),
         s3tc: gl.getExtension("WEBGL_compressed_texture_s3tc"),
@@ -7891,7 +7923,6 @@ Deprecated since v${version}`);
         Object.assign(this.extensions, common, {
           drawBuffers: gl.getExtension("WEBGL_draw_buffers"),
           depthTexture: gl.getExtension("WEBGL_depth_texture"),
-          loseContext: gl.getExtension("WEBGL_lose_context"),
           vertexArrayObject: gl.getExtension("OES_vertex_array_object") || gl.getExtension("MOZ_OES_vertex_array_object") || gl.getExtension("WEBKIT_OES_vertex_array_object"),
           uint32ElementIndex: gl.getExtension("OES_element_index_uint"),
           floatTexture: gl.getExtension("OES_texture_float"),
@@ -7907,6 +7938,11 @@ Deprecated since v${version}`);
     }
     handleContextLost(event) {
       event.preventDefault();
+      setTimeout(() => {
+        if (this.gl.isContextLost() && this.extensions.loseContext) {
+          this.extensions.loseContext.restoreContext();
+        }
+      }, 0);
     }
     handleContextRestored() {
       this.renderer.runners.contextChange.emit(this.gl);
@@ -7973,13 +8009,13 @@ Deprecated since v${version}`);
       this.msaaSamples = null;
     }
     contextChange() {
+      this.disposeAll(true);
       const gl = this.gl = this.renderer.gl;
       this.CONTEXT_UID = this.renderer.CONTEXT_UID;
       this.current = this.unknownFramebuffer;
       this.viewport = new Rectangle();
       this.hasMRT = true;
       this.writeDepthTexture = true;
-      this.disposeAll(true);
       if (this.renderer.context.webGLVersion === 1) {
         let nativeDrawBuffersExtension = this.renderer.context.extensions.drawBuffers;
         let nativeDepthTextureExtension = this.renderer.context.extensions.depthTexture;
@@ -9460,6 +9496,9 @@ ${this.fragmentSrc}`;
       this.offsets = !!value;
       this._polygonOffset = value;
     }
+    toString() {
+      return `[@pixi/core:State blendMode=${this.blendMode} clockwiseFrontFace=${this.clockwiseFrontFace} culling=${this.culling} depthMask=${this.depthMask} polygonOffset=${this.polygonOffset}]`;
+    }
     static for2d() {
       const state = new State();
       state.depthTest = false;
@@ -9815,7 +9854,7 @@ ${this.fragmentSrc}`;
     }
   }
 
-  const tempMatrix = new Matrix();
+  const tempMatrix$1 = new Matrix();
   const rectPool = [];
   const _ScissorSystem = class extends AbstractMaskSystem {
     constructor(renderer) {
@@ -9870,7 +9909,7 @@ ${this.fragmentSrc}`;
       if (_ScissorSystem.isMatrixRotated(transform)) {
         return;
       }
-      transform = transform ? tempMatrix.copyFrom(transform) : tempMatrix.identity();
+      transform = transform ? tempMatrix$1.copyFrom(transform) : tempMatrix$1.identity();
       transform.translate(-bindingSourceFrame.x, -bindingSourceFrame.y).scale(bindingDestinationFrame.width / bindingSourceFrame.width, bindingDestinationFrame.height / bindingSourceFrame.height).translate(bindingDestinationFrame.x, bindingDestinationFrame.y);
       this.renderer.filter.transformAABB(transform, frame);
       frame.fit(bindingDestinationFrame);
@@ -10399,6 +10438,7 @@ ${this.fragmentSrc}`;
     const transformFeedbackVaryings = program.extra?.transformFeedbackVaryings;
     if (transformFeedbackVaryings) {
       if (typeof gl.transformFeedbackVaryings !== "function") {
+        console.warn(`TransformFeedback is not supported but TransformFeedbackVaryings are given.`);
       } else {
         gl.transformFeedbackVaryings(webGLProgram, transformFeedbackVaryings.names, transformFeedbackVaryings.bufferMode === "separate" ? gl.SEPARATE_ATTRIBS : gl.INTERLEAVED_ATTRIBS);
       }
@@ -11288,6 +11328,29 @@ ${this.fragmentSrc}`;
     constructor(renderer) {
       this.renderer = renderer;
       this.plugins = {};
+      Object.defineProperties(this.plugins, {
+        extract: {
+          enumerable: false,
+          get() {
+            deprecation("7.0.0", "renderer.plugins.extract has moved to renderer.extract");
+            return renderer.extract;
+          }
+        },
+        prepare: {
+          enumerable: false,
+          get() {
+            deprecation("7.0.0", "renderer.plugins.prepare has moved to renderer.prepare");
+            return renderer.prepare;
+          }
+        },
+        interaction: {
+          enumerable: false,
+          get() {
+            deprecation("7.0.0", "renderer.plugins.interaction has been deprecated, use renderer.events");
+            return renderer.events;
+          }
+        }
+      });
     }
     init(staticMap) {
       for (const o in staticMap) {
@@ -11367,7 +11430,7 @@ ${this.fragmentSrc}`;
       const renderer = this.renderer;
       renderer.emitWithCustomOptions(renderer.runners.init, options);
       if (options.hello) {
-        console.log(`PixiJS ${"7.0.4"} - ${renderer.rendererLogId} - https://pixijs.com`);
+        console.log(`PixiJS ${"7.0.5"} - ${renderer.rendererLogId} - https://pixijs.com`);
       }
       renderer.resize(this.renderer.screen.width, this.renderer.screen.height);
     }
@@ -11493,7 +11556,17 @@ ${this.fragmentSrc}`;
         projectionMatrix: new Matrix()
       }, true);
       const systemConfig = {
-        runners: ["init", "destroy", "contextChange", "reset", "update", "postrender", "prerender", "resize"],
+        runners: [
+          "init",
+          "destroy",
+          "contextChange",
+          "resolutionChange",
+          "reset",
+          "update",
+          "postrender",
+          "prerender",
+          "resize"
+        ],
         systems: _Renderer.__systems,
         priority: [
           "_view",
@@ -11521,6 +11594,11 @@ ${this.fragmentSrc}`;
         ]
       };
       this.setup(systemConfig);
+      if ("useContextAlpha" in options) {
+        deprecation("7.0.0", "options.useContextAlpha is deprecated, use options.premultipliedAlpha and options.backgroundAlpha instead");
+        options.premultipliedAlpha = options.useContextAlpha && options.useContextAlpha !== "notMultiplied";
+        options.backgroundAlpha = options.useContextAlpha === false ? 1 : options.backgroundAlpha;
+      }
       const startupOptions = {
         hello: options.hello,
         _plugin: _Renderer.__plugins,
@@ -11540,7 +11618,7 @@ ${this.fragmentSrc}`;
           antialias: options.antialias,
           context: options.context,
           powerPreference: options.powerPreference,
-          premultipliedAlpha: options.premultipliedAlpha ?? (options.useContextAlpha && options.useContextAlpha !== "notMultiplied"),
+          premultipliedAlpha: options.premultipliedAlpha,
           preserveDrawingBuffer: options.preserveDrawingBuffer
         }
       };
@@ -11588,6 +11666,10 @@ ${this.fragmentSrc}`;
     get resolution() {
       return this._view.resolution;
     }
+    set resolution(value) {
+      this._view.resolution = value;
+      this.runners.resolutionChange.emit(value);
+    }
     get autoDensity() {
       return this._view.autoDensity;
     }
@@ -11607,27 +11689,35 @@ ${this.fragmentSrc}`;
       return `WebGL ${this.context.webGLVersion}`;
     }
     get clearBeforeRender() {
+      deprecation("7.0.0", "renderer.clearBeforeRender has been deprecated, please use renderer.background.clearBeforeRender instead.");
       return this.background.clearBeforeRender;
     }
     get useContextAlpha() {
+      deprecation("7.0.0", "renderer.useContextAlpha has been deprecated, please use renderer.context.premultipliedAlpha instead.");
       return this.context.useContextAlpha;
     }
     get preserveDrawingBuffer() {
+      deprecation("7.0.0", "renderer.preserveDrawingBuffer has been deprecated, we cannot truly know this unless pixi created the context");
       return this.context.preserveDrawingBuffer;
     }
     get backgroundColor() {
+      deprecation("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
       return this.background.color;
     }
     set backgroundColor(value) {
+      deprecation("7.0.0", "renderer.backgroundColor has been deprecated, use renderer.background.color instead.");
       this.background.color = value;
     }
     get backgroundAlpha() {
+      deprecation("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
       return this.background.color;
     }
     set backgroundAlpha(value) {
+      deprecation("7.0.0", "renderer.backgroundAlpha has been deprecated, use renderer.background.alpha instead.");
       this.background.alpha = value;
     }
     get powerPreference() {
+      deprecation("7.0.0", "renderer.powerPreference has been deprecated, we can only know this if pixi creates the context");
       return this.context.powerPreference;
     }
     generateTexture(displayObject, options) {
@@ -12336,7 +12426,7 @@ ${this.fragmentSrc}`;
   };
   extensions$1.add(ObjectRendererSystem);
 
-  const VERSION = "7.0.4";
+  const VERSION = "7.0.5";
 
   var fragment$6 = "varying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float uAlpha;\n\nvoid main(void)\n{\n   gl_FragColor = texture2D(uSampler, vTextureCoord) * uAlpha;\n}\n";
 
@@ -13809,6 +13899,7 @@ ${this.fragmentSrc}`;
   }
   DisplayObject.prototype.displayObjectUpdateTransform = DisplayObject.prototype.updateTransform;
 
+  const tempMatrix = new Matrix();
   function sortChildren(a, b) {
     if (a.zIndex === b.zIndex) {
       return a._lastSortedIndex - b._lastSortedIndex;
@@ -14030,6 +14121,15 @@ ${this.fragmentSrc}`;
       } else if (this._render !== Container.prototype._render) {
         bounds = this.getBounds(true);
       }
+      const projectionTransform = renderer.projection.transform;
+      if (projectionTransform) {
+        if (transform) {
+          transform = tempMatrix.copyFrom(transform);
+          transform.prepend(projectionTransform);
+        } else {
+          transform = projectionTransform;
+        }
+      }
       if (bounds && sourceFrame.intersects(bounds, transform)) {
         this._render(renderer);
       } else if (this.cullArea) {
@@ -15392,6 +15492,9 @@ ${this.fragmentSrc}`;
       this.setTargetElement(view);
       this.resolution = resolution;
     }
+    resolutionChange(resolution) {
+      this.resolution = resolution;
+    }
     destroy() {
       this.setTargetElement(null);
       this.renderer = null;
@@ -16178,6 +16281,26 @@ ${this.fragmentSrc}`;
     }
   }
 
+  function checkDataUrl(url, mimes) {
+    if (Array.isArray(mimes)) {
+      for (const mime of mimes) {
+        if (url.startsWith(`data:${mime}`))
+          return true;
+      }
+      return false;
+    }
+    return url.startsWith(`data:${mimes}`);
+  }
+
+  function checkExtension(url, extension) {
+    const tempURL = url.split("?")[0];
+    const ext = path.extname(tempURL).toLowerCase();
+    if (Array.isArray(extension)) {
+      return extension.includes(ext.toLowerCase());
+    }
+    return ext.toLowerCase() === extension;
+  }
+
   const convertToList = (input, transform) => {
     if (!Array.isArray(input)) {
       input = [input];
@@ -16239,6 +16362,7 @@ ${this.fragmentSrc}`;
     get(key) {
       const result = this._cache.get(key);
       if (!result) {
+        console.warn(`[Assets] Asset id ${key} was not found in the Cache`);
       }
       return result;
     }
@@ -16268,6 +16392,7 @@ ${this.fragmentSrc}`;
       });
       cacheKeys.forEach((key2) => {
         if (this._cache.has(key2) && this._cache.get(key2) !== value) {
+          console.warn("[Cache] already has key:", key2);
         }
         this._cache.set(key2, cacheableAssets[key2]);
       });
@@ -16284,6 +16409,7 @@ ${this.fragmentSrc}`;
     remove(key) {
       this._cacheMap.get(key);
       if (!this._cacheMap.has(key)) {
+        console.warn(`[Assets] Asset id ${key} was not found in the Cache`);
         return;
       }
       const cacheMap = this._cacheMap.get(key);
@@ -16325,6 +16451,7 @@ ${this.fragmentSrc}`;
           }
         }
         if (!result.parser) {
+          console.warn(`[Assets] ${url} could not be loaded as we don't know how to parse it, ensure the correct parser has being added`);
           return null;
         }
         for (let i = 0; i < this.parsers.length; i++) {
@@ -16431,6 +16558,7 @@ ${e}`);
     }
     addManifest(manifest) {
       if (this._manifest) {
+        console.warn("[Resolver] Manifest already exists, this will be overwritten");
       }
       this._manifest = manifest;
       manifest.bundles.forEach((bundle) => {
@@ -16460,6 +16588,7 @@ ${e}`);
       const keys = convertToList(keysIn);
       keys.forEach((key) => {
         if (this._assetMap[key]) {
+          console.warn(`[Resolver] already has key: ${key} overwriting`);
         }
       });
       if (!Array.isArray(assetsIn)) {
@@ -16589,6 +16718,7 @@ ${e}`);
     }
     async init(options = {}) {
       if (this._initialized) {
+        console.warn("[Assets]AssetManager already initialized, did you load before calling this Asset.init()?");
         return;
       }
       this._initialized = true;
@@ -16844,7 +16974,13 @@ ${e}`);
     "800",
     "900"
   ];
-  const validFonts = ["woff", "woff2", "ttf", "otf"];
+  const validFontExtensions = [".ttf", ".otf", ".woff", ".woff2"];
+  const validFontMIMEs = [
+    "font/ttf",
+    "font/otf",
+    "font/woff",
+    "font/woff2"
+  ];
   function getFontFamilyName(url) {
     const ext = path.extname(url);
     const name = path.basename(url, ext);
@@ -16858,9 +16994,7 @@ ${e}`);
       priority: LoaderParserPriority.Low
     },
     test(url) {
-      const tempURL = url.split("?")[0];
-      const extension = tempURL.split(".").pop();
-      return validFonts.includes(extension);
+      return checkDataUrl(url, validFontMIMEs) || checkExtension(url, validFontExtensions);
     },
     async load(url, options) {
       if (!globalThis.navigator.onLine) {
@@ -16874,7 +17008,7 @@ ${e}`);
         const data = options.data ?? {};
         for (let i = 0; i < weights.length; i++) {
           const weight = weights[i];
-          const font = new FontFace(name, `url(${url})`, {
+          const font = new FontFace(name, `url(${encodeURI(url)})`, {
             ...data,
             weight
           });
@@ -16884,6 +17018,7 @@ ${e}`);
         }
         return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
       }
+      console.warn("[loadWebFont] FontFace API is not supported. Skipping loading font");
       return null;
     },
     unload(font) {
@@ -17046,15 +17181,6 @@ ${e}`);
   }
   const WorkerManager = new WorkerManagerClass();
 
-  function checkExtension(url, extension) {
-    const tempURL = url.split("?")[0];
-    const ext = path.extname(tempURL).toLowerCase();
-    if (Array.isArray(extension)) {
-      return extension.includes(ext.toLowerCase());
-    }
-    return ext.toLowerCase() === extension;
-  }
-
   function createTexture(base, loader, url) {
     const texture = new Texture(base);
     texture.baseTexture.on("dispose", () => {
@@ -17063,7 +17189,13 @@ ${e}`);
     return texture;
   }
 
-  const validImages$1 = [".jpg", ".png", ".jpeg", ".avif", ".webp"];
+  const validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"];
+  const validImageMIMEs = [
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+    "image/avif"
+  ];
   async function loadImageBitmap(url) {
     const response = await settings.ADAPTER.fetch(url);
     if (!response.ok) {
@@ -17082,14 +17214,7 @@ ${e}`);
       preferWorkers: true
     },
     test(url) {
-      let isValidBase64Suffix = false;
-      for (let i = 0; i < validImages$1.length; i++) {
-        if (url.startsWith(`data:image/${validImages$1[i].slice(1)}`)) {
-          isValidBase64Suffix = true;
-          break;
-        }
-      }
-      return isValidBase64Suffix || checkExtension(url, validImages$1);
+      return checkDataUrl(url, validImageMIMEs) || checkExtension(url, validImageExtensions);
     },
     async load(url, asset, loader) {
       let src = null;
@@ -17403,6 +17528,7 @@ ${e}`);
       const canvas = settings.ADAPTER.createCanvas();
       const gl = canvas.getContext("webgl");
       if (!gl) {
+        console.warn("WebGL not available for compressed textures.");
         return false;
       }
       storedGl = gl;
@@ -17864,6 +17990,7 @@ ${e}`);
   function validate(url, dataView) {
     for (let i = 0; i < FILE_IDENTIFIER.length; i++) {
       if (dataView.getUint8(i) !== FILE_IDENTIFIER[i]) {
+        console.error(`${url} is not a valid *.ktx file!`);
         return false;
       }
     }
@@ -21428,7 +21555,7 @@ ${e}`);
         width += style.dropShadowDistance;
       }
       const lineHeight = style.lineHeight || fontProperties.fontSize + style.strokeThickness;
-      let height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness) + (lines.length - 1) * (lineHeight + style.leading);
+      let height = Math.max(lineHeight, fontProperties.fontSize + style.strokeThickness * 2) + (lines.length - 1) * (lineHeight + style.leading);
       if (style.dropShadow) {
         height += style.dropShadowDistance;
       }
@@ -22994,7 +23121,8 @@ ${e}`);
 
   class XMLFormat {
     static test(data) {
-      return data instanceof XMLDocument && data.getElementsByTagName("page").length && data.getElementsByTagName("info")[0].getAttribute("face") !== null;
+      const xml = data;
+      return "getElementsByTagName" in xml && xml.getElementsByTagName("page").length && xml.getElementsByTagName("info")[0].getAttribute("face") !== null;
     }
     static parse(xml) {
       const data = new BitmapFontData();
@@ -23055,14 +23183,12 @@ ${e}`);
   class XMLStringFormat {
     static test(data) {
       if (typeof data === "string" && data.includes("<font>")) {
-        const xml = new globalThis.DOMParser().parseFromString(data, "text/xml");
-        return XMLFormat.test(xml);
+        return XMLFormat.test(settings.ADAPTER.parseXML(data));
       }
       return false;
     }
     static parse(xmlTxt) {
-      const xml = new globalThis.DOMParser().parseFromString(xmlTxt, "text/xml");
-      return XMLFormat.parse(xml);
+      return XMLFormat.parse(settings.ADAPTER.parseXML(xmlTxt));
     }
   }
 
@@ -24137,6 +24263,7 @@ ${e}`);
   exports.autoDetectRenderer = autoDetectRenderer;
   exports.autoDetectResource = autoDetectResource;
   exports.cacheTextureArray = cacheTextureArray;
+  exports.checkDataUrl = checkDataUrl;
   exports.checkExtension = checkExtension;
   exports.checkMaxIfStatementsInShader = checkMaxIfStatementsInShader;
   exports.convertToList = convertToList;