pixi-watchface-engine 0.1.3 → 0.1.4

package/dist/index.js

@@ -28030,60 +28030,6 @@ var init_CanvasRenderer = __esm(() => {
   };
 });
 
-// node_modules/pixi.js/lib/scene/text-bitmap/AbstractBitmapFont.mjs
-var AbstractBitmapFont;
-var init_AbstractBitmapFont = __esm(() => {
-  init_eventemitter3();
-  init_deprecation();
-  AbstractBitmapFont = class AbstractBitmapFont extends eventemitter3_default {
-    constructor() {
-      super(...arguments);
-      this.chars = /* @__PURE__ */ Object.create(null);
-      this.lineHeight = 0;
-      this.fontFamily = "";
-      this.fontMetrics = { fontSize: 0, ascent: 0, descent: 0 };
-      this.baseLineOffset = 0;
-      this.distanceField = { type: "none", range: 0 };
-      this.pages = [];
-      this.applyFillAsTint = true;
-      this.baseMeasurementFontSize = 100;
-      this.baseRenderedFontSize = 100;
-    }
-    get font() {
-      deprecation(v8_0_0, "BitmapFont.font is deprecated, please use BitmapFont.fontFamily instead.");
-      return this.fontFamily;
-    }
-    get pageTextures() {
-      deprecation(v8_0_0, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead.");
-      return this.pages;
-    }
-    get size() {
-      deprecation(v8_0_0, "BitmapFont.size is deprecated, please use BitmapFont.fontMetrics.fontSize instead.");
-      return this.fontMetrics.fontSize;
-    }
-    get distanceFieldRange() {
-      deprecation(v8_0_0, "BitmapFont.distanceFieldRange is deprecated, please use BitmapFont.distanceField.range instead.");
-      return this.distanceField.range;
-    }
-    get distanceFieldType() {
-      deprecation(v8_0_0, "BitmapFont.distanceFieldType is deprecated, please use BitmapFont.distanceField.type instead.");
-      return this.distanceField.type;
-    }
-    destroy(destroyTextures = false) {
-      this.emit("destroy", this);
-      this.removeAllListeners();
-      for (const i2 in this.chars) {
-        this.chars[i2].texture?.destroy();
-      }
-      this.chars = null;
-      if (destroyTextures) {
-        this.pages.forEach((page) => page.texture.destroy(true));
-        this.pages = null;
-      }
-    }
-  };
-});
-
 // node_modules/tiny-lru/dist/tiny-lru.js
 class LRU {
   constructor(max = 0, ttl = 0, resetTtl = false) {
@@ -29105,6 +29051,73 @@ var init_fontStringFromTextStyle = __esm(() => {
   ];
 });
 
+// node_modules/pixi.js/lib/scene/text/canvas/utils/getCanvasFillStyle.mjs
+function getCanvasFillStyle(fillStyle, context2, textMetrics, padding = 0, offsetX = 0, offsetY = 0) {
+  if (fillStyle.texture === Texture.WHITE && !fillStyle.fill) {
+    return Color.shared.setValue(fillStyle.color).setAlpha(fillStyle.alpha ?? 1).toHexa();
+  } else if (!fillStyle.fill) {
+    const pattern = context2.createPattern(fillStyle.texture.source.resource, "repeat");
+    const tempMatrix8 = fillStyle.matrix.copyTo(Matrix.shared);
+    tempMatrix8.scale(fillStyle.texture.source.pixelWidth, fillStyle.texture.source.pixelHeight);
+    pattern.setTransform(tempMatrix8);
+    return pattern;
+  } else if (fillStyle.fill instanceof FillPattern) {
+    const fillPattern = fillStyle.fill;
+    const pattern = context2.createPattern(fillPattern.texture.source.resource, "repeat");
+    const tempMatrix8 = fillPattern.transform.copyTo(Matrix.shared);
+    tempMatrix8.scale(fillPattern.texture.source.pixelWidth, fillPattern.texture.source.pixelHeight);
+    pattern.setTransform(tempMatrix8);
+    return pattern;
+  } else if (fillStyle.fill instanceof FillGradient) {
+    const fillGradient = fillStyle.fill;
+    const isLinear = fillGradient.type === "linear";
+    const isLocal = fillGradient.textureSpace === "local";
+    let width = 1;
+    let height = 1;
+    if (isLocal && textMetrics) {
+      width = textMetrics.width + padding;
+      height = textMetrics.height + padding;
+    }
+    let gradient;
+    let isNearlyVertical = false;
+    if (isLinear) {
+      const { start, end } = fillGradient;
+      gradient = context2.createLinearGradient(start.x * width + offsetX, start.y * height + offsetY, end.x * width + offsetX, end.y * height + offsetY);
+      isNearlyVertical = Math.abs(end.x - start.x) < Math.abs((end.y - start.y) * 0.1);
+    } else {
+      const { center, innerRadius, outerCenter, outerRadius } = fillGradient;
+      gradient = context2.createRadialGradient(center.x * width + offsetX, center.y * height + offsetY, innerRadius * width, outerCenter.x * width + offsetX, outerCenter.y * height + offsetY, outerRadius * width);
+    }
+    if (isNearlyVertical && isLocal && textMetrics) {
+      const ratio = textMetrics.lineHeight / height;
+      for (let i2 = 0;i2 < textMetrics.lines.length; i2++) {
+        const start = (i2 * textMetrics.lineHeight + padding / 2) / height;
+        fillGradient.colorStops.forEach((stop) => {
+          let globalStop = start + stop.offset * ratio;
+          globalStop = Math.max(0, Math.min(1, globalStop));
+          gradient.addColorStop(Math.floor(globalStop * PRECISION) / PRECISION, Color.shared.setValue(stop.color).toHex());
+        });
+      }
+    } else {
+      fillGradient.colorStops.forEach((stop) => {
+        gradient.addColorStop(stop.offset, Color.shared.setValue(stop.color).toHex());
+      });
+    }
+    return gradient;
+  }
+  warn("FillStyle not recognised", fillStyle);
+  return "red";
+}
+var PRECISION = 1e5;
+var init_getCanvasFillStyle = __esm(() => {
+  init_Color();
+  init_Matrix();
+  init_Texture();
+  init_warn();
+  init_FillGradient();
+  init_FillPattern();
+});
+
 // node_modules/pixi.js/lib/scene/text/TextStyle.mjs
 function convertV7Tov8Style(style) {
   const oldStyle = style;
@@ -29536,811 +29549,71 @@ var init_TextStyle = __esm(() => {
   TextStyle = _TextStyle;
 });
 
-// node_modules/pixi.js/lib/scene/text/canvas/utils/getCanvasFillStyle.mjs
-function getCanvasFillStyle(fillStyle, context2, textMetrics, padding = 0, offsetX = 0, offsetY = 0) {
-  if (fillStyle.texture === Texture.WHITE && !fillStyle.fill) {
-    return Color.shared.setValue(fillStyle.color).setAlpha(fillStyle.alpha ?? 1).toHexa();
-  } else if (!fillStyle.fill) {
-    const pattern = context2.createPattern(fillStyle.texture.source.resource, "repeat");
-    const tempMatrix8 = fillStyle.matrix.copyTo(Matrix.shared);
-    tempMatrix8.scale(fillStyle.texture.source.pixelWidth, fillStyle.texture.source.pixelHeight);
-    pattern.setTransform(tempMatrix8);
-    return pattern;
-  } else if (fillStyle.fill instanceof FillPattern) {
-    const fillPattern = fillStyle.fill;
-    const pattern = context2.createPattern(fillPattern.texture.source.resource, "repeat");
-    const tempMatrix8 = fillPattern.transform.copyTo(Matrix.shared);
-    tempMatrix8.scale(fillPattern.texture.source.pixelWidth, fillPattern.texture.source.pixelHeight);
-    pattern.setTransform(tempMatrix8);
-    return pattern;
-  } else if (fillStyle.fill instanceof FillGradient) {
-    const fillGradient = fillStyle.fill;
-    const isLinear = fillGradient.type === "linear";
-    const isLocal = fillGradient.textureSpace === "local";
-    let width = 1;
-    let height = 1;
-    if (isLocal && textMetrics) {
-      width = textMetrics.width + padding;
-      height = textMetrics.height + padding;
-    }
-    let gradient;
-    let isNearlyVertical = false;
-    if (isLinear) {
-      const { start, end } = fillGradient;
-      gradient = context2.createLinearGradient(start.x * width + offsetX, start.y * height + offsetY, end.x * width + offsetX, end.y * height + offsetY);
-      isNearlyVertical = Math.abs(end.x - start.x) < Math.abs((end.y - start.y) * 0.1);
-    } else {
-      const { center, innerRadius, outerCenter, outerRadius } = fillGradient;
-      gradient = context2.createRadialGradient(center.x * width + offsetX, center.y * height + offsetY, innerRadius * width, outerCenter.x * width + offsetX, outerCenter.y * height + offsetY, outerRadius * width);
-    }
-    if (isNearlyVertical && isLocal && textMetrics) {
-      const ratio = textMetrics.lineHeight / height;
-      for (let i2 = 0;i2 < textMetrics.lines.length; i2++) {
-        const start = (i2 * textMetrics.lineHeight + padding / 2) / height;
-        fillGradient.colorStops.forEach((stop) => {
-          let globalStop = start + stop.offset * ratio;
-          globalStop = Math.max(0, Math.min(1, globalStop));
-          gradient.addColorStop(Math.floor(globalStop * PRECISION) / PRECISION, Color.shared.setValue(stop.color).toHex());
-        });
-      }
-    } else {
-      fillGradient.colorStops.forEach((stop) => {
-        gradient.addColorStop(stop.offset, Color.shared.setValue(stop.color).toHex());
-      });
-    }
-    return gradient;
+// node_modules/pixi.js/lib/environment-browser/browserExt.mjs
+init_Extensions();
+var browserExt = {
+  extension: {
+    type: ExtensionType.Environment,
+    name: "browser",
+    priority: -1
+  },
+  test: () => true,
+  load: async () => {
+    await Promise.resolve().then(() => (init_browserAll(), exports_browserAll));
   }
-  warn("FillStyle not recognised", fillStyle);
-  return "red";
-}
-var PRECISION = 1e5;
-var init_getCanvasFillStyle = __esm(() => {
-  init_Color();
-  init_Matrix();
-  init_Texture();
-  init_warn();
-  init_FillGradient();
-  init_FillPattern();
-});
+};
 
-// node_modules/pixi.js/lib/scene/text-bitmap/DynamicBitmapFont.mjs
-var _DynamicBitmapFont, DynamicBitmapFont;
-var init_DynamicBitmapFont = __esm(() => {
-  init_Color();
-  init_Rectangle();
-  init_CanvasPool();
-  init_ImageSource();
-  init_Texture();
-  init_TextureStyle();
-  init_deprecation();
-  init_CanvasTextMetrics();
-  init_fontStringFromTextStyle();
-  init_getCanvasFillStyle();
-  init_TextStyle();
-  init_AbstractBitmapFont();
-  _DynamicBitmapFont = class _DynamicBitmapFont2 extends AbstractBitmapFont {
-    constructor(options) {
-      super();
-      this.resolution = 1;
-      this.pages = [];
-      this._padding = 0;
-      this._measureCache = /* @__PURE__ */ Object.create(null);
-      this._currentChars = [];
-      this._currentX = 0;
-      this._currentY = 0;
-      this._currentMaxCharHeight = 0;
-      this._currentPageIndex = -1;
-      this._skipKerning = false;
-      const dynamicOptions = { ..._DynamicBitmapFont2.defaultOptions, ...options };
-      this._textureSize = dynamicOptions.textureSize;
-      this._mipmap = dynamicOptions.mipmap;
-      const style = dynamicOptions.style.clone();
-      if (dynamicOptions.overrideFill) {
-        style._fill.color = 16777215;
-        style._fill.alpha = 1;
-        style._fill.texture = Texture.WHITE;
-        style._fill.fill = null;
-      }
-      this.applyFillAsTint = dynamicOptions.overrideFill;
-      const requestedFontSize = style.fontSize;
-      style.fontSize = this.baseMeasurementFontSize;
-      const font = fontStringFromTextStyle(style);
-      if (dynamicOptions.overrideSize) {
-        if (style._stroke) {
-          style._stroke.width *= this.baseRenderedFontSize / requestedFontSize;
-        }
-      } else {
-        style.fontSize = this.baseRenderedFontSize = requestedFontSize;
-      }
-      this._style = style;
-      this._skipKerning = dynamicOptions.skipKerning ?? false;
-      this.resolution = dynamicOptions.resolution ?? 1;
-      this._padding = dynamicOptions.padding ?? 4;
-      if (dynamicOptions.textureStyle) {
-        this._textureStyle = dynamicOptions.textureStyle instanceof TextureStyle ? dynamicOptions.textureStyle : new TextureStyle(dynamicOptions.textureStyle);
-      }
-      this.fontMetrics = CanvasTextMetrics.measureFont(font);
-      this.lineHeight = style.lineHeight || this.fontMetrics.fontSize || style.fontSize;
-    }
-    ensureCharacters(chars) {
-      const charList = CanvasTextMetrics.graphemeSegmenter(chars).filter((char) => !this._currentChars.includes(char)).filter((char, index, self2) => self2.indexOf(char) === index);
-      if (!charList.length)
-        return;
-      this._currentChars = [...this._currentChars, ...charList];
-      let pageData;
-      if (this._currentPageIndex === -1) {
-        pageData = this._nextPage();
-      } else {
-        pageData = this.pages[this._currentPageIndex];
-      }
-      let { canvas, context: context2 } = pageData.canvasAndContext;
-      let textureSource = pageData.texture.source;
-      const style = this._style;
-      let currentX = this._currentX;
-      let currentY = this._currentY;
-      let currentMaxCharHeight = this._currentMaxCharHeight;
-      const fontScale = this.baseRenderedFontSize / this.baseMeasurementFontSize;
-      const padding = this._padding * fontScale;
-      let skipTexture = false;
-      const maxTextureWidth = canvas.width / this.resolution;
-      const maxTextureHeight = canvas.height / this.resolution;
-      for (let i2 = 0;i2 < charList.length; i2++) {
-        const char = charList[i2];
-        const metrics = CanvasTextMetrics.measureText(char, style, canvas, false);
-        metrics.lineHeight = metrics.height;
-        const width = metrics.width * fontScale;
-        const textureGlyphWidth = Math.ceil((style.fontStyle === "italic" ? 2 : 1) * width);
-        const height = metrics.height * fontScale;
-        const paddedWidth = textureGlyphWidth + padding * 2;
-        const paddedHeight = height + padding * 2;
-        skipTexture = false;
-        if (char !== `
-` && char !== "\r" && char !== "\t" && char !== " ") {
-          skipTexture = true;
-          currentMaxCharHeight = Math.ceil(Math.max(paddedHeight, currentMaxCharHeight));
-        }
-        if (currentX + paddedWidth > maxTextureWidth) {
-          currentY += currentMaxCharHeight;
-          currentMaxCharHeight = paddedHeight;
-          currentX = 0;
-          if (currentY + currentMaxCharHeight > maxTextureHeight) {
-            textureSource.update();
-            const pageData2 = this._nextPage();
-            canvas = pageData2.canvasAndContext.canvas;
-            context2 = pageData2.canvasAndContext.context;
-            textureSource = pageData2.texture.source;
-            currentX = 0;
-            currentY = 0;
-            currentMaxCharHeight = 0;
-          }
-        }
-        const xAdvance = width / fontScale - (style.dropShadow?.distance ?? 0) - (style._stroke?.width ?? 0);
-        this.chars[char] = {
-          id: char.codePointAt(0),
-          xOffset: -this._padding,
-          yOffset: -this._padding,
-          xAdvance,
-          kerning: {}
-        };
-        if (skipTexture) {
-          this._drawGlyph(context2, metrics, currentX + padding, currentY + padding, fontScale, style);
-          const px = textureSource.width * fontScale;
-          const py = textureSource.height * fontScale;
-          const frame = new Rectangle(currentX / px * textureSource.width, currentY / py * textureSource.height, paddedWidth / px * textureSource.width, paddedHeight / py * textureSource.height);
-          this.chars[char].texture = new Texture({
-            source: textureSource,
-            frame
-          });
-          currentX += Math.ceil(paddedWidth);
-        }
-      }
-      textureSource.update();
-      this._currentX = currentX;
-      this._currentY = currentY;
-      this._currentMaxCharHeight = currentMaxCharHeight;
-      this._skipKerning && this._applyKerning(charList, context2);
-    }
-    get pageTextures() {
-      deprecation(v8_0_0, "BitmapFont.pageTextures is deprecated, please use BitmapFont.pages instead.");
-      return this.pages;
-    }
-    _applyKerning(newChars, context2) {
-      const measureCache = this._measureCache;
-      for (let i2 = 0;i2 < newChars.length; i2++) {
-        const first = newChars[i2];
-        for (let j2 = 0;j2 < this._currentChars.length; j2++) {
-          const second = this._currentChars[j2];
-          let c1 = measureCache[first];
-          if (!c1)
-            c1 = measureCache[first] = context2.measureText(first).width;
-          let c2 = measureCache[second];
-          if (!c2)
-            c2 = measureCache[second] = context2.measureText(second).width;
-          let total = context2.measureText(first + second).width;
-          let amount = total - (c1 + c2);
-          if (amount) {
-            this.chars[first].kerning[second] = amount;
-          }
-          total = context2.measureText(first + second).width;
-          amount = total - (c1 + c2);
-          if (amount) {
-            this.chars[second].kerning[first] = amount;
-          }
-        }
-      }
-    }
-    _nextPage() {
-      this._currentPageIndex++;
-      const textureResolution = this.resolution;
-      const canvasAndContext = CanvasPool.getOptimalCanvasAndContext(this._textureSize, this._textureSize, textureResolution);
-      this._setupContext(canvasAndContext.context, this._style, textureResolution);
-      const resolution = textureResolution * (this.baseRenderedFontSize / this.baseMeasurementFontSize);
-      const texture = new Texture({
-        source: new ImageSource({
-          resource: canvasAndContext.canvas,
-          resolution,
-          alphaMode: "premultiply-alpha-on-upload",
-          autoGenerateMipmaps: this._mipmap
-        })
-      });
-      if (this._textureStyle) {
-        texture.source.style = this._textureStyle;
-      }
-      const pageData = {
-        canvasAndContext,
-        texture
-      };
-      this.pages[this._currentPageIndex] = pageData;
-      return pageData;
-    }
-    _setupContext(context2, style, resolution) {
-      style.fontSize = this.baseRenderedFontSize;
-      context2.scale(resolution, resolution);
-      context2.font = fontStringFromTextStyle(style);
-      style.fontSize = this.baseMeasurementFontSize;
-      context2.textBaseline = style.textBaseline;
-      const stroke = style._stroke;
-      const strokeThickness = stroke?.width ?? 0;
-      if (stroke) {
-        context2.lineWidth = strokeThickness;
-        context2.lineJoin = stroke.join;
-        context2.miterLimit = stroke.miterLimit;
-        context2.strokeStyle = getCanvasFillStyle(stroke, context2);
-      }
-      if (style._fill) {
-        context2.fillStyle = getCanvasFillStyle(style._fill, context2);
-      }
-      if (style.dropShadow) {
-        const shadowOptions = style.dropShadow;
-        const rgb = Color.shared.setValue(shadowOptions.color).toArray();
-        const dropShadowBlur = shadowOptions.blur * resolution;
-        const dropShadowDistance = shadowOptions.distance * resolution;
-        context2.shadowColor = `rgba(${rgb[0] * 255},${rgb[1] * 255},${rgb[2] * 255},${shadowOptions.alpha})`;
-        context2.shadowBlur = dropShadowBlur;
-        context2.shadowOffsetX = Math.cos(shadowOptions.angle) * dropShadowDistance;
-        context2.shadowOffsetY = Math.sin(shadowOptions.angle) * dropShadowDistance;
-      } else {
-        context2.shadowColor = "black";
-        context2.shadowBlur = 0;
-        context2.shadowOffsetX = 0;
-        context2.shadowOffsetY = 0;
-      }
-    }
-    _drawGlyph(context2, metrics, x2, y2, fontScale, style) {
-      const char = metrics.text;
-      const fontProperties = metrics.fontProperties;
-      const stroke = style._stroke;
-      const strokeThickness = (stroke?.width ?? 0) * fontScale;
-      const tx = x2 + strokeThickness / 2;
-      const ty = y2 - strokeThickness / 2;
-      const descent = fontProperties.descent * fontScale;
-      const lineHeight = metrics.lineHeight * fontScale;
-      let removeShadow = false;
-      if (style.stroke && strokeThickness) {
-        removeShadow = true;
-        context2.strokeText(char, tx, ty + lineHeight - descent);
-      }
-      const { shadowBlur, shadowOffsetX, shadowOffsetY } = context2;
-      if (style._fill) {
-        if (removeShadow) {
-          context2.shadowBlur = 0;
-          context2.shadowOffsetX = 0;
-          context2.shadowOffsetY = 0;
-        }
-        context2.fillText(char, tx, ty + lineHeight - descent);
-      }
-      if (removeShadow) {
-        context2.shadowBlur = shadowBlur;
-        context2.shadowOffsetX = shadowOffsetX;
-        context2.shadowOffsetY = shadowOffsetY;
-      }
-    }
-    destroy() {
-      super.destroy();
-      for (let i2 = 0;i2 < this.pages.length; i2++) {
-        const { canvasAndContext, texture } = this.pages[i2];
-        CanvasPool.returnCanvasAndContext(canvasAndContext);
-        texture.destroy(true);
-      }
-      this.pages = null;
-    }
-  };
-  _DynamicBitmapFont.defaultOptions = {
-    textureSize: 512,
-    style: new TextStyle,
-    mipmap: true
-  };
-  DynamicBitmapFont = _DynamicBitmapFont;
-});
+// node_modules/pixi.js/lib/environment-webworker/webworkerExt.mjs
+init_Extensions();
+var webworkerExt = {
+  extension: {
+    type: ExtensionType.Environment,
+    name: "webworker",
+    priority: 0
+  },
+  test: () => typeof self !== "undefined" && self.WorkerGlobalScope !== undefined,
+  load: async () => {
+    await Promise.resolve().then(() => (init_webworkerAll(), exports_webworkerAll));
+  }
+};
 
-// node_modules/pixi.js/lib/scene/text-bitmap/utils/getBitmapTextLayout.mjs
-function getBitmapTextLayout(chars, style, font, trimEnd) {
-  const layoutData = {
-    width: 0,
-    height: 0,
-    offsetY: 0,
-    scale: style.fontSize / font.baseMeasurementFontSize,
-    lines: [{
-      width: 0,
-      charPositions: [],
-      spaceWidth: 0,
-      spacesIndex: [],
-      chars: []
-    }]
-  };
-  layoutData.offsetY = font.baseLineOffset;
-  let currentLine = layoutData.lines[0];
-  let previousChar = null;
-  let firstWord = true;
-  const currentWord = {
-    spaceWord: false,
-    width: 0,
-    start: 0,
-    index: 0,
-    positions: [],
-    chars: []
-  };
-  const scale = font.baseMeasurementFontSize / style.fontSize;
-  const adjustedLetterSpacing = style.letterSpacing * scale;
-  const adjustedWordWrapWidth = style.wordWrapWidth * scale;
-  const adjustedLineHeight = style.lineHeight ? style.lineHeight * scale : font.lineHeight;
-  const breakWords = style.wordWrap && style.breakWords;
-  const nextWord = (word) => {
-    const start = currentLine.width;
-    for (let j2 = 0;j2 < currentWord.index; j2++) {
-      const position = word.positions[j2];
-      currentLine.chars.push(word.chars[j2]);
-      currentLine.charPositions.push(position + start);
-    }
-    currentLine.width += word.width;
-    firstWord = false;
-    currentWord.width = 0;
-    currentWord.index = 0;
-    currentWord.chars.length = 0;
-  };
-  const nextLine = () => {
-    let index = currentLine.chars.length - 1;
-    if (trimEnd) {
-      let lastChar = currentLine.chars[index];
-      while (lastChar === " ") {
-        currentLine.width -= font.chars[lastChar].xAdvance;
-        lastChar = currentLine.chars[--index];
-      }
-    }
-    layoutData.width = Math.max(layoutData.width, currentLine.width);
-    currentLine = {
-      width: 0,
-      charPositions: [],
-      chars: [],
-      spaceWidth: 0,
-      spacesIndex: []
+// node_modules/pixi.js/lib/index.mjs
+init_Extensions();
+init_init4();
+init_init3();
+
+// node_modules/pixi.js/lib/app/Application.mjs
+init_Extensions();
+
+// node_modules/pixi.js/lib/utils/browser/isWebGLSupported.mjs
+init_adapter();
+init_AbstractRenderer();
+var _isWebGLSupported;
+function isWebGLSupported(failIfMajorPerformanceCaveat) {
+  if (_isWebGLSupported !== undefined)
+    return _isWebGLSupported;
+  _isWebGLSupported = (() => {
+    const contextOptions = {
+      stencil: true,
+      failIfMajorPerformanceCaveat: failIfMajorPerformanceCaveat ?? AbstractRenderer.defaultOptions.failIfMajorPerformanceCaveat
     };
-    firstWord = true;
-    layoutData.lines.push(currentLine);
-    layoutData.height += adjustedLineHeight;
-  };
-  const checkIsOverflow = (lineWidth) => lineWidth - adjustedLetterSpacing > adjustedWordWrapWidth;
-  for (let i2 = 0;i2 < chars.length + 1; i2++) {
-    let char;
-    const isEnd = i2 === chars.length;
-    if (!isEnd) {
-      char = chars[i2];
-    }
-    const charData = font.chars[char] || font.chars[" "];
-    const isSpace = /(?:\s)/.test(char);
-    const isWordBreak = isSpace || char === "\r" || char === `
-` || isEnd;
-    if (isWordBreak) {
-      const addWordToNextLine = !firstWord && style.wordWrap && checkIsOverflow(currentLine.width + currentWord.width);
-      if (addWordToNextLine) {
-        nextLine();
-        nextWord(currentWord);
-        if (!isEnd) {
-          currentLine.charPositions.push(0);
-        }
-      } else {
-        currentWord.start = currentLine.width;
-        nextWord(currentWord);
-        if (!isEnd) {
-          currentLine.charPositions.push(0);
-        }
-      }
-      if (char === "\r" || char === `
-`) {
-        nextLine();
-      } else if (!isEnd) {
-        const spaceWidth = charData.xAdvance + (charData.kerning[previousChar] || 0) + adjustedLetterSpacing;
-        currentLine.width += spaceWidth;
-        currentLine.spaceWidth = spaceWidth;
-        currentLine.spacesIndex.push(currentLine.charPositions.length);
-        currentLine.chars.push(char);
+    try {
+      if (!DOMAdapter.get().getWebGLRenderingContext()) {
+        return false;
       }
-    } else {
-      const kerning = charData.kerning[previousChar] || 0;
-      const nextCharWidth = charData.xAdvance + kerning + adjustedLetterSpacing;
-      const addWordToNextLine = breakWords && checkIsOverflow(currentLine.width + currentWord.width + nextCharWidth);
-      if (addWordToNextLine) {
-        nextWord(currentWord);
-        nextLine();
+      const canvas = DOMAdapter.get().createCanvas();
+      let gl = canvas.getContext("webgl", contextOptions);
+      const success = !!gl?.getContextAttributes()?.stencil;
+      if (gl) {
+        const loseContext = gl.getExtension("WEBGL_lose_context");
+        if (loseContext) {
+          loseContext.loseContext();
+        }
       }
-      currentWord.positions[currentWord.index++] = currentWord.width + kerning;
-      currentWord.chars.push(char);
-      currentWord.width += nextCharWidth;
-    }
-    previousChar = char;
-  }
-  nextLine();
-  if (style.align === "center") {
-    alignCenter(layoutData);
-  } else if (style.align === "right") {
-    alignRight(layoutData);
-  } else if (style.align === "justify") {
-    alignJustify(layoutData);
-  }
-  return layoutData;
-}
-function alignCenter(measurementData) {
-  for (let i2 = 0;i2 < measurementData.lines.length; i2++) {
-    const line = measurementData.lines[i2];
-    const offset = measurementData.width / 2 - line.width / 2;
-    for (let j2 = 0;j2 < line.charPositions.length; j2++) {
-      line.charPositions[j2] += offset;
-    }
-  }
-}
-function alignRight(measurementData) {
-  for (let i2 = 0;i2 < measurementData.lines.length; i2++) {
-    const line = measurementData.lines[i2];
-    const offset = measurementData.width - line.width;
-    for (let j2 = 0;j2 < line.charPositions.length; j2++) {
-      line.charPositions[j2] += offset;
-    }
-  }
-}
-function alignJustify(measurementData) {
-  const width = measurementData.width;
-  for (let i2 = 0;i2 < measurementData.lines.length; i2++) {
-    const line = measurementData.lines[i2];
-    let indy = 0;
-    let spaceIndex = line.spacesIndex[indy++];
-    let offset = 0;
-    const totalSpaces = line.spacesIndex.length;
-    const newSpaceWidth = (width - line.width) / totalSpaces;
-    const spaceWidth = newSpaceWidth;
-    for (let j2 = 0;j2 < line.charPositions.length; j2++) {
-      if (j2 === spaceIndex) {
-        spaceIndex = line.spacesIndex[indy++];
-        offset += spaceWidth;
-      }
-      line.charPositions[j2] += offset;
-    }
-  }
-}
-var init_getBitmapTextLayout = () => {};
-
-// node_modules/pixi.js/lib/scene/text-bitmap/utils/resolveCharacters.mjs
-function resolveCharacters(chars) {
-  if (chars === "") {
-    return [];
-  }
-  if (typeof chars === "string") {
-    chars = [chars];
-  }
-  const result = [];
-  for (let i2 = 0, j2 = chars.length;i2 < j2; i2++) {
-    const item = chars[i2];
-    if (Array.isArray(item)) {
-      if (item.length !== 2) {
-        throw new Error(`[BitmapFont]: Invalid character range length, expecting 2 got ${item.length}.`);
-      }
-      if (item[0].length === 0 || item[1].length === 0) {
-        throw new Error("[BitmapFont]: Invalid character delimiter.");
-      }
-      const startCode = item[0].charCodeAt(0);
-      const endCode = item[1].charCodeAt(0);
-      if (endCode < startCode) {
-        throw new Error("[BitmapFont]: Invalid character range.");
-      }
-      for (let i22 = startCode, j22 = endCode;i22 <= j22; i22++) {
-        result.push(String.fromCharCode(i22));
-      }
-    } else {
-      result.push(...Array.from(item));
-    }
-  }
-  if (result.length === 0) {
-    throw new Error("[BitmapFont]: Empty set when resolving characters.");
-  }
-  return result;
-}
-var init_resolveCharacters = () => {};
-
-// node_modules/pixi.js/lib/scene/text-bitmap/BitmapFontManager.mjs
-class BitmapFontManagerClass {
-  constructor() {
-    this.ALPHA = [["a", "z"], ["A", "Z"], " "];
-    this.NUMERIC = [["0", "9"]];
-    this.ALPHANUMERIC = [["a", "z"], ["A", "Z"], ["0", "9"], " "];
-    this.ASCII = [[" ", "~"]];
-    this.defaultOptions = {
-      chars: this.ALPHANUMERIC,
-      resolution: 1,
-      padding: 4,
-      skipKerning: false,
-      textureStyle: null
-    };
-    this.measureCache = lru(1000);
-  }
-  getFont(text, style) {
-    let fontFamilyKey = `${style.fontFamily}-bitmap`;
-    let overrideFill = true;
-    if (style._fill.fill && !style._stroke) {
-      fontFamilyKey += style._fill.fill.styleKey;
-      overrideFill = false;
-    } else if (style._stroke || style.dropShadow) {
-      fontFamilyKey = `${style.styleKey}-bitmap`;
-      overrideFill = false;
-    }
-    if (!Cache.has(fontFamilyKey)) {
-      const styleCopy = Object.create(style);
-      styleCopy._lineHeight = 0;
-      const fnt = new DynamicBitmapFont({
-        style: styleCopy,
-        overrideFill,
-        overrideSize: true,
-        ...this.defaultOptions
-      });
-      fontCount++;
-      if (fontCount > 50) {
-        warn("BitmapText", `You have dynamically created ${fontCount} bitmap fonts, this can be inefficient. Try pre installing your font styles using \`BitmapFont.install({name:"style1", style})\``);
-      }
-      fnt.once("destroy", () => {
-        fontCount--;
-        Cache.remove(fontFamilyKey);
-      });
-      Cache.set(fontFamilyKey, fnt);
-    }
-    const dynamicFont = Cache.get(fontFamilyKey);
-    dynamicFont.ensureCharacters?.(text);
-    return dynamicFont;
-  }
-  getLayout(text, style, trimEnd = true) {
-    const bitmapFont = this.getFont(text, style);
-    const id = `${text}-${style.styleKey}-${trimEnd}`;
-    if (this.measureCache.has(id)) {
-      return this.measureCache.get(id);
-    }
-    const segments = CanvasTextMetrics.graphemeSegmenter(text);
-    const layoutData = getBitmapTextLayout(segments, style, bitmapFont, trimEnd);
-    this.measureCache.set(id, layoutData);
-    return layoutData;
-  }
-  measureText(text, style, trimEnd = true) {
-    return this.getLayout(text, style, trimEnd);
-  }
-  install(...args) {
-    let options = args[0];
-    if (typeof options === "string") {
-      options = {
-        name: options,
-        style: args[1],
-        chars: args[2]?.chars,
-        resolution: args[2]?.resolution,
-        padding: args[2]?.padding,
-        skipKerning: args[2]?.skipKerning
-      };
-      deprecation(v8_0_0, "BitmapFontManager.install(name, style, options) is deprecated, use BitmapFontManager.install({name, style, ...options})");
-    }
-    const name = options?.name;
-    if (!name) {
-      throw new Error("[BitmapFontManager] Property `name` is required.");
-    }
-    options = { ...this.defaultOptions, ...options };
-    const textStyle = options.style;
-    const style = textStyle instanceof TextStyle ? textStyle : new TextStyle(textStyle);
-    const overrideFill = options.dynamicFill ?? this._canUseTintForStyle(style);
-    const font = new DynamicBitmapFont({
-      style,
-      overrideFill,
-      skipKerning: options.skipKerning,
-      padding: options.padding,
-      resolution: options.resolution,
-      overrideSize: false,
-      textureStyle: options.textureStyle
-    });
-    const flatChars = resolveCharacters(options.chars);
-    font.ensureCharacters(flatChars.join(""));
-    Cache.set(`${name}-bitmap`, font);
-    font.once("destroy", () => Cache.remove(`${name}-bitmap`));
-    return font;
-  }
-  uninstall(name) {
-    const cacheKey = `${name}-bitmap`;
-    const font = Cache.get(cacheKey);
-    if (font) {
-      font.destroy();
-    }
-  }
-  _canUseTintForStyle(style) {
-    return !style._stroke && (!style.dropShadow || style.dropShadow.color === 0) && !style._fill.fill && style._fill.color === 16777215;
-  }
-}
-var fontCount = 0, BitmapFontManager;
-var init_BitmapFontManager = __esm(() => {
-  init_tiny_lru();
-  init_Cache();
-  init_deprecation();
-  init_warn();
-  init_CanvasTextMetrics();
-  init_TextStyle();
-  init_DynamicBitmapFont();
-  init_getBitmapTextLayout();
-  init_resolveCharacters();
-  BitmapFontManager = new BitmapFontManagerClass;
-});
-
-// node_modules/pixi.js/lib/scene/text-bitmap/BitmapFont.mjs
-var exports_BitmapFont = {};
-__export(exports_BitmapFont, {
-  BitmapFont: () => BitmapFont
-});
-var BitmapFont;
-var init_BitmapFont = __esm(() => {
-  init_groupD8();
-  init_Rectangle();
-  init_Texture();
-  init_AbstractBitmapFont();
-  init_BitmapFontManager();
-  BitmapFont = class BitmapFont extends AbstractBitmapFont {
-    constructor(options, url) {
-      super();
-      const { textures, data } = options;
-      Object.keys(data.pages).forEach((key) => {
-        const pageData = data.pages[parseInt(key, 10)];
-        const texture = textures[pageData.id];
-        this.pages.push({ texture });
-      });
-      Object.keys(data.chars).forEach((key) => {
-        const charData = data.chars[key];
-        const {
-          frame: textureFrame,
-          source: textureSource,
-          rotate: textureRotate
-        } = textures[charData.page];
-        const frame = groupD8.transformRectCoords(charData, textureFrame, textureRotate, new Rectangle);
-        const texture = new Texture({
-          frame,
-          orig: new Rectangle(0, 0, charData.width, charData.height),
-          source: textureSource,
-          rotate: textureRotate
-        });
-        this.chars[key] = {
-          id: key.codePointAt(0),
-          xOffset: charData.xOffset,
-          yOffset: charData.yOffset,
-          xAdvance: charData.xAdvance,
-          kerning: charData.kerning ?? {},
-          texture
-        };
-      });
-      this.baseRenderedFontSize = data.fontSize;
-      this.baseMeasurementFontSize = data.fontSize;
-      this.fontMetrics = {
-        ascent: 0,
-        descent: 0,
-        fontSize: data.fontSize
-      };
-      this.baseLineOffset = data.baseLineOffset;
-      this.lineHeight = data.lineHeight;
-      this.fontFamily = data.fontFamily;
-      this.distanceField = data.distanceField ?? {
-        type: "none",
-        range: 0
-      };
-      this.url = url;
-    }
-    destroy() {
-      super.destroy();
-      for (let i2 = 0;i2 < this.pages.length; i2++) {
-        const { texture } = this.pages[i2];
-        texture.destroy(true);
-      }
-      this.pages = null;
-    }
-    static install(options) {
-      BitmapFontManager.install(options);
-    }
-    static uninstall(name) {
-      BitmapFontManager.uninstall(name);
-    }
-  };
-});
-
-// node_modules/pixi.js/lib/environment-browser/browserExt.mjs
-init_Extensions();
-var browserExt = {
-  extension: {
-    type: ExtensionType.Environment,
-    name: "browser",
-    priority: -1
-  },
-  test: () => true,
-  load: async () => {
-    await Promise.resolve().then(() => (init_browserAll(), exports_browserAll));
-  }
-};
-
-// node_modules/pixi.js/lib/environment-webworker/webworkerExt.mjs
-init_Extensions();
-var webworkerExt = {
-  extension: {
-    type: ExtensionType.Environment,
-    name: "webworker",
-    priority: 0
-  },
-  test: () => typeof self !== "undefined" && self.WorkerGlobalScope !== undefined,
-  load: async () => {
-    await Promise.resolve().then(() => (init_webworkerAll(), exports_webworkerAll));
-  }
-};
-
-// node_modules/pixi.js/lib/index.mjs
-init_Extensions();
-init_init4();
-init_init3();
-
-// node_modules/pixi.js/lib/app/Application.mjs
-init_Extensions();
-
-// node_modules/pixi.js/lib/utils/browser/isWebGLSupported.mjs
-init_adapter();
-init_AbstractRenderer();
-var _isWebGLSupported;
-function isWebGLSupported(failIfMajorPerformanceCaveat) {
-  if (_isWebGLSupported !== undefined)
-    return _isWebGLSupported;
-  _isWebGLSupported = (() => {
-    const contextOptions = {
-      stencil: true,
-      failIfMajorPerformanceCaveat: failIfMajorPerformanceCaveat ?? AbstractRenderer.defaultOptions.failIfMajorPerformanceCaveat
-    };
-    try {
-      if (!DOMAdapter.get().getWebGLRenderingContext()) {
-        return false;
-      }
-      const canvas = DOMAdapter.get().createCanvas();
-      let gl = canvas.getContext("webgl", contextOptions);
-      const success = !!gl?.getContextAttributes()?.stencil;
-      if (gl) {
-        const loseContext = gl.getExtension("WEBGL_lose_context");
-        if (loseContext) {
-          loseContext.loseContext();
-        }
-      }
-      gl = null;
-      return success;
-    } catch (_e) {
-      return false;
+      gl = null;
+      return success;
+    } catch (_e) {
+      return false;
     }
   })();
   return _isWebGLSupported;
@@ -30400,1794 +29673,191 @@ async function autoDetectRenderer(options) {
     } else if (rendererType === "canvas") {
       const { CanvasRenderer: CanvasRenderer2 } = await Promise.resolve().then(() => (init_CanvasRenderer(), exports_CanvasRenderer));
       RendererClass = CanvasRenderer2;
-      finalOptions = { ...options, ...options.canvasOptions };
-      break;
-    }
-  }
-  delete finalOptions.webgpu;
-  delete finalOptions.webgl;
-  delete finalOptions.canvasOptions;
-  if (!RendererClass) {
-    throw new Error("No available renderer for the current environment");
-  }
-  const renderer = new RendererClass;
-  await renderer.init(finalOptions);
-  return renderer;
-}
-
-// node_modules/pixi.js/lib/app/Application.mjs
-init_Container();
-init_globalHooks();
-init_deprecation();
-
-// node_modules/pixi.js/lib/app/init.mjs
-init_Extensions();
-
-// node_modules/pixi.js/lib/app/ResizePlugin.mjs
-init_Extensions();
-
-class ResizePlugin {
-  static init(options) {
-    Object.defineProperty(this, "resizeTo", {
-      configurable: true,
-      set(dom) {
-        globalThis.removeEventListener("resize", this.queueResize);
-        this._resizeTo = dom;
-        if (dom) {
-          globalThis.addEventListener("resize", this.queueResize);
-          this.resize();
-        }
-      },
-      get() {
-        return this._resizeTo;
-      }
-    });
-    this.queueResize = () => {
-      if (!this._resizeTo) {
-        return;
-      }
-      this._cancelResize();
-      this._resizeId = requestAnimationFrame(() => this.resize());
-    };
-    this._cancelResize = () => {
-      if (this._resizeId) {
-        cancelAnimationFrame(this._resizeId);
-        this._resizeId = null;
-      }
-    };
-    this.resize = () => {
-      if (!this._resizeTo) {
-        return;
-      }
-      this._cancelResize();
-      let width;
-      let height;
-      if (this._resizeTo === globalThis.window) {
-        width = globalThis.innerWidth;
-        height = globalThis.innerHeight;
-      } else {
-        const { clientWidth, clientHeight } = this._resizeTo;
-        width = clientWidth;
-        height = clientHeight;
-      }
-      this.renderer.resize(width, height);
-      this.render();
-    };
-    this._resizeId = null;
-    this._resizeTo = null;
-    this.resizeTo = options.resizeTo || null;
-  }
-  static destroy() {
-    globalThis.removeEventListener("resize", this.queueResize);
-    this._cancelResize();
-    this._cancelResize = null;
-    this.queueResize = null;
-    this.resizeTo = null;
-    this.resize = null;
-  }
-}
-ResizePlugin.extension = ExtensionType.Application;
-
-// node_modules/pixi.js/lib/app/TickerPlugin.mjs
-init_Extensions();
-init_const2();
-init_Ticker();
-
-class TickerPlugin {
-  static init(options) {
-    options = Object.assign({
-      autoStart: true,
-      sharedTicker: false
-    }, options);
-    Object.defineProperty(this, "ticker", {
-      configurable: true,
-      set(ticker) {
-        if (this._ticker) {
-          this._ticker.remove(this.render, this);
-        }
-        this._ticker = ticker;
-        if (ticker) {
-          ticker.add(this.render, this, UPDATE_PRIORITY.LOW);
-        }
-      },
-      get() {
-        return this._ticker;
-      }
-    });
-    this.stop = () => {
-      this._ticker.stop();
-    };
-    this.start = () => {
-      this._ticker.start();
-    };
-    this._ticker = null;
-    this.ticker = options.sharedTicker ? Ticker.shared : new Ticker;
-    if (options.autoStart) {
-      this.start();
-    }
-  }
-  static destroy() {
-    if (this._ticker) {
-      const oldTicker = this._ticker;
-      this.ticker = null;
-      oldTicker.destroy();
-    }
-  }
-}
-TickerPlugin.extension = ExtensionType.Application;
-
-// node_modules/pixi.js/lib/app/init.mjs
-extensions.add(ResizePlugin);
-extensions.add(TickerPlugin);
-
-// node_modules/pixi.js/lib/app/Application.mjs
-var _Application = class _Application2 {
-  constructor(...args) {
-    this.stage = new Container;
-    if (args[0] !== undefined) {
-      deprecation(v8_0_0, "Application constructor options are deprecated, please use Application.init() instead.");
-    }
-  }
-  async init(options) {
-    options = { ...options };
-    this.stage || (this.stage = new Container);
-    this.renderer = await autoDetectRenderer(options);
-    _Application2._plugins.forEach((plugin) => {
-      plugin.init.call(this, options);
-    });
-  }
-  render() {
-    this.renderer.render({ container: this.stage });
-  }
-  get canvas() {
-    return this.renderer.canvas;
-  }
-  get view() {
-    deprecation(v8_0_0, "Application.view is deprecated, please use Application.canvas instead.");
-    return this.renderer.canvas;
-  }
-  get screen() {
-    return this.renderer.screen;
-  }
-  destroy(rendererDestroyOptions = false, options = false) {
-    const plugins = _Application2._plugins.slice(0);
-    plugins.reverse();
-    plugins.forEach((plugin) => {
-      plugin.destroy.call(this);
-    });
-    this.stage.destroy(options);
-    this.stage = null;
-    this.renderer.destroy(rendererDestroyOptions);
-    this.renderer = null;
-  }
-};
-_Application._plugins = [];
-var Application = _Application;
-extensions.handleByList(ExtensionType.Application, Application._plugins);
-extensions.add(ApplicationInitHook);
-
-// node_modules/pixi.js/lib/assets/Assets.mjs
-init_Extensions();
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/loadBitmapFont.mjs
-init_LoaderParser();
-init_copySearchParams();
-init_adapter();
-init_Extensions();
-init_path();
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontTextParser.mjs
-var bitmapFontTextParser = {
-  test(data) {
-    return typeof data === "string" && data.startsWith("info face=");
-  },
-  parse(txt) {
-    const items = txt.match(/^[a-z]+\s+.+$/gm);
-    const rawData = {
-      info: [],
-      common: [],
-      page: [],
-      char: [],
-      chars: [],
-      kerning: [],
-      kernings: [],
-      distanceField: []
-    };
-    for (const i2 in items) {
-      const name = items[i2].match(/^[a-z]+/gm)[0];
-      const attributeList = items[i2].match(/[a-zA-Z]+=([^\s"']+|"([^"]*)")/gm);
-      const itemData = {};
-      for (const i22 in attributeList) {
-        const split = attributeList[i22].split("=");
-        const key = split[0];
-        const strValue = split[1].replace(/"/gm, "");
-        const floatValue = parseFloat(strValue);
-        const value = isNaN(floatValue) ? strValue : floatValue;
-        itemData[key] = value;
-      }
-      rawData[name].push(itemData);
-    }
-    const font = {
-      chars: {},
-      pages: [],
-      lineHeight: 0,
-      fontSize: 0,
-      fontFamily: "",
-      distanceField: null,
-      baseLineOffset: 0
-    };
-    const [info] = rawData.info;
-    const [common] = rawData.common;
-    const [distanceField] = rawData.distanceField ?? [];
-    if (distanceField) {
-      font.distanceField = {
-        range: parseInt(distanceField.distanceRange, 10),
-        type: distanceField.fieldType
-      };
-    }
-    font.fontSize = parseInt(info.size, 10);
-    font.fontFamily = info.face;
-    font.lineHeight = parseInt(common.lineHeight, 10);
-    const page = rawData.page;
-    for (let i2 = 0;i2 < page.length; i2++) {
-      font.pages.push({
-        id: parseInt(page[i2].id, 10) || 0,
-        file: page[i2].file
-      });
-    }
-    const map = {};
-    font.baseLineOffset = font.lineHeight - parseInt(common.base, 10);
-    const char = rawData.char;
-    for (let i2 = 0;i2 < char.length; i2++) {
-      const charNode = char[i2];
-      const id = parseInt(charNode.id, 10);
-      let letter = charNode.letter ?? charNode.char ?? String.fromCharCode(id);
-      if (letter === "space")
-        letter = " ";
-      map[id] = letter;
-      font.chars[letter] = {
-        id,
-        page: parseInt(charNode.page, 10) || 0,
-        x: parseInt(charNode.x, 10),
-        y: parseInt(charNode.y, 10),
-        width: parseInt(charNode.width, 10),
-        height: parseInt(charNode.height, 10),
-        xOffset: parseInt(charNode.xoffset, 10),
-        yOffset: parseInt(charNode.yoffset, 10),
-        xAdvance: parseInt(charNode.xadvance, 10),
-        kerning: {}
-      };
-    }
-    const kerning = rawData.kerning || [];
-    for (let i2 = 0;i2 < kerning.length; i2++) {
-      const first = parseInt(kerning[i2].first, 10);
-      const second = parseInt(kerning[i2].second, 10);
-      const amount = parseInt(kerning[i2].amount, 10);
-      font.chars[map[second]].kerning[map[first]] = amount;
-    }
-    return font;
-  }
-};
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.mjs
-init_adapter();
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLParser.mjs
-var bitmapFontXMLParser = {
-  test(data) {
-    const xml = data;
-    return typeof xml !== "string" && "getElementsByTagName" in xml && xml.getElementsByTagName("page").length && xml.getElementsByTagName("info")[0].getAttribute("face") !== null;
-  },
-  parse(xml) {
-    const data = {
-      chars: {},
-      pages: [],
-      lineHeight: 0,
-      fontSize: 0,
-      fontFamily: "",
-      distanceField: null,
-      baseLineOffset: 0
-    };
-    const info = xml.getElementsByTagName("info")[0];
-    const common = xml.getElementsByTagName("common")[0];
-    const distanceField = xml.getElementsByTagName("distanceField")[0];
-    if (distanceField) {
-      data.distanceField = {
-        type: distanceField.getAttribute("fieldType"),
-        range: parseInt(distanceField.getAttribute("distanceRange"), 10)
-      };
-    }
-    const page = xml.getElementsByTagName("page");
-    const char = xml.getElementsByTagName("char");
-    const kerning = xml.getElementsByTagName("kerning");
-    data.fontSize = parseInt(info.getAttribute("size"), 10);
-    data.fontFamily = info.getAttribute("face");
-    data.lineHeight = parseInt(common.getAttribute("lineHeight"), 10);
-    for (let i2 = 0;i2 < page.length; i2++) {
-      data.pages.push({
-        id: parseInt(page[i2].getAttribute("id"), 10) || 0,
-        file: page[i2].getAttribute("file")
-      });
-    }
-    const map = {};
-    data.baseLineOffset = data.lineHeight - parseInt(common.getAttribute("base"), 10);
-    for (let i2 = 0;i2 < char.length; i2++) {
-      const charNode = char[i2];
-      const id = parseInt(charNode.getAttribute("id"), 10);
-      let letter = charNode.getAttribute("letter") ?? charNode.getAttribute("char") ?? String.fromCharCode(id);
-      if (letter === "space")
-        letter = " ";
-      map[id] = letter;
-      data.chars[letter] = {
-        id,
-        page: parseInt(charNode.getAttribute("page"), 10) || 0,
-        x: parseInt(charNode.getAttribute("x"), 10),
-        y: parseInt(charNode.getAttribute("y"), 10),
-        width: parseInt(charNode.getAttribute("width"), 10),
-        height: parseInt(charNode.getAttribute("height"), 10),
-        xOffset: parseInt(charNode.getAttribute("xoffset"), 10),
-        yOffset: parseInt(charNode.getAttribute("yoffset"), 10),
-        xAdvance: parseInt(charNode.getAttribute("xadvance"), 10),
-        kerning: {}
-      };
-    }
-    for (let i2 = 0;i2 < kerning.length; i2++) {
-      const first = parseInt(kerning[i2].getAttribute("first"), 10);
-      const second = parseInt(kerning[i2].getAttribute("second"), 10);
-      const amount = parseInt(kerning[i2].getAttribute("amount"), 10);
-      data.chars[map[second]].kerning[map[first]] = amount;
-    }
-    return data;
-  }
-};
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/bitmapFontXMLStringParser.mjs
-var bitmapFontXMLStringParser = {
-  test(data) {
-    if (typeof data === "string" && data.match(/<font(\s|>)/)) {
-      return bitmapFontXMLParser.test(DOMAdapter.get().parseXML(data));
-    }
-    return false;
-  },
-  parse(data) {
-    return bitmapFontXMLParser.parse(DOMAdapter.get().parseXML(data));
-  }
-};
-
-// node_modules/pixi.js/lib/scene/text-bitmap/asset/loadBitmapFont.mjs
-var validExtensions = [".xml", ".fnt"];
-var bitmapFontCachePlugin = {
-  extension: {
-    type: ExtensionType.CacheParser,
-    name: "cacheBitmapFont"
-  },
-  test: (asset) => !!asset?.pages && !!asset?.chars && typeof asset?.fontFamily === "string",
-  getCacheableAssets(keys, asset) {
-    const out2 = {};
-    keys.forEach((key) => {
-      out2[key] = asset;
-      out2[`${key}-bitmap`] = asset;
-    });
-    out2[`${asset.fontFamily}-bitmap`] = asset;
-    return out2;
-  }
-};
-var loadBitmapFont = {
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.Normal
-  },
-  name: "loadBitmapFont",
-  id: "bitmap-font",
-  test(url) {
-    return validExtensions.includes(path.extname(url).toLowerCase());
-  },
-  async testParse(data) {
-    return bitmapFontTextParser.test(data) || bitmapFontXMLStringParser.test(data);
-  },
-  async parse(asset, data, loader) {
-    const bitmapFontData = bitmapFontTextParser.test(asset) ? bitmapFontTextParser.parse(asset) : bitmapFontXMLStringParser.parse(asset);
-    const { src } = data;
-    const { pages } = bitmapFontData;
-    const textureUrls = [];
-    const textureOptions = bitmapFontData.distanceField ? {
-      scaleMode: "linear",
-      alphaMode: "premultiply-alpha-on-upload",
-      autoGenerateMipmaps: false,
-      resolution: 1
-    } : {};
-    for (let i2 = 0;i2 < pages.length; ++i2) {
-      const pageFile = pages[i2].file;
-      let imagePath = path.join(path.dirname(src), pageFile);
-      imagePath = copySearchParams(imagePath, src);
-      textureUrls.push({
-        src: imagePath,
-        data: textureOptions
-      });
-    }
-    const [loadedTextures, { BitmapFont: BitmapFont2 }] = await Promise.all([
-      loader.load(textureUrls),
-      Promise.resolve().then(() => (init_BitmapFont(), exports_BitmapFont))
-    ]);
-    const textures = textureUrls.map((url) => loadedTextures[url.src]);
-    const bitmapFont = new BitmapFont2({
-      data: bitmapFontData,
-      textures
-    }, src);
-    return bitmapFont;
-  },
-  async load(url, _options) {
-    const response = await DOMAdapter.get().fetch(url);
-    return await response.text();
-  },
-  async unload(bitmapFont, _resolvedAsset, loader) {
-    await Promise.all(bitmapFont.pages.map((page) => loader.unload(page.texture.source._sourceOrigin)));
-    bitmapFont.destroy();
-  }
-};
-
-// node_modules/pixi.js/lib/assets/Assets.mjs
-init_warn();
-
-// node_modules/pixi.js/lib/assets/BackgroundLoader.mjs
-class BackgroundLoader {
-  constructor(loader, verbose = false) {
-    this._loader = loader;
-    this._assetList = [];
-    this._isLoading = false;
-    this._maxConcurrent = 1;
-    this.verbose = verbose;
-  }
-  add(assetUrls) {
-    assetUrls.forEach((a2) => {
-      this._assetList.push(a2);
-    });
-    if (this.verbose) {
-      console.log("[BackgroundLoader] assets: ", this._assetList);
-    }
-    if (this._isActive && !this._isLoading) {
-      this._next();
-    }
-  }
-  async _next() {
-    if (this._assetList.length && this._isActive) {
-      this._isLoading = true;
-      const toLoad = [];
-      const toLoadAmount = Math.min(this._assetList.length, this._maxConcurrent);
-      for (let i2 = 0;i2 < toLoadAmount; i2++) {
-        toLoad.push(this._assetList.pop());
-      }
-      await this._loader.load(toLoad);
-      this._isLoading = false;
-      this._next();
-    }
-  }
-  get active() {
-    return this._isActive;
-  }
-  set active(value) {
-    if (this._isActive === value)
-      return;
-    this._isActive = value;
-    if (value && !this._isLoading) {
-      this._next();
-    }
-  }
-}
-
-// node_modules/pixi.js/lib/assets/Assets.mjs
-init_Cache();
-
-// node_modules/pixi.js/lib/assets/cache/parsers/cacheTextureArray.mjs
-init_Extensions();
-init_Texture();
-var cacheTextureArray = {
-  extension: {
-    type: ExtensionType.CacheParser,
-    name: "cacheTextureArray"
-  },
-  test: (asset) => Array.isArray(asset) && asset.every((t2) => t2 instanceof Texture),
-  getCacheableAssets: (keys, asset) => {
-    const out2 = {};
-    keys.forEach((key) => {
-      asset.forEach((item, i2) => {
-        out2[key + (i2 === 0 ? "" : i2 + 1)] = item;
-      });
-    });
-    return out2;
-  }
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectAvif.mjs
-init_Extensions();
-
-// node_modules/pixi.js/lib/assets/detections/utils/testImageFormat.mjs
-async function testImageFormat(imageData) {
-  if ("Image" in globalThis) {
-    return new Promise((resolve) => {
-      const image = new Image;
-      image.onload = () => {
-        resolve(true);
-      };
-      image.onerror = () => {
-        resolve(false);
-      };
-      image.src = imageData;
-    });
-  }
-  if ("createImageBitmap" in globalThis && "fetch" in globalThis) {
-    try {
-      const blob = await (await fetch(imageData)).blob();
-      await createImageBitmap(blob);
-    } catch (_e) {
-      return false;
-    }
-    return true;
-  }
-  return false;
-}
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectAvif.mjs
-var detectAvif = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: 1
-  },
-  test: async () => testImageFormat("data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAACVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A="),
-  add: async (formats) => [...formats, "avif"],
-  remove: async (formats) => formats.filter((f2) => f2 !== "avif")
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectDefaults.mjs
-init_Extensions();
-var imageFormats = ["png", "jpg", "jpeg"];
-var detectDefaults = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: -1
-  },
-  test: () => Promise.resolve(true),
-  add: async (formats) => [...formats, ...imageFormats],
-  remove: async (formats) => formats.filter((f2) => !imageFormats.includes(f2))
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectMp4.mjs
-init_Extensions();
-
-// node_modules/pixi.js/lib/assets/detections/utils/testVideoFormat.mjs
-var inWorker = "WorkerGlobalScope" in globalThis && globalThis instanceof globalThis.WorkerGlobalScope;
-function testVideoFormat(mimeType) {
-  if (inWorker) {
-    return false;
-  }
-  const video = document.createElement("video");
-  return video.canPlayType(mimeType) !== "";
-}
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectMp4.mjs
-var detectMp4 = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: 0
-  },
-  test: async () => testVideoFormat("video/mp4"),
-  add: async (formats) => [...formats, "mp4", "m4v"],
-  remove: async (formats) => formats.filter((f2) => f2 !== "mp4" && f2 !== "m4v")
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectOgv.mjs
-init_Extensions();
-var detectOgv = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: 0
-  },
-  test: async () => testVideoFormat("video/ogg"),
-  add: async (formats) => [...formats, "ogv"],
-  remove: async (formats) => formats.filter((f2) => f2 !== "ogv")
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectWebm.mjs
-init_Extensions();
-var detectWebm = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: 0
-  },
-  test: async () => testVideoFormat("video/webm"),
-  add: async (formats) => [...formats, "webm"],
-  remove: async (formats) => formats.filter((f2) => f2 !== "webm")
-};
-
-// node_modules/pixi.js/lib/assets/detections/parsers/detectWebp.mjs
-init_Extensions();
-var detectWebp = {
-  extension: {
-    type: ExtensionType.DetectionParser,
-    priority: 0
-  },
-  test: async () => testImageFormat("data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAAAAAAfQ//73v/+BiOh/AAA="),
-  add: async (formats) => [...formats, "webp"],
-  remove: async (formats) => formats.filter((f2) => f2 !== "webp")
-};
-
-// node_modules/pixi.js/lib/assets/loader/Loader.mjs
-init_warn();
-init_path();
-init_convertToList();
-init_isSingleItem();
-var _Loader = class _Loader2 {
-  constructor() {
-    this.loadOptions = { ..._Loader2.defaultOptions };
-    this._parsers = [];
-    this._parsersValidated = false;
-    this.parsers = new Proxy(this._parsers, {
-      set: (target, key, value) => {
-        this._parsersValidated = false;
-        target[key] = value;
-        return true;
-      }
-    });
-    this.promiseCache = {};
-  }
-  reset() {
-    this._parsersValidated = false;
-    this.promiseCache = {};
-  }
-  _getLoadPromiseAndParser(url, data) {
-    const result = {
-      promise: null,
-      parser: null
-    };
-    result.promise = (async () => {
-      let asset = null;
-      let parser = null;
-      if (data.parser || data.loadParser) {
-        parser = this._parserHash[data.parser || data.loadParser];
-        if (data.loadParser) {
-          warn(`[Assets] "loadParser" is deprecated, use "parser" instead for ${url}`);
-        }
-        if (!parser) {
-          warn(`[Assets] specified load parser "${data.parser || data.loadParser}" not found while loading ${url}`);
-        }
-      }
-      if (!parser) {
-        for (let i2 = 0;i2 < this.parsers.length; i2++) {
-          const parserX = this.parsers[i2];
-          if (parserX.load && parserX.test?.(url, data, this)) {
-            parser = parserX;
-            break;
-          }
-        }
-        if (!parser) {
-          warn(`[Assets] ${url} could not be loaded as we don't know how to parse it, ensure the correct parser has been added`);
-          return null;
-        }
-      }
-      asset = await parser.load(url, data, this);
-      result.parser = parser;
-      for (let i2 = 0;i2 < this.parsers.length; i2++) {
-        const parser2 = this.parsers[i2];
-        if (parser2.parse) {
-          if (parser2.parse && await parser2.testParse?.(asset, data, this)) {
-            asset = await parser2.parse(asset, data, this) || asset;
-            result.parser = parser2;
-          }
-        }
-      }
-      return asset;
-    })();
-    return result;
-  }
-  async load(assetsToLoadIn, onProgressOrOptions) {
-    if (!this._parsersValidated) {
-      this._validateParsers();
-    }
-    const options = typeof onProgressOrOptions === "function" ? { ..._Loader2.defaultOptions, ...this.loadOptions, onProgress: onProgressOrOptions } : { ..._Loader2.defaultOptions, ...this.loadOptions, ...onProgressOrOptions || {} };
-    const { onProgress, onError, strategy, retryCount, retryDelay } = options;
-    let count2 = 0;
-    const assets = {};
-    const singleAsset = isSingleItem(assetsToLoadIn);
-    const assetsToLoad = convertToList(assetsToLoadIn, (item) => ({
-      alias: [item],
-      src: item,
-      data: {}
-    }));
-    const total = assetsToLoad.reduce((sum, asset) => sum + (asset.progressSize || 1), 0);
-    const promises = assetsToLoad.map(async (asset) => {
-      const url = path.toAbsolute(asset.src);
-      if (assets[asset.src])
-        return;
-      await this._loadAssetWithRetry(url, asset, { onProgress, onError, strategy, retryCount, retryDelay }, assets);
-      count2 += asset.progressSize || 1;
-      if (onProgress)
-        onProgress(count2 / total);
-    });
-    await Promise.all(promises);
-    return singleAsset ? assets[assetsToLoad[0].src] : assets;
-  }
-  async unload(assetsToUnloadIn) {
-    const assetsToUnload = convertToList(assetsToUnloadIn, (item) => ({
-      alias: [item],
-      src: item
-    }));
-    const promises = assetsToUnload.map(async (asset) => {
-      const url = path.toAbsolute(asset.src);
-      const loadPromise = this.promiseCache[url];
-      if (loadPromise) {
-        const loadedAsset = await loadPromise.promise;
-        delete this.promiseCache[url];
-        await loadPromise.parser?.unload?.(loadedAsset, asset, this);
-      }
-    });
-    await Promise.all(promises);
-  }
-  _validateParsers() {
-    this._parsersValidated = true;
-    this._parserHash = this._parsers.filter((parser) => parser.name || parser.id).reduce((hash, parser) => {
-      if (!parser.name && !parser.id) {
-        warn(`[Assets] parser should have an id`);
-      } else if (hash[parser.name] || hash[parser.id]) {
-        warn(`[Assets] parser id conflict "${parser.id}"`);
-      }
-      hash[parser.name] = parser;
-      if (parser.id)
-        hash[parser.id] = parser;
-      return hash;
-    }, {});
-  }
-  async _loadAssetWithRetry(url, asset, options, assets) {
-    let attempt = 0;
-    const { onError, strategy, retryCount, retryDelay } = options;
-    const wait = (ms) => new Promise((r2) => setTimeout(r2, ms));
-    while (true) {
-      try {
-        if (!this.promiseCache[url]) {
-          this.promiseCache[url] = this._getLoadPromiseAndParser(url, asset);
-        }
-        assets[asset.src] = await this.promiseCache[url].promise;
-        return;
-      } catch (e2) {
-        delete this.promiseCache[url];
-        delete assets[asset.src];
-        attempt++;
-        const isLast = strategy !== "retry" || attempt > retryCount;
-        if (strategy === "retry" && !isLast) {
-          if (onError)
-            onError(e2, asset);
-          await wait(retryDelay);
-          continue;
-        }
-        if (strategy === "skip") {
-          if (onError)
-            onError(e2, asset);
-          return;
-        }
-        if (onError)
-          onError(e2, asset);
-        const error = new Error(`[Loader.load] Failed to load ${url}.
-${e2}`);
-        if (e2 instanceof Error && e2.stack) {
-          error.stack = e2.stack;
-        }
-        throw error;
-      }
-    }
-  }
-};
-_Loader.defaultOptions = {
-  onProgress: undefined,
-  onError: undefined,
-  strategy: "throw",
-  retryCount: 3,
-  retryDelay: 250
-};
-var Loader = _Loader;
-
-// node_modules/pixi.js/lib/assets/loader/parsers/loadJson.mjs
-init_adapter();
-init_Extensions();
-
-// node_modules/pixi.js/lib/assets/utils/checkDataUrl.mjs
-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}`);
-}
-
-// node_modules/pixi.js/lib/assets/utils/checkExtension.mjs
-init_path();
-function checkExtension(url, extension) {
-  const tempURL = url.split("?")[0];
-  const ext = path.extname(tempURL).toLowerCase();
-  if (Array.isArray(extension)) {
-    return extension.includes(ext);
-  }
-  return ext === extension;
-}
-
-// node_modules/pixi.js/lib/assets/loader/parsers/loadJson.mjs
-init_LoaderParser();
-var validJSONExtension = ".json";
-var validJSONMIME = "application/json";
-var loadJson = {
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.Low
-  },
-  name: "loadJson",
-  id: "json",
-  test(url) {
-    return checkDataUrl(url, validJSONMIME) || checkExtension(url, validJSONExtension);
-  },
-  async load(url) {
-    const response = await DOMAdapter.get().fetch(url);
-    const json = await response.json();
-    return json;
-  }
-};
-
-// node_modules/pixi.js/lib/assets/loader/parsers/loadTxt.mjs
-init_adapter();
-init_Extensions();
-init_LoaderParser();
-var validTXTExtension = ".txt";
-var validTXTMIME = "text/plain";
-var loadTxt = {
-  name: "loadTxt",
-  id: "text",
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.Low,
-    name: "loadTxt"
-  },
-  test(url) {
-    return checkDataUrl(url, validTXTMIME) || checkExtension(url, validTXTExtension);
-  },
-  async load(url) {
-    const response = await DOMAdapter.get().fetch(url);
-    const txt = await response.text();
-    return txt;
-  }
-};
-
-// node_modules/pixi.js/lib/assets/loader/parsers/loadWebFont.mjs
-init_adapter();
-init_Extensions();
-init_warn();
-init_path();
-init_Cache();
-init_LoaderParser();
-var validWeights = [
-  "normal",
-  "bold",
-  "100",
-  "200",
-  "300",
-  "400",
-  "500",
-  "600",
-  "700",
-  "800",
-  "900"
-];
-var validFontExtensions = [".ttf", ".otf", ".woff", ".woff2"];
-var validFontMIMEs = [
-  "font/ttf",
-  "font/otf",
-  "font/woff",
-  "font/woff2"
-];
-var CSS_IDENT_TOKEN_REGEX = /^(--|-?[A-Z_])[0-9A-Z_-]*$/i;
-function getFontFamilyName(url) {
-  const ext = path.extname(url);
-  const name = path.basename(url, ext);
-  const nameWithSpaces = name.replace(/(-|_)/g, " ");
-  const nameTokens = nameWithSpaces.toLowerCase().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1));
-  let valid = nameTokens.length > 0;
-  for (const token of nameTokens) {
-    if (!token.match(CSS_IDENT_TOKEN_REGEX)) {
-      valid = false;
-      break;
-    }
-  }
-  let fontFamilyName = nameTokens.join(" ");
-  if (!valid) {
-    fontFamilyName = `"${fontFamilyName.replace(/[\\"]/g, "\\$&")}"`;
-  }
-  return fontFamilyName;
-}
-var validURICharactersRegex = /^[0-9A-Za-z%:/?#\[\]@!\$&'()\*\+,;=\-._~]*$/;
-function encodeURIWhenNeeded(uri) {
-  if (validURICharactersRegex.test(uri)) {
-    return uri;
-  }
-  return encodeURI(uri);
-}
-var loadWebFont = {
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.Low
-  },
-  name: "loadWebFont",
-  id: "web-font",
-  test(url) {
-    return checkDataUrl(url, validFontMIMEs) || checkExtension(url, validFontExtensions);
-  },
-  async load(url, options) {
-    const fonts = DOMAdapter.get().getFontFaceSet();
-    if (fonts) {
-      const fontFaces = [];
-      const name = options.data?.family ?? getFontFamilyName(url);
-      const weights = options.data?.weights?.filter((weight) => validWeights.includes(weight)) ?? ["normal"];
-      const data = options.data ?? {};
-      for (let i2 = 0;i2 < weights.length; i2++) {
-        const weight = weights[i2];
-        const font = new FontFace(name, `url(${encodeURIWhenNeeded(url)})`, {
-          ...data,
-          weight
-        });
-        await font.load();
-        fonts.add(font);
-        fontFaces.push(font);
-      }
-      if (Cache.has(`${name}-and-url`)) {
-        const cached = Cache.get(`${name}-and-url`);
-        cached.entries.push({ url, faces: fontFaces });
-      } else {
-        Cache.set(`${name}-and-url`, {
-          entries: [{ url, faces: fontFaces }]
-        });
-      }
-      return fontFaces.length === 1 ? fontFaces[0] : fontFaces;
-    }
-    warn("[loadWebFont] FontFace API is not supported. Skipping loading font");
-    return null;
-  },
-  unload(font) {
-    const fonts = Array.isArray(font) ? font : [font];
-    const fontFamily = fonts[0].family;
-    const cached = Cache.get(`${fontFamily}-and-url`);
-    const entry = cached.entries.find((f2) => f2.faces.some((t2) => fonts.indexOf(t2) !== -1));
-    entry.faces = entry.faces.filter((f2) => fonts.indexOf(f2) === -1);
-    if (entry.faces.length === 0) {
-      cached.entries = cached.entries.filter((f2) => f2 !== entry);
-    }
-    fonts.forEach((t2) => {
-      DOMAdapter.get().getFontFaceSet().delete(t2);
-    });
-    if (cached.entries.length === 0) {
-      Cache.remove(`${fontFamily}-and-url`);
-    }
-  }
-};
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.mjs
-init_adapter();
-init_Extensions();
-init_ImageSource();
-init_GraphicsContext();
-
-// node_modules/pixi.js/lib/utils/network/getResolutionOfUrl.mjs
-init_Resolver();
-function getResolutionOfUrl(url, defaultValue2 = 1) {
-  const resolution = Resolver.RETINA_PREFIX?.exec(url);
-  if (resolution) {
-    return parseFloat(resolution[1]);
-  }
-  return defaultValue2;
-}
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.mjs
-init_LoaderParser();
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/utils/createTexture.mjs
-init_Texture();
-init_warn();
-init_Cache();
-function createTexture(source3, loader, url) {
-  source3.label = url;
-  source3._sourceOrigin = url;
-  const texture = new Texture({
-    source: source3,
-    label: url
-  });
-  const unload = () => {
-    delete loader.promiseCache[url];
-    if (Cache.has(url)) {
-      Cache.remove(url);
-    }
-  };
-  texture.source.once("destroy", () => {
-    if (loader.promiseCache[url]) {
-      warn("[Assets] A TextureSource managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the TextureSource.");
-      unload();
-    }
-  });
-  texture.once("destroy", () => {
-    if (!source3.destroyed) {
-      warn("[Assets] A Texture managed by Assets was destroyed instead of unloaded! Use Assets.unload() instead of destroying the Texture.");
-      unload();
-    }
-  });
-  return texture;
-}
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadSVG.mjs
-var validSVGExtension = ".svg";
-var validSVGMIME = "image/svg+xml";
-var loadSvg = {
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.Low,
-    name: "loadSVG"
-  },
-  name: "loadSVG",
-  id: "svg",
-  config: {
-    crossOrigin: "anonymous",
-    parseAsGraphicsContext: false
-  },
-  test(url) {
-    return checkDataUrl(url, validSVGMIME) || checkExtension(url, validSVGExtension);
-  },
-  async load(url, asset, loader) {
-    if (asset.data?.parseAsGraphicsContext ?? this.config.parseAsGraphicsContext) {
-      return loadAsGraphics(url);
-    }
-    return loadAsTexture(url, asset, loader, this.config.crossOrigin);
-  },
-  unload(asset) {
-    asset.destroy(true);
-  }
-};
-async function loadAsTexture(url, asset, loader, crossOrigin) {
-  const response = await DOMAdapter.get().fetch(url);
-  const image = DOMAdapter.get().createImage();
-  image.src = `data:image/svg+xml;charset=utf-8,${encodeURIComponent(await response.text())}`;
-  image.crossOrigin = crossOrigin;
-  await image.decode();
-  const width = asset.data?.width ?? image.width;
-  const height = asset.data?.height ?? image.height;
-  const resolution = asset.data?.resolution || getResolutionOfUrl(url);
-  const canvasWidth = Math.ceil(width * resolution);
-  const canvasHeight = Math.ceil(height * resolution);
-  const canvas = DOMAdapter.get().createCanvas(canvasWidth, canvasHeight);
-  const context2 = canvas.getContext("2d");
-  context2.imageSmoothingEnabled = true;
-  context2.imageSmoothingQuality = "high";
-  context2.drawImage(image, 0, 0, width * resolution, height * resolution);
-  const { parseAsGraphicsContext: _p, ...rest } = asset.data ?? {};
-  const base = new ImageSource({
-    resource: canvas,
-    alphaMode: "premultiply-alpha-on-upload",
-    resolution,
-    ...rest
-  });
-  return createTexture(base, loader, url);
-}
-async function loadAsGraphics(url) {
-  const response = await DOMAdapter.get().fetch(url);
-  const svgSource = await response.text();
-  const context2 = new GraphicsContext;
-  context2.svg(svgSource);
-  return context2;
-}
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadTextures.mjs
-init_adapter();
-init_Extensions();
-init_ImageSource();
-
-// node_modules/pixi.js/lib/_virtual/checkImageBitmap.worker.mjs
-var WORKER_CODE = `(function () {
-    'use strict';
-
-    const WHITE_PNG = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+ip1sAAAAASUVORK5CYII=";
-    async function checkImageBitmap() {
-      try {
-        if (typeof createImageBitmap !== "function") return false;
-        const response = await fetch(WHITE_PNG);
-        const imageBlob = await response.blob();
-        const imageBitmap = await createImageBitmap(imageBlob);
-        return imageBitmap.width === 1 && imageBitmap.height === 1;
-      } catch (_e) {
-        return false;
-      }
-    }
-    void checkImageBitmap().then((result) => {
-      self.postMessage(result);
-    });
-
-})();
-`;
-var WORKER_URL = null;
-
-class WorkerInstance {
-  constructor() {
-    if (!WORKER_URL) {
-      WORKER_URL = URL.createObjectURL(new Blob([WORKER_CODE], { type: "application/javascript" }));
-    }
-    this.worker = new Worker(WORKER_URL);
-  }
-}
-WorkerInstance.revokeObjectURL = function revokeObjectURL() {
-  if (WORKER_URL) {
-    URL.revokeObjectURL(WORKER_URL);
-    WORKER_URL = null;
-  }
-};
-
-// node_modules/pixi.js/lib/_virtual/loadImageBitmap.worker.mjs
-var WORKER_CODE2 = `(function () {
-    'use strict';
-
-    async function loadImageBitmap(url, alphaMode) {
-      const response = await fetch(url);
-      if (!response.ok) {
-        throw new Error(\`[WorkerManager.loadImageBitmap] Failed to fetch \${url}: \${response.status} \${response.statusText}\`);
-      }
-      const imageBlob = await response.blob();
-      return alphaMode === "premultiplied-alpha" ? createImageBitmap(imageBlob, { premultiplyAlpha: "none" }) : createImageBitmap(imageBlob);
-    }
-    self.onmessage = async (event) => {
-      try {
-        const imageBitmap = await loadImageBitmap(event.data.data[0], event.data.data[1]);
-        self.postMessage({
-          data: imageBitmap,
-          uuid: event.data.uuid,
-          id: event.data.id
-        }, [imageBitmap]);
-      } catch (e) {
-        self.postMessage({
-          error: e,
-          uuid: event.data.uuid,
-          id: event.data.id
-        });
-      }
-    };
-
-})();
-`;
-var WORKER_URL2 = null;
-
-class WorkerInstance2 {
-  constructor() {
-    if (!WORKER_URL2) {
-      WORKER_URL2 = URL.createObjectURL(new Blob([WORKER_CODE2], { type: "application/javascript" }));
-    }
-    this.worker = new Worker(WORKER_URL2);
-  }
-}
-WorkerInstance2.revokeObjectURL = function revokeObjectURL2() {
-  if (WORKER_URL2) {
-    URL.revokeObjectURL(WORKER_URL2);
-    WORKER_URL2 = null;
-  }
-};
-
-// node_modules/pixi.js/lib/assets/loader/workers/WorkerManager.mjs
-var UUID = 0;
-var MAX_WORKERS;
-
-class WorkerManagerClass {
-  constructor() {
-    this._initialized = false;
-    this._createdWorkers = 0;
-    this._workerPool = [];
-    this._queue = [];
-    this._resolveHash = {};
-  }
-  isImageBitmapSupported() {
-    if (this._isImageBitmapSupported !== undefined)
-      return this._isImageBitmapSupported;
-    this._isImageBitmapSupported = new Promise((resolve) => {
-      const { worker } = new WorkerInstance;
-      worker.addEventListener("message", (event) => {
-        worker.terminate();
-        WorkerInstance.revokeObjectURL();
-        resolve(event.data);
-      });
-    });
-    return this._isImageBitmapSupported;
-  }
-  loadImageBitmap(src, asset) {
-    return this._run("loadImageBitmap", [src, asset?.data?.alphaMode]);
-  }
-  async _initWorkers() {
-    if (this._initialized)
-      return;
-    this._initialized = true;
-  }
-  _getWorker() {
-    if (MAX_WORKERS === undefined) {
-      MAX_WORKERS = navigator.hardwareConcurrency || 4;
-    }
-    let worker = this._workerPool.pop();
-    if (!worker && this._createdWorkers < MAX_WORKERS) {
-      this._createdWorkers++;
-      worker = new WorkerInstance2().worker;
-      worker.addEventListener("message", (event) => {
-        this._complete(event.data);
-        this._returnWorker(event.target);
-        this._next();
-      });
-    }
-    return worker;
-  }
-  _returnWorker(worker) {
-    this._workerPool.push(worker);
-  }
-  _complete(data) {
-    if (!this._resolveHash[data.uuid]) {
-      return;
-    }
-    if (data.error !== undefined) {
-      this._resolveHash[data.uuid].reject(data.error);
-    } else {
-      this._resolveHash[data.uuid].resolve(data.data);
-    }
-    delete this._resolveHash[data.uuid];
-  }
-  async _run(id, args) {
-    await this._initWorkers();
-    const promise2 = new Promise((resolve, reject) => {
-      this._queue.push({ id, arguments: args, resolve, reject });
-    });
-    this._next();
-    return promise2;
-  }
-  _next() {
-    if (!this._queue.length)
-      return;
-    const worker = this._getWorker();
-    if (!worker) {
-      return;
-    }
-    const toDo = this._queue.pop();
-    const id = toDo.id;
-    this._resolveHash[UUID] = { resolve: toDo.resolve, reject: toDo.reject };
-    worker.postMessage({
-      data: toDo.arguments,
-      uuid: UUID++,
-      id
-    });
-  }
-  reset() {
-    this._workerPool.forEach((worker) => worker.terminate());
-    this._workerPool.length = 0;
-    Object.values(this._resolveHash).forEach(({ reject }) => {
-      reject?.(new Error("WorkerManager has been reset before completion"));
-    });
-    this._resolveHash = {};
-    this._queue.length = 0;
-    this._initialized = false;
-    this._createdWorkers = 0;
-  }
-}
-var WorkerManager = new WorkerManagerClass;
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadTextures.mjs
-init_LoaderParser();
-var validImageExtensions = [".jpeg", ".jpg", ".png", ".webp", ".avif"];
-var validImageMIMEs = [
-  "image/jpeg",
-  "image/png",
-  "image/webp",
-  "image/avif"
-];
-async function loadImageBitmap(url, asset) {
-  const response = await DOMAdapter.get().fetch(url);
-  if (!response.ok) {
-    throw new Error(`[loadImageBitmap] Failed to fetch ${url}: ${response.status} ${response.statusText}`);
-  }
-  const imageBlob = await response.blob();
-  return asset?.data?.alphaMode === "premultiplied-alpha" ? createImageBitmap(imageBlob, { premultiplyAlpha: "none" }) : createImageBitmap(imageBlob);
-}
-var loadTextures = {
-  name: "loadTextures",
-  id: "texture",
-  extension: {
-    type: ExtensionType.LoadParser,
-    priority: LoaderParserPriority.High,
-    name: "loadTextures"
-  },
-  config: {
-    preferWorkers: true,
-    preferCreateImageBitmap: true,
-    crossOrigin: "anonymous"
-  },
-  test(url) {
-    return checkDataUrl(url, validImageMIMEs) || checkExtension(url, validImageExtensions);
-  },
-  async load(url, asset, loader) {
-    let src = null;
-    if (globalThis.createImageBitmap && this.config.preferCreateImageBitmap) {
-      if (this.config.preferWorkers && await WorkerManager.isImageBitmapSupported()) {
-        src = await WorkerManager.loadImageBitmap(url, asset);
-      } else {
-        src = await loadImageBitmap(url, asset);
-      }
-    } else {
-      src = await new Promise((resolve, reject) => {
-        src = DOMAdapter.get().createImage();
-        src.crossOrigin = this.config.crossOrigin;
-        src.src = url;
-        if (src.complete) {
-          resolve(src);
-        } else {
-          src.onload = () => {
-            resolve(src);
-          };
-          src.onerror = reject;
-        }
-      });
-    }
-    const base = new ImageSource({
-      resource: src,
-      alphaMode: "premultiply-alpha-on-upload",
-      resolution: asset.data?.resolution || getResolutionOfUrl(url),
-      ...asset.data
-    });
-    return createTexture(base, loader, url);
-  },
-  unload(texture) {
-    texture.destroy(true);
-  }
-};
-
-// node_modules/pixi.js/lib/assets/loader/parsers/textures/loadVideoTextures.mjs
-init_Extensions();
-init_VideoSource();
-init_detectVideoAlphaMode();
-var potentialVideoExtensions = [".mp4", ".m4v", ".webm", ".ogg", ".ogv", ".h264", ".avi", ".mov"];
-var validVideoExtensions;
-var validVideoMIMEs;
-function crossOrigin(element, url, crossorigin) {
-  if (crossorigin === undefined && !url.startsWith("data:")) {
-    element.crossOrigin = determineCrossOrigin(url);
-  } else if (crossorigin !== false) {
-    element.crossOrigin = typeof crossorigin === "string" ? crossorigin : "anonymous";
-  }
-}
-function preloadVideo(element) {
-  return new Promise((resolve, reject) => {
-    element.addEventListener("canplaythrough", loaded);
-    element.addEventListener("error", error);
-    element.load();
-    function loaded() {
-      cleanup();
-      resolve();
-    }
-    function error(err) {
-      cleanup();
-      reject(err);
-    }
-    function cleanup() {
-      element.removeEventListener("canplaythrough", loaded);
-      element.removeEventListener("error", error);
-    }
-  });
-}
-function determineCrossOrigin(url, loc = globalThis.location) {
-  if (url.startsWith("data:")) {
-    return "";
-  }
-  loc || (loc = globalThis.location);
-  const parsedUrl = new URL(url, document.baseURI);
-  if (parsedUrl.hostname !== loc.hostname || parsedUrl.port !== loc.port || parsedUrl.protocol !== loc.protocol) {
-    return "anonymous";
-  }
-  return "";
-}
-function getBrowserSupportedVideoExtensions() {
-  const supportedExtensions = [];
-  const supportedMimes = [];
-  for (const ext of potentialVideoExtensions) {
-    const mimeType = VideoSource.MIME_TYPES[ext.substring(1)] || `video/${ext.substring(1)}`;
-    if (testVideoFormat(mimeType)) {
-      supportedExtensions.push(ext);
-      if (!supportedMimes.includes(mimeType)) {
-        supportedMimes.push(mimeType);
-      }
+      finalOptions = { ...options, ...options.canvasOptions };
+      break;
     }
   }
-  return {
-    validVideoExtensions: supportedExtensions,
-    validVideoMime: supportedMimes
-  };
-}
-var loadVideoTextures = {
-  name: "loadVideo",
-  id: "video",
-  extension: {
-    type: ExtensionType.LoadParser,
-    name: "loadVideo"
-  },
-  test(url) {
-    if (!validVideoExtensions || !validVideoMIMEs) {
-      const { validVideoExtensions: ve, validVideoMime: vm } = getBrowserSupportedVideoExtensions();
-      validVideoExtensions = ve;
-      validVideoMIMEs = vm;
-    }
-    const isValidDataUrl = checkDataUrl(url, validVideoMIMEs);
-    const isValidExtension = checkExtension(url, validVideoExtensions);
-    return isValidDataUrl || isValidExtension;
-  },
-  async load(url, asset, loader) {
-    const options = {
-      ...VideoSource.defaultOptions,
-      resolution: asset.data?.resolution || getResolutionOfUrl(url),
-      alphaMode: asset.data?.alphaMode || await detectVideoAlphaMode(),
-      ...asset.data
-    };
-    const videoElement = document.createElement("video");
-    const attributeMap = {
-      preload: options.autoLoad !== false ? "auto" : undefined,
-      "webkit-playsinline": options.playsinline !== false ? "" : undefined,
-      playsinline: options.playsinline !== false ? "" : undefined,
-      muted: options.muted === true ? "" : undefined,
-      loop: options.loop === true ? "" : undefined,
-      autoplay: options.autoPlay !== false ? "" : undefined
-    };
-    Object.keys(attributeMap).forEach((key) => {
-      const value = attributeMap[key];
-      if (value !== undefined)
-        videoElement.setAttribute(key, value);
-    });
-    if (options.muted === true) {
-      videoElement.muted = true;
-    }
-    crossOrigin(videoElement, url, options.crossorigin);
-    const sourceElement = document.createElement("source");
-    let mime;
-    if (options.mime) {
-      mime = options.mime;
-    } else if (url.startsWith("data:")) {
-      mime = url.slice(5, url.indexOf(";"));
-    } else if (!url.startsWith("blob:")) {
-      const ext = url.split("?")[0].slice(url.lastIndexOf(".") + 1).toLowerCase();
-      mime = VideoSource.MIME_TYPES[ext] || `video/${ext}`;
-    }
-    sourceElement.src = url;
-    if (mime) {
-      sourceElement.type = mime;
-    }
-    return new Promise((resolve, reject) => {
-      if (options.preload && !options.autoPlay) {
-        videoElement.load();
-      }
-      videoElement.addEventListener("canplay", onCanPlay);
-      videoElement.addEventListener("error", onError);
-      sourceElement.addEventListener("error", onError);
-      videoElement.appendChild(sourceElement);
-      async function onCanPlay() {
-        const base = new VideoSource({ ...options, resource: videoElement });
-        cleanup();
-        if (asset.data.preload) {
-          await preloadVideo(videoElement);
-        }
-        resolve(createTexture(base, loader, url));
-      }
-      function onError(event) {
-        cleanup();
-        reject(event);
-      }
-      function cleanup() {
-        videoElement.removeEventListener("canplay", onCanPlay);
-        videoElement.removeEventListener("error", onError);
-        sourceElement.removeEventListener("error", onError);
-      }
-    });
-  },
-  unload(texture) {
-    texture.destroy(true);
+  delete finalOptions.webgpu;
+  delete finalOptions.webgl;
+  delete finalOptions.canvasOptions;
+  if (!RendererClass) {
+    throw new Error("No available renderer for the current environment");
   }
-};
+  const renderer = new RendererClass;
+  await renderer.init(finalOptions);
+  return renderer;
+}
 
-// node_modules/pixi.js/lib/assets/resolver/parsers/resolveJsonUrl.mjs
-init_Extensions();
-init_Resolver();
+// node_modules/pixi.js/lib/app/Application.mjs
+init_Container();
+init_globalHooks();
+init_deprecation();
 
-// node_modules/pixi.js/lib/assets/resolver/parsers/resolveTextureUrl.mjs
+// node_modules/pixi.js/lib/app/init.mjs
 init_Extensions();
-init_Resolver();
-var resolveTextureUrl = {
-  extension: {
-    type: ExtensionType.ResolveParser,
-    name: "resolveTexture"
-  },
-  test: loadTextures.test,
-  parse: (value) => ({
-    resolution: parseFloat(Resolver.RETINA_PREFIX.exec(value)?.[1] ?? "1"),
-    format: value.split(".").pop(),
-    src: value
-  })
-};
-
-// node_modules/pixi.js/lib/assets/resolver/parsers/resolveJsonUrl.mjs
-var resolveJsonUrl = {
-  extension: {
-    type: ExtensionType.ResolveParser,
-    priority: -2,
-    name: "resolveJson"
-  },
-  test: (value) => Resolver.RETINA_PREFIX.test(value) && value.endsWith(".json"),
-  parse: resolveTextureUrl.parse
-};
 
-// node_modules/pixi.js/lib/assets/Assets.mjs
-init_Resolver();
-init_convertToList();
-init_isSingleItem();
+// node_modules/pixi.js/lib/app/ResizePlugin.mjs
+init_Extensions();
 
-class AssetsClass {
-  constructor() {
-    this._detections = [];
-    this._initialized = false;
-    this.resolver = new Resolver;
-    this.loader = new Loader;
-    this.cache = Cache;
-    this._backgroundLoader = new BackgroundLoader(this.loader);
-    this._backgroundLoader.active = true;
-    this.reset();
-  }
-  async init(options = {}) {
-    if (this._initialized) {
-      warn("[Assets]AssetManager already initialized, did you load before calling this Assets.init()?");
-      return;
-    }
-    this._initialized = true;
-    if (options.defaultSearchParams) {
-      this.resolver.setDefaultSearchParams(options.defaultSearchParams);
-    }
-    if (options.basePath) {
-      this.resolver.basePath = options.basePath;
-    }
-    if (options.bundleIdentifier) {
-      this.resolver.setBundleIdentifier(options.bundleIdentifier);
-    }
-    if (options.manifest) {
-      let manifest = options.manifest;
-      if (typeof manifest === "string") {
-        manifest = await this.load(manifest);
+class ResizePlugin {
+  static init(options) {
+    Object.defineProperty(this, "resizeTo", {
+      configurable: true,
+      set(dom) {
+        globalThis.removeEventListener("resize", this.queueResize);
+        this._resizeTo = dom;
+        if (dom) {
+          globalThis.addEventListener("resize", this.queueResize);
+          this.resize();
+        }
+      },
+      get() {
+        return this._resizeTo;
       }
-      this.resolver.addManifest(manifest);
-    }
-    const resolutionPref = options.texturePreference?.resolution ?? 1;
-    const resolution = typeof resolutionPref === "number" ? [resolutionPref] : resolutionPref;
-    const formats = await this._detectFormats({
-      preferredFormats: options.texturePreference?.format,
-      skipDetections: options.skipDetections,
-      detections: this._detections
     });
-    this.resolver.prefer({
-      params: {
-        format: formats,
-        resolution
+    this.queueResize = () => {
+      if (!this._resizeTo) {
+        return;
       }
-    });
-    if (options.preferences) {
-      this.setPreferences(options.preferences);
-    }
-    if (options.loadOptions) {
-      this.loader.loadOptions = {
-        ...this.loader.loadOptions,
-        ...options.loadOptions
-      };
-    }
+      this._cancelResize();
+      this._resizeId = requestAnimationFrame(() => this.resize());
+    };
+    this._cancelResize = () => {
+      if (this._resizeId) {
+        cancelAnimationFrame(this._resizeId);
+        this._resizeId = null;
+      }
+    };
+    this.resize = () => {
+      if (!this._resizeTo) {
+        return;
+      }
+      this._cancelResize();
+      let width;
+      let height;
+      if (this._resizeTo === globalThis.window) {
+        width = globalThis.innerWidth;
+        height = globalThis.innerHeight;
+      } else {
+        const { clientWidth, clientHeight } = this._resizeTo;
+        width = clientWidth;
+        height = clientHeight;
+      }
+      this.renderer.resize(width, height);
+      this.render();
+    };
+    this._resizeId = null;
+    this._resizeTo = null;
+    this.resizeTo = options.resizeTo || null;
   }
-  add(assets) {
-    this.resolver.add(assets);
+  static destroy() {
+    globalThis.removeEventListener("resize", this.queueResize);
+    this._cancelResize();
+    this._cancelResize = null;
+    this.queueResize = null;
+    this.resizeTo = null;
+    this.resize = null;
   }
-  async load(urls, onProgress) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    const singleAsset = isSingleItem(urls);
-    const urlArray = convertToList(urls).map((url) => {
-      if (typeof url !== "string") {
-        const aliases = this.resolver.getAlias(url);
-        if (aliases.some((alias) => !this.resolver.hasKey(alias))) {
-          this.add(url);
+}
+ResizePlugin.extension = ExtensionType.Application;
+
+// node_modules/pixi.js/lib/app/TickerPlugin.mjs
+init_Extensions();
+init_const2();
+init_Ticker();
+
+class TickerPlugin {
+  static init(options) {
+    options = Object.assign({
+      autoStart: true,
+      sharedTicker: false
+    }, options);
+    Object.defineProperty(this, "ticker", {
+      configurable: true,
+      set(ticker) {
+        if (this._ticker) {
+          this._ticker.remove(this.render, this);
+        }
+        this._ticker = ticker;
+        if (ticker) {
+          ticker.add(this.render, this, UPDATE_PRIORITY.LOW);
         }
-        return Array.isArray(aliases) ? aliases[0] : aliases;
+      },
+      get() {
+        return this._ticker;
       }
-      if (!this.resolver.hasKey(url))
-        this.add({ alias: url, src: url });
-      return url;
     });
-    const resolveResults = this.resolver.resolve(urlArray);
-    const out2 = await this._mapLoadToResolve(resolveResults, onProgress);
-    return singleAsset ? out2[urlArray[0]] : out2;
-  }
-  addBundle(bundleId, assets) {
-    this.resolver.addBundle(bundleId, assets);
-  }
-  async loadBundle(bundleIds, onProgress) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    let singleAsset = false;
-    if (typeof bundleIds === "string") {
-      singleAsset = true;
-      bundleIds = [bundleIds];
-    }
-    const resolveResults = this.resolver.resolveBundle(bundleIds);
-    const out2 = {};
-    const keys = Object.keys(resolveResults);
-    let total = 0;
-    const counts = [];
-    const _onProgress = () => {
-      onProgress?.(counts.reduce((a2, b2) => a2 + b2, 0) / total);
+    this.stop = () => {
+      this._ticker.stop();
     };
-    const promises = keys.map((bundleId, i2) => {
-      const resolveResult = resolveResults[bundleId];
-      const values = Object.values(resolveResult);
-      const totalAssetsToLoad = [...new Set(values.flat())];
-      const progressSize = totalAssetsToLoad.reduce((sum, asset) => sum + (asset.progressSize || 1), 0);
-      counts.push(0);
-      total += progressSize;
-      return this._mapLoadToResolve(resolveResult, (e2) => {
-        counts[i2] = e2 * progressSize;
-        _onProgress();
-      }).then((resolveResult2) => {
-        out2[bundleId] = resolveResult2;
-      });
-    });
-    await Promise.all(promises);
-    return singleAsset ? out2[bundleIds[0]] : out2;
-  }
-  async backgroundLoad(urls) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    if (typeof urls === "string") {
-      urls = [urls];
+    this.start = () => {
+      this._ticker.start();
+    };
+    this._ticker = null;
+    this.ticker = options.sharedTicker ? Ticker.shared : new Ticker;
+    if (options.autoStart) {
+      this.start();
     }
-    const resolveResults = this.resolver.resolve(urls);
-    this._backgroundLoader.add(Object.values(resolveResults));
   }
-  async backgroundLoadBundle(bundleIds) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    if (typeof bundleIds === "string") {
-      bundleIds = [bundleIds];
+  static destroy() {
+    if (this._ticker) {
+      const oldTicker = this._ticker;
+      this.ticker = null;
+      oldTicker.destroy();
     }
-    const resolveResults = this.resolver.resolveBundle(bundleIds);
-    Object.values(resolveResults).forEach((resolveResult) => {
-      this._backgroundLoader.add(Object.values(resolveResult));
-    });
-  }
-  reset() {
-    this.resolver.reset();
-    this.loader.reset();
-    this.cache.reset();
-    this._initialized = false;
   }
-  get(keys) {
-    if (typeof keys === "string") {
-      return Cache.get(keys);
+}
+TickerPlugin.extension = ExtensionType.Application;
+
+// node_modules/pixi.js/lib/app/init.mjs
+extensions.add(ResizePlugin);
+extensions.add(TickerPlugin);
+
+// node_modules/pixi.js/lib/app/Application.mjs
+var _Application = class _Application2 {
+  constructor(...args) {
+    this.stage = new Container;
+    if (args[0] !== undefined) {
+      deprecation(v8_0_0, "Application constructor options are deprecated, please use Application.init() instead.");
     }
-    const assets = {};
-    for (let i2 = 0;i2 < keys.length; i2++) {
-      assets[i2] = Cache.get(keys[i2]);
-    }
-    return assets;
-  }
-  async _mapLoadToResolve(resolveResults, progressOrLoadOptions) {
-    const resolveArray = [...new Set(Object.values(resolveResults))];
-    this._backgroundLoader.active = false;
-    const loadedAssets = await this.loader.load(resolveArray, progressOrLoadOptions);
-    this._backgroundLoader.active = true;
-    const out2 = {};
-    resolveArray.forEach((resolveResult) => {
-      const asset = loadedAssets[resolveResult.src];
-      const keys = [resolveResult.src];
-      if (resolveResult.alias) {
-        keys.push(...resolveResult.alias);
-      }
-      keys.forEach((key) => {
-        out2[key] = asset;
-      });
-      Cache.set(keys, asset);
+  }
+  async init(options) {
+    options = { ...options };
+    this.stage || (this.stage = new Container);
+    this.renderer = await autoDetectRenderer(options);
+    _Application2._plugins.forEach((plugin) => {
+      plugin.init.call(this, options);
     });
-    return out2;
   }
-  async unload(urls) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    const urlArray = convertToList(urls).map((url) => typeof url !== "string" ? url.src : url);
-    const resolveResults = this.resolver.resolve(urlArray);
-    await this._unloadFromResolved(resolveResults);
+  render() {
+    this.renderer.render({ container: this.stage });
   }
-  async unloadBundle(bundleIds) {
-    if (!this._initialized) {
-      await this.init();
-    }
-    bundleIds = convertToList(bundleIds);
-    const resolveResults = this.resolver.resolveBundle(bundleIds);
-    const promises = Object.keys(resolveResults).map((bundleId) => this._unloadFromResolved(resolveResults[bundleId]));
-    await Promise.all(promises);
-  }
-  async _unloadFromResolved(resolveResult) {
-    const resolveArray = Object.values(resolveResult);
-    resolveArray.forEach((resolveResult2) => {
-      Cache.remove(resolveResult2.src);
-    });
-    await this.loader.unload(resolveArray);
+  get canvas() {
+    return this.renderer.canvas;
   }
-  async _detectFormats(options) {
-    let formats = [];
-    if (options.preferredFormats) {
-      formats = Array.isArray(options.preferredFormats) ? options.preferredFormats : [options.preferredFormats];
-    }
-    for (const detection of options.detections) {
-      if (options.skipDetections || await detection.test()) {
-        formats = await detection.add(formats);
-      } else if (!options.skipDetections) {
-        formats = await detection.remove(formats);
-      }
-    }
-    formats = formats.filter((format, index) => formats.indexOf(format) === index);
-    return formats;
+  get view() {
+    deprecation(v8_0_0, "Application.view is deprecated, please use Application.canvas instead.");
+    return this.renderer.canvas;
   }
-  get detections() {
-    return this._detections;
+  get screen() {
+    return this.renderer.screen;
   }
-  setPreferences(preferences) {
-    this.loader.parsers.forEach((parser) => {
-      if (!parser.config)
-        return;
-      Object.keys(parser.config).filter((key) => (key in preferences)).forEach((key) => {
-        parser.config[key] = preferences[key];
-      });
+  destroy(rendererDestroyOptions = false, options = false) {
+    const plugins = _Application2._plugins.slice(0);
+    plugins.reverse();
+    plugins.forEach((plugin) => {
+      plugin.destroy.call(this);
     });
+    this.stage.destroy(options);
+    this.stage = null;
+    this.renderer.destroy(rendererDestroyOptions);
+    this.renderer = null;
   }
-}
-var Assets = new AssetsClass;
-extensions.handleByList(ExtensionType.LoadParser, Assets.loader.parsers).handleByList(ExtensionType.ResolveParser, Assets.resolver.parsers).handleByList(ExtensionType.CacheParser, Assets.cache.parsers).handleByList(ExtensionType.DetectionParser, Assets.detections);
-extensions.add(cacheTextureArray, detectDefaults, detectAvif, detectWebp, detectMp4, detectOgv, detectWebm, loadJson, loadTxt, loadWebFont, loadSvg, loadTextures, loadVideoTextures, loadBitmapFont, bitmapFontCachePlugin, resolveTextureUrl, resolveJsonUrl);
-var assetKeyMap = {
-  loader: ExtensionType.LoadParser,
-  resolver: ExtensionType.ResolveParser,
-  cache: ExtensionType.CacheParser,
-  detection: ExtensionType.DetectionParser
 };
-extensions.handle(ExtensionType.Asset, (extension) => {
-  const ref = extension.ref;
-  Object.entries(assetKeyMap).filter(([key]) => !!ref[key]).forEach(([key, type]) => extensions.add(Object.assign(ref[key], { extension: ref[key].extension ?? type })));
-}, (extension) => {
-  const ref = extension.ref;
-  Object.keys(assetKeyMap).filter((key) => !!ref[key]).forEach((key) => extensions.remove(ref[key]));
-});
+_Application._plugins = [];
+var Application = _Application;
+extensions.handleByList(ExtensionType.Application, Application._plugins);
+extensions.add(ApplicationInitHook);
 
 // node_modules/pixi.js/lib/scene/text/Text.mjs
 init_TextureStyle();
@@ -33038,6 +30708,7 @@ class Text extends AbstractText {
 // node_modules/pixi.js/lib/index.mjs
 init_Point();
 init_Rectangle();
+init_ImageSource();
 init_Texture();
 init_textureFrom();
 init_Container();
@@ -33588,14 +31259,18 @@ class ImageElement extends BaseElement {
     this.y = y2;
     this.loadTexture(src);
   }
-  async loadTexture(src) {
-    try {
-      const texture = await Assets.load(src);
+  loadTexture(src) {
+    const img = new Image;
+    img.onload = () => {
+      const texture = new Texture({ source: new ImageSource({ resource: img }) });
       this.sprite.texture = texture;
       this._loaded = true;
-    } catch (err) {
-      console.warn(`Failed to load image: ${src}`, err);
-    }
+      this.emitChange("loaded", false, true);
+    };
+    img.onerror = () => {
+      console.warn(`Failed to load image: ${src}`);
+    };
+    img.src = src;
   }
   get src() {
     return this._src;
@@ -33606,8 +31281,8 @@ class ImageElement extends BaseElement {
       return;
     this._src = value;
     this._loaded = false;
-    this.loadTexture(value);
     this.emitChange("src", old, value);
+    this.loadTexture(value);
   }
   get loaded() {
     return this._loaded;
@@ -33723,6 +31398,7 @@ class ShapeElement extends BaseElement {
   _fillPercentage;
   _fillDirection;
   _strokeWidth;
+  _lineCap;
   _shapeParams;
   constructor(shapeType, params, options) {
     super("shape");
@@ -33733,6 +31409,7 @@ class ShapeElement extends BaseElement {
     this._fillPercentage = options?.fillPercentage ?? 100;
     this._fillDirection = options?.fillDirection ?? "left-to-right";
     this._strokeWidth = options?.strokeWidth ?? 2;
+    this._lineCap = options?.lineCap ?? "butt";
     this.bgGraphics = new Graphics;
     this.fgGraphics = new Graphics;
     this.fillMask = new FillMask;
@@ -33832,6 +31509,17 @@ class ShapeElement extends BaseElement {
     this.redraw();
     this.emitChange("strokeWidth", old, value);
   }
+  get lineCap() {
+    return this._lineCap;
+  }
+  set lineCap(value) {
+    const old = this._lineCap;
+    if (old === value)
+      return;
+    this._lineCap = value;
+    this.redraw();
+    this.emitChange("lineCap", old, value);
+  }
   get width() {
     return this.getLocalBounds().width;
   }
@@ -33884,7 +31572,7 @@ class ShapeElement extends BaseElement {
     switch (this._shapeType) {
       case "circle": {
         const r2 = this._shapeParams["radius"];
-        return { x: 0, y: 0, width: r2 * 2, height: r2 * 2 };
+        return { x: -r2, y: -r2, width: r2 * 2, height: r2 * 2 };
       }
       case "rectangle":
         return { x: 0, y: 0, width: this._shapeParams["w"], height: this._shapeParams["h"] };
@@ -33893,13 +31581,15 @@ class ShapeElement extends BaseElement {
         const ly1 = this._shapeParams["ly1"];
         const lx2 = this._shapeParams["lx2"];
         const ly2 = this._shapeParams["ly2"];
+        const half = this._strokeWidth / 2;
         const w2 = Math.abs(lx2 - lx1) || 1;
         const h2 = Math.abs(ly2 - ly1) || 1;
-        return { x: 0, y: 0, width: w2, height: h2 };
+        return { x: -half, y: -half, width: w2 + this._strokeWidth, height: h2 + this._strokeWidth };
       }
       case "arc": {
         const r2 = this._shapeParams["radius"];
-        return { x: 0, y: 0, width: r2 * 2, height: r2 * 2 };
+        const half = this._strokeWidth / 2;
+        return { x: -r2 - half, y: -r2 - half, width: (r2 + half) * 2, height: (r2 + half) * 2 };
       }
     }
   }
@@ -33917,12 +31607,12 @@ class ShapeElement extends BaseElement {
         const ly1 = this._shapeParams["ly1"];
         const lx2 = this._shapeParams["lx2"];
         const ly2 = this._shapeParams["ly2"];
-        g2.moveTo(lx1, ly1).lineTo(lx2, ly2).stroke({ color, width: this._strokeWidth });
+        g2.moveTo(lx1, ly1).lineTo(lx2, ly2).stroke({ color, width: this._strokeWidth, cap: this._lineCap });
         break;
       }
       case "circle": {
         const r2 = this._shapeParams["radius"];
-        g2.circle(r2, r2, r2).fill({ color });
+        g2.circle(0, 0, r2).fill({ color });
         break;
       }
       case "rectangle": {
@@ -33935,7 +31625,7 @@ class ShapeElement extends BaseElement {
         const r2 = this._shapeParams["radius"];
         const start = this._shapeParams["startAngle"];
         const end = this._shapeParams["endAngle"];
-        g2.arc(r2, r2, r2, start, end).stroke({ color, width: this._strokeWidth });
+        g2.arc(0, 0, r2, start, end).stroke({ color, width: this._strokeWidth, cap: this._lineCap });
         break;
       }
     }
@@ -33953,7 +31643,8 @@ class ShapeElement extends BaseElement {
       backgroundColor: this._backgroundColor,
       fillPercentage: this._fillPercentage,
       fillDirection: this._fillDirection,
-      strokeWidth: this._strokeWidth
+      strokeWidth: this._strokeWidth,
+      lineCap: this._lineCap
     };
   }
   applyJSON(data) {
@@ -33967,6 +31658,8 @@ class ShapeElement extends BaseElement {
       this.fillDirection = data.fillDirection;
     if (data.strokeWidth !== undefined)
       this.strokeWidth = data.strokeWidth;
+    if (data.lineCap !== undefined)
+      this.lineCap = data.lineCap;
     this.x = data.x;
     this.y = data.y;
     this.rotation = data.rotation;
@@ -33982,7 +31675,8 @@ class ShapeElement extends BaseElement {
       backgroundColor: data.backgroundColor,
       fillPercentage: data.fillPercentage,
       fillDirection: data.fillDirection,
-      strokeWidth: data.strokeWidth
+      strokeWidth: data.strokeWidth,
+      lineCap: data.lineCap
     });
     el.x = data.x;
     el.y = data.y;
@@ -34200,33 +31894,44 @@ class MarqueeSelect {
 // src/selection/TransformController.ts
 class TransformController {
   eventBus;
+  contentRoot = null;
   dragState = null;
   activeElements = [];
   constructor(eventBus) {
     this.eventBus = eventBus;
   }
+  setContentRoot(root) {
+    this.contentRoot = root;
+  }
   get isDragging() {
     return this.dragState !== null;
   }
   get currentMode() {
     return this.dragState?.mode ?? "none";
   }
+  toWorld(event) {
+    if (this.contentRoot) {
+      return this.contentRoot.toLocal({ x: event.globalX, y: event.globalY });
+    }
+    return { x: event.globalX, y: event.globalY };
+  }
   startMove(elements, event) {
     this.activeElements = elements;
     const startProps = new Map;
     for (const el of elements) {
       startProps.set(el.id, { x: el.x, y: el.y, width: el.width, height: el.height, rotation: el.rotation });
     }
+    const world = this.toWorld(event);
     this.dragState = {
       mode: "move",
-      startX: event.globalX,
-      startY: event.globalY,
+      startX: world.x,
+      startY: world.y,
       elementStartProps: startProps
     };
     if (elements.length > 0) {
       this.eventBus.emit("interaction:dragStart", {
         element: elements[0],
-        position: { x: event.globalX, y: event.globalY }
+        position: { x: world.x, y: world.y }
       });
     }
   }
@@ -34236,10 +31941,11 @@ class TransformController {
     for (const el of elements) {
       startProps.set(el.id, { x: el.x, y: el.y, width: el.width, height: el.height, rotation: el.rotation });
     }
+    const world = this.toWorld(event);
     this.dragState = {
       mode: "resize",
-      startX: event.globalX,
-      startY: event.globalY,
+      startX: world.x,
+      startY: world.y,
       handlePosition,
       elementStartProps: startProps
     };
@@ -34253,10 +31959,11 @@ class TransformController {
     for (const el of elements) {
       startProps.set(el.id, { x: el.x, y: el.y, width: el.width, height: el.height, rotation: el.rotation });
     }
+    const world = this.toWorld(event);
     this.dragState = {
       mode: "rotate",
-      startX: event.globalX,
-      startY: event.globalY,
+      startX: world.x,
+      startY: world.y,
       elementStartProps: startProps
     };
     if (elements.length > 0) {
@@ -34308,8 +32015,9 @@ class TransformController {
   handleMove(event) {
     if (!this.dragState)
       return;
-    const dx = event.globalX - this.dragState.startX;
-    const dy = event.globalY - this.dragState.startY;
+    const world = this.toWorld(event);
+    const dx = world.x - this.dragState.startX;
+    const dy = world.y - this.dragState.startY;
     for (const el of this.activeElements) {
       const start = this.dragState.elementStartProps.get(el.id);
       if (start) {
@@ -34326,13 +32034,16 @@ class TransformController {
   handleResize(event) {
     if (!this.dragState || !this.dragState.handlePosition)
       return;
-    const dx = event.globalX - this.dragState.startX;
-    const dy = event.globalY - this.dragState.startY;
+    const world = this.toWorld(event);
+    const dx = world.x - this.dragState.startX;
+    const dy = world.y - this.dragState.startY;
     const handle = this.dragState.handlePosition;
+    const constrain = event.shiftKey;
     for (const el of this.activeElements) {
       const start = this.dragState.elementStartProps.get(el.id);
       if (!start)
         continue;
+      const aspect = start.height === 0 ? 1 : start.width / start.height;
       let newX = start.x;
       let newY = start.y;
       let newW = start.width;
@@ -34351,13 +32062,41 @@ class TransformController {
       if (handle.includes("bottom")) {
         newH = start.height + dy;
       }
+      if (constrain && start.width > 0 && start.height > 0) {
+        const isCorner = (handle.includes("left") || handle.includes("right")) && (handle.includes("top") || handle.includes("bottom"));
+        if (isCorner) {
+          const absDx = Math.abs(newW - start.width);
+          const absDy = Math.abs(newH - start.height);
+          if (absDx / aspect >= absDy) {
+            newH = newW / aspect;
+            if (handle.includes("top"))
+              newY = start.y + start.height - newH;
+          } else {
+            newW = newH * aspect;
+            if (handle.includes("left"))
+              newX = start.x + start.width - newW;
+          }
+        } else {
+          if (handle === "middle-left" || handle === "middle-right") {
+            const centerY = start.y + start.height / 2;
+            newH = newW / aspect;
+            newY = centerY - newH / 2;
+          } else {
+            const centerX = start.x + start.width / 2;
+            newW = newH * aspect;
+            newX = centerX - newW / 2;
+          }
+        }
+      }
       if (newW < 5) {
         newW = 5;
-        newX = start.x + start.width - 5;
+        if (handle.includes("left"))
+          newX = start.x + start.width - 5;
       }
       if (newH < 5) {
         newH = 5;
-        newY = start.y + start.height - 5;
+        if (handle.includes("top"))
+          newY = start.y + start.height - 5;
       }
       el.x = newX;
       el.y = newY;
@@ -34368,13 +32107,14 @@ class TransformController {
   handleRotate(event) {
     if (!this.dragState)
       return;
+    const world = this.toWorld(event);
     for (const el of this.activeElements) {
       const start = this.dragState.elementStartProps.get(el.id);
       if (!start)
         continue;
       const cx = el.x + el.width / 2;
       const cy = el.y + el.height / 2;
-      const angle = angleBetweenPoints(cx, cy, event.globalX, event.globalY);
+      const angle = angleBetweenPoints(cx, cy, world.x, world.y);
       const startAngle = angleBetweenPoints(cx, cy, this.dragState.startX, this.dragState.startY);
       el.rotation = start.rotation + (angle - startAngle);
     }
@@ -34392,6 +32132,7 @@ class SelectionManager {
   transformController;
   clipboard = [];
   layer = null;
+  contentRoot = null;
   handleConfig = { color: 35071, fillColor: 16777215, size: 8 };
   isMarqueeActive = false;
   marqueeStart = { x: 0, y: 0 };
@@ -34409,11 +32150,15 @@ class SelectionManager {
   setSerializationManager(sm) {
     this.serializationManager = sm;
   }
-  init(layer, app, config) {
+  init(layer, app, config, contentRoot) {
     this.layer = layer;
     if (config) {
       this.handleConfig = { ...this.handleConfig, ...config };
     }
+    if (contentRoot) {
+      this.contentRoot = contentRoot;
+      this.transformController.setContentRoot(contentRoot);
+    }
     this.layer.addChild(this.selectionBox.container);
     this.layer.addChild(this.marquee.graphics);
     this.wireHandleEvents();
@@ -34428,6 +32173,11 @@ class SelectionManager {
       this.selected.delete(element);
       this.updateSelectionVisuals();
     });
+    this.eventBus.on("element:changed", ({ element }) => {
+      if (this.selected.has(element)) {
+        this.updateSelectionVisuals();
+      }
+    });
   }
   handleElementPointerDown(element, event) {
     if (!element.interactable)
@@ -34464,6 +32214,9 @@ class SelectionManager {
     this.clearSelection();
     this.addToSelection(element);
   }
+  selectOnly(element) {
+    this.select(element);
+  }
   addToSelection(element) {
     this.selected.add(element);
     this.updateSelectionVisuals();
@@ -34474,6 +32227,9 @@ class SelectionManager {
     this.updateSelectionVisuals();
     this.eventBus.emit("selection:changed", { selected: this.getSelected() });
   }
+  deselectAll() {
+    this.clearSelection();
+  }
   clearSelection() {
     if (this.selected.size === 0)
       return;
@@ -34538,12 +32294,13 @@ class SelectionManager {
   computeCombinedBounds(elements) {
     let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
     for (const el of elements) {
-      const display = el.getDisplayObject();
-      const b2 = display.getBounds();
-      minX = Math.min(minX, b2.x);
-      minY = Math.min(minY, b2.y);
-      maxX = Math.max(maxX, b2.x + b2.width);
-      maxY = Math.max(maxY, b2.y + b2.height);
+      const b2 = el.getDisplayObject().getLocalBounds();
+      const wx = el.x + b2.x;
+      const wy = el.y + b2.y;
+      minX = Math.min(minX, wx);
+      minY = Math.min(minY, wy);
+      maxX = Math.max(maxX, wx + b2.width);
+      maxY = Math.max(maxY, wy + b2.height);
     }
     return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
   }
@@ -34560,14 +32317,19 @@ class SelectionManager {
       });
     }
   }
+  toWorld(globalX, globalY) {
+    if (this.contentRoot) {
+      return this.contentRoot.toLocal({ x: globalX, y: globalY });
+    }
+    return { x: globalX, y: globalY };
+  }
   onStagePointerDown(event) {
-    if (event.target === event.currentTarget) {
-      if (!event.shiftKey) {
-        this.clearSelection();
-      }
-      this.isMarqueeActive = true;
-      this.marqueeStart = { x: event.globalX, y: event.globalY };
+    if (!event.shiftKey) {
+      this.clearSelection();
     }
+    this.isMarqueeActive = true;
+    const world = this.toWorld(event.globalX, event.globalY);
+    this.marqueeStart = { x: world.x, y: world.y };
   }
   onStagePointerMove(event) {
     if (this.transformController.isDragging && !this.isDraggingElement) {
@@ -34576,7 +32338,8 @@ class SelectionManager {
       return;
     }
     if (this.isMarqueeActive) {
-      this.marquee.draw(this.marqueeStart.x, this.marqueeStart.y, event.globalX, event.globalY);
+      const world = this.toWorld(event.globalX, event.globalY);
+      this.marquee.draw(this.marqueeStart.x, this.marqueeStart.y, world.x, world.y);
     }
   }
   onStagePointerUp(event) {
@@ -34586,14 +32349,21 @@ class SelectionManager {
     }
     if (this.isMarqueeActive) {
       this.isMarqueeActive = false;
-      const rect = this.marquee.getRect(this.marqueeStart.x, this.marqueeStart.y, event.globalX, event.globalY);
+      const world = this.toWorld(event.globalX, event.globalY);
+      const rect = this.marquee.getRect(this.marqueeStart.x, this.marqueeStart.y, world.x, world.y);
       this.marquee.clear();
       if (rect.width > 3 || rect.height > 3) {
         for (const el of this.elementManager.getAll()) {
           if (!el.interactable)
             continue;
-          const b2 = el.getDisplayObject().getBounds();
-          if (this.boundsOverlap(rect, { x: b2.x, y: b2.y, width: b2.width, height: b2.height })) {
+          const lb = el.getDisplayObject().getLocalBounds();
+          const elBounds = {
+            x: el.x + lb.x,
+            y: el.y + lb.y,
+            width: lb.width,
+            height: lb.height
+          };
+          if (this.boundsOverlap(rect, elBounds)) {
             this.selected.add(el);
           }
         }
@@ -34726,7 +32496,7 @@ class WatchfaceEngine {
       handleConfig.fillColor = options.selectionHandleFillColor;
     if (options.selectionHandleSize !== undefined)
       handleConfig.size = options.selectionHandleSize;
-    this.selection.init(this.selectionLayer, this.app, handleConfig);
+    this.selection.init(this.selectionLayer, this.app, handleConfig, this._contentRoot);
     this._initialized = true;
     this.eventBus.emit("engine:ready");
   }
@@ -34811,9 +32581,12 @@ class GridPlugin {
     this.gridGraphics = new Graphics;
     this.gridGraphics.alpha = this.options.opacity;
     this.gridGraphics.visible = this.options.visible;
-    engine.getBackgroundLayer().addChild(this.gridGraphics);
+    engine.app.stage.addChild(this.gridGraphics);
     this.drawGrid();
-    const unsub = engine.eventBus.on("interaction:dragMove", ({ elements }) => {
+    const unsubZoom = engine.eventBus.on("viewport:zoomed", () => this.drawGrid());
+    const unsubMove = engine.eventBus.on("viewport:moved", () => this.drawGrid());
+    this.unsubscribers.push(unsubZoom, unsubMove);
+    const unsubDrag = engine.eventBus.on("interaction:dragMove", ({ elements }) => {
       if (!this.options.snapEnabled)
         return;
       for (const el of elements) {
@@ -34821,7 +32594,7 @@ class GridPlugin {
         el.y = this.snapValue(el.y);
       }
     });
-    this.unsubscribers.push(unsub);
+    this.unsubscribers.push(unsubDrag);
   }
   snapValue(value) {
     return Math.round(value / this.options.cellSize) * this.options.cellSize;
@@ -34831,17 +32604,26 @@ class GridPlugin {
     const { width, height } = this.engine.options;
     const { x: ox, y: oy } = this.engine.originOffset;
     const { cellSize, color } = this.options;
-    const left = -ox;
-    const top = -oy;
-    const right = width - ox;
-    const bottom = height - oy;
-    const startX = Math.ceil(left / cellSize) * cellSize;
-    const startY = Math.ceil(top / cellSize) * cellSize;
-    for (let x2 = startX;x2 <= right; x2 += cellSize) {
-      this.gridGraphics.moveTo(x2, top).lineTo(x2, bottom).stroke({ color, width: 0.5 });
-    }
-    for (let y2 = startY;y2 <= bottom; y2 += cellSize) {
-      this.gridGraphics.moveTo(left, y2).lineTo(right, y2).stroke({ color, width: 0.5 });
+    const viewportPlugin = this.engine.plugins.get("viewport");
+    const viewport = viewportPlugin?.viewport;
+    let scale = 1;
+    let panX = 0;
+    let panY = 0;
+    if (viewport) {
+      scale = viewport.scale.x;
+      panX = viewport.x;
+      panY = viewport.y;
+    }
+    const originScreenX = panX + ox * scale;
+    const originScreenY = panY + oy * scale;
+    const screenCell = cellSize * scale;
+    const startX = originScreenX - Math.ceil(originScreenX / screenCell) * screenCell;
+    const startY = originScreenY - Math.ceil(originScreenY / screenCell) * screenCell;
+    for (let sx = startX;sx <= width; sx += screenCell) {
+      this.gridGraphics.moveTo(sx, 0).lineTo(sx, height).stroke({ color, width: 0.5 });
+    }
+    for (let sy = startY;sy <= height; sy += screenCell) {
+      this.gridGraphics.moveTo(0, sy).lineTo(width, sy).stroke({ color, width: 0.5 });
     }
   }
   destroy() {