@drincs/pixi-vn 0.9.7 → 0.9.9

package/dist/{ContainerChild-B5yD0BI8.d.ts → ContainerChild-AjuVp3wW.d.ts}

@@ -200,6 +200,7 @@ declare class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory = Sprit
 declare function getMemorySprite<T extends Sprite<any>>(element: T | Sprite<any>): SpriteMemory;
 declare function setMemorySprite<Memory extends SpriteBaseMemory>(element: Sprite<any>, memory: Memory | {}, options?: {
     half?: () => Promise<void>;
+    ignoreTexture?: boolean;
 }): Promise<void>;
 
 /**
@@ -264,7 +265,9 @@ declare class ImageSprite<Memory extends ImageSpriteMemory = ImageSpriteMemory>
     get y(): number;
     set y(value: number);
 }
-declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}): Promise<void>;
+declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}, options?: {
+    ignoreTexture?: boolean;
+}): Promise<void>;
 
 type ContainerChild = Container & CanvasBaseItem<any>;
 

package/dist/{ContainerChild-WzyxEjAc.d.cts → ContainerChild-BUFxM6Ya.d.cts}

@@ -200,6 +200,7 @@ declare class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory = Sprit
 declare function getMemorySprite<T extends Sprite<any>>(element: T | Sprite<any>): SpriteMemory;
 declare function setMemorySprite<Memory extends SpriteBaseMemory>(element: Sprite<any>, memory: Memory | {}, options?: {
     half?: () => Promise<void>;
+    ignoreTexture?: boolean;
 }): Promise<void>;
 
 /**
@@ -264,7 +265,9 @@ declare class ImageSprite<Memory extends ImageSpriteMemory = ImageSpriteMemory>
     get y(): number;
     set y(value: number);
 }
-declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}): Promise<void>;
+declare function setMemoryImageSprite(element: ImageSprite, memory: ImageSpriteMemory | {}, options?: {
+    ignoreTexture?: boolean;
+}): Promise<void>;
 
 type ContainerChild = Container & CanvasBaseItem<any>;
 

package/dist/WebGLRenderer-CWVLYTYY.js

@@ -0,0 +1,9 @@
+import {
+  WebGLRenderer
+} from "./chunk-UWBWDBB3.js";
+import "./chunk-BJGKFUMU.js";
+import "./chunk-KAHX5SKO.js";
+import "./chunk-N342G4HO.js";
+export {
+  WebGLRenderer
+};

package/dist/WebGPURenderer-46NKQGBG.js

@@ -0,0 +1,10 @@
+import {
+  WebGPURenderer
+} from "./chunk-F74VVSHO.js";
+import "./chunk-XGGTEP7V.js";
+import "./chunk-BJGKFUMU.js";
+import "./chunk-KAHX5SKO.js";
+import "./chunk-N342G4HO.js";
+export {
+  WebGPURenderer
+};

package/dist/{browserAll-2HD5EH7K.js → browserAll-S4EPEXZD.js}

@@ -1,16 +1,16 @@
-import "./chunk-Y3WNBACN.js";
+import "./chunk-R4J2U4HN.js";
 import {
   AccessibilitySystem,
   EventSystem,
   FederatedContainer,
   accessibilityTarget
-} from "./chunk-SAUNZQHZ.js";
-import "./chunk-CAWOWL3P.js";
-import "./chunk-5JREOVCG.js";
+} from "./chunk-D753T42C.js";
+import "./chunk-IG7HSAEJ.js";
+import "./chunk-XGGTEP7V.js";
 import {
   Container,
   extensions
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 import "./chunk-N342G4HO.js";
 
 // node_modules/pixi.js/lib/accessibility/init.mjs

package/dist/{chunk-PP5T5HEO.js → chunk-52ZSR3AN.js}

@@ -1,6 +1,6 @@
 import {
   filters_exports
-} from "./chunk-WS3FY4Q6.js";
+} from "./chunk-X55ALTH7.js";
 
 // src/functions/sound-utility.ts
 function FilterMemoryToFilter(filter) {

package/dist/{chunk-5VX2VTDZ.js → chunk-BJGKFUMU.js}

@@ -42,7 +42,7 @@ import {
   uid,
   v8_0_0,
   warn
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // node_modules/pixi.js/lib/filters/Filter.mjs
 var _Filter = class _Filter2 extends Shader {
@@ -779,7 +779,7 @@ function collectAllRenderablesSimple(container, instructionSet, renderer) {
     renderPipes.blendMode.setBlendMode(renderable, container.groupBlendMode, instructionSet);
     const rp = renderPipes;
     rp[renderable.renderPipeId].addRenderable(renderable, instructionSet);
-    renderableGC.addRenderable(renderable, instructionSet);
+    renderableGC.addRenderable(renderable);
     renderable.didViewUpdate = false;
   }
   if (!container.renderGroup) {
@@ -806,7 +806,7 @@ function collectAllRenderablesAdvanced(container, instructionSet, renderer, isRo
       renderPipes.blendMode.setBlendMode(renderable, renderable.groupBlendMode, instructionSet);
       const pipe = renderPipes[renderPipeId];
       pipe.addRenderable(renderable, instructionSet);
-      renderableGC.addRenderable(renderable, instructionSet);
+      renderableGC.addRenderable(renderable);
       renderable.didViewUpdate = false;
     }
     const children = container.children;
@@ -1152,7 +1152,7 @@ SpritePipe.extension = {
 
 // node_modules/pixi.js/lib/utils/const.mjs
 var DATA_URI = /^\s*data:(?:([\w-]+)\/([\w+.-]+))?(?:;charset=([\w-]+))?(?:;(base64))?,(.*)/i;
-var VERSION = "8.6.4";
+var VERSION = "8.6.6";
 
 // node_modules/pixi.js/lib/utils/global/globalHooks.mjs
 var ApplicationInitHook = class {
@@ -2408,23 +2408,40 @@ function cleanArray(arr) {
 }
 
 // node_modules/pixi.js/lib/rendering/renderers/shared/texture/RenderableGCSystem.mjs
+var renderableGCTick = 0;
 var _RenderableGCSystem = class _RenderableGCSystem2 {
-  /** @param renderer - The renderer this System works for. */
+  /**
+   * Creates a new RenderableGCSystem instance.
+   * @param renderer - The renderer this garbage collection system works for
+   */
   constructor(renderer) {
     this._managedRenderables = [];
     this._managedHashes = [];
     this._managedArrays = [];
     this._renderer = renderer;
   }
+  /**
+   * Initializes the garbage collection system with the provided options.
+   * @param options - Configuration options for the renderer
+   */
   init(options) {
     options = { ..._RenderableGCSystem2.defaultOptions, ...options };
     this.maxUnusedTime = options.renderableGCMaxUnusedTime;
     this._frequency = options.renderableGCFrequency;
     this.enabled = options.renderableGCActive;
   }
+  /**
+   * Gets whether the garbage collection system is currently enabled.
+   * @returns True if GC is enabled, false otherwise
+   */
   get enabled() {
     return !!this._handler;
   }
+  /**
+   * Enables or disables the garbage collection system.
+   * When enabled, schedules periodic cleanup of resources.
+   * When disabled, cancels all scheduled cleanups.
+   */
   set enabled(value) {
     if (this.enabled === value)
       return;
@@ -2456,28 +2473,53 @@ var _RenderableGCSystem = class _RenderableGCSystem2 {
       this._renderer.scheduler.cancel(this._arrayHandler);
     }
   }
+  /**
+   * Adds a hash table to be managed by the garbage collector.
+   * @param context - The object containing the hash table
+   * @param hash - The property name of the hash table
+   */
   addManagedHash(context, hash) {
     this._managedHashes.push({ context, hash });
   }
+  /**
+   * Adds an array to be managed by the garbage collector.
+   * @param context - The object containing the array
+   * @param hash - The property name of the array
+   */
   addManagedArray(context, hash) {
     this._managedArrays.push({ context, hash });
   }
-  prerender() {
+  /**
+   * Updates the GC timestamp and tracking before rendering.
+   * @param options - The render options
+   * @param options.container - The container to render
+   */
+  prerender({
+    container
+  }) {
     this._now = performance.now();
+    container.renderGroup.gcTick = renderableGCTick++;
+    this._updateInstructionGCTick(container.renderGroup, container.renderGroup.gcTick);
   }
-  addRenderable(renderable, instructionSet) {
+  /**
+   * Starts tracking a renderable for garbage collection.
+   * @param renderable - The renderable to track
+   */
+  addRenderable(renderable) {
     if (!this.enabled)
       return;
-    renderable._lastUsed = this._now;
-    if (renderable._lastInstructionTick === -1) {
+    if (renderable._lastUsed === -1) {
       this._managedRenderables.push(renderable);
       renderable.once("destroyed", this._removeRenderable, this);
     }
-    renderable._lastInstructionTick = instructionSet.tick;
+    renderable._lastUsed = this._now;
   }
-  /** Runs the scheduled garbage collection */
+  /**
+   * Performs garbage collection by cleaning up unused renderables.
+   * Removes renderables that haven't been used for longer than maxUnusedTime.
+   */
   run() {
-    const now = performance.now();
+    const now = this._now;
     const managedRenderables = this._managedRenderables;
     const renderPipes = this._renderer.renderPipes;
     let offset = 0;
@@ -2488,13 +2530,18 @@ var _RenderableGCSystem = class _RenderableGCSystem2 {
         continue;
       }
       const renderGroup = renderable.renderGroup ?? renderable.parentRenderGroup;
-      const currentIndex = renderGroup?.instructionSet?.tick ?? -1;
-      if (renderable._lastInstructionTick !== currentIndex && now - renderable._lastUsed > this.maxUnusedTime) {
+      const currentTick = renderGroup?.instructionSet?.gcTick ?? -1;
+      if ((renderGroup?.gcTick ?? 0) === currentTick) {
+        renderable._lastUsed = now;
+      }
+      if (now - renderable._lastUsed > this.maxUnusedTime) {
         if (!renderable.destroyed) {
           const rp = renderPipes;
+          if (renderGroup)
+            renderGroup.structureDidChange = true;
           rp[renderable.renderPipeId].destroyRenderable(renderable);
         }
-        renderable._lastInstructionTick = -1;
+        renderable._lastUsed = -1;
         offset++;
         renderable.off("destroyed", this._removeRenderable, this);
       } else {
@@ -2503,6 +2550,7 @@ var _RenderableGCSystem = class _RenderableGCSystem2 {
     }
     managedRenderables.length -= offset;
   }
+  /** Cleans up the garbage collection system. Disables GC and removes all tracked resources. */
   destroy() {
     this.enabled = false;
     this._renderer = null;
@@ -2510,6 +2558,10 @@ var _RenderableGCSystem = class _RenderableGCSystem2 {
     this._managedHashes.length = 0;
     this._managedArrays.length = 0;
   }
+  /**
+   * Removes a renderable from being tracked when it's destroyed.
+   * @param renderable - The renderable to stop tracking
+   */
   _removeRenderable(renderable) {
     const index = this._managedRenderables.indexOf(renderable);
     if (index >= 0) {
@@ -2517,6 +2569,17 @@ var _RenderableGCSystem = class _RenderableGCSystem2 {
       this._managedRenderables[index] = null;
     }
   }
+  /**
+   * Updates the GC tick counter for a render group and its children.
+   * @param renderGroup - The render group to update
+   * @param gcTick - The new tick value
+   */
+  _updateInstructionGCTick(renderGroup, gcTick) {
+    renderGroup.instructionSet.gcTick = gcTick;
+    for (const child of renderGroup.renderGroupChildren) {
+      this._updateInstructionGCTick(child, gcTick);
+    }
+  }
 };
 _RenderableGCSystem.extension = {
   type: [
@@ -2527,20 +2590,11 @@ _RenderableGCSystem.extension = {
   priority: 0
 };
 _RenderableGCSystem.defaultOptions = {
-  /**
-   * If set to true, this will enable the garbage collector on the GPU.
-   * @default true
-   */
+  /** Enable/disable the garbage collector */
   renderableGCActive: true,
-  /**
-   * The maximum idle frames before a texture is destroyed by garbage collection.
-   * @default 60 * 60
-   */
+  /** Time in ms before an unused resource is collected (default 1 minute) */
   renderableGCMaxUnusedTime: 6e4,
-  /**
-   * Frames between two garbage collections.
-   * @default 600
-   */
+  /** How often to run garbage collection in ms (default 30 seconds) */
   renderableGCFrequency: 3e4
 };
 var RenderableGCSystem = _RenderableGCSystem;

package/dist/{chunk-SAUNZQHZ.js → chunk-D753T42C.js}

@@ -6,7 +6,7 @@ import {
   eventemitter3_default,
   removeItems,
   warn
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // node_modules/pixi.js/lib/events/FederatedEvent.mjs
 var FederatedEvent = class _FederatedEvent {

package/dist/{chunk-ODIEVSQX.js → chunk-F74VVSHO.js}

@@ -1,7 +1,7 @@
 import {
   CanvasPool,
   getTextureBatchBindGroup
-} from "./chunk-5JREOVCG.js";
+} from "./chunk-XGGTEP7V.js";
 import {
   AbstractRenderer,
   BufferResource,
@@ -15,7 +15,7 @@ import {
   ensureAttributes,
   textureBit,
   uboSyncFunctionsWGSL
-} from "./chunk-5VX2VTDZ.js";
+} from "./chunk-BJGKFUMU.js";
 import {
   BindGroup,
   Buffer,
@@ -42,7 +42,7 @@ import {
   localUniformBitGroup2,
   roundPixelsBit,
   warn
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // node_modules/pixi.js/lib/scene/graphics/gpu/GpuGraphicsAdaptor.mjs
 var GpuGraphicsAdaptor = class {

package/dist/{chunk-6GJXIPNB.js → chunk-GEY6RTYO.js}

@@ -1,6 +1,6 @@
 import {
   Container
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // src/classes/canvas/CanvasBaseItem.ts
 var CanvasBaseItem = class extends Container {

package/dist/{chunk-CAWOWL3P.js → chunk-IG7HSAEJ.js}

@@ -1,7 +1,7 @@
 import {
   CanvasPool,
   getTextureBatchBindGroup
-} from "./chunk-5JREOVCG.js";
+} from "./chunk-XGGTEP7V.js";
 import {
   BatchableSprite,
   BigPool,
@@ -65,7 +65,7 @@ import {
   v8_0_0,
   v8_3_4,
   warn
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 import {
   __commonJS,
   __toESM
@@ -4938,17 +4938,18 @@ var Circle = class _Circle {
    * @param x - The X coordinate of the point to test
    * @param y - The Y coordinate of the point to test
    * @param width - The width of the line to check
+   * @param alignment - The alignment of the stroke, 0.5 by default
    * @returns Whether the x/y coordinates are within this Circle
    */
-  strokeContains(x, y, width) {
+  strokeContains(x, y, width, alignment = 0.5) {
     if (this.radius === 0)
       return false;
     const dx = this.x - x;
     const dy = this.y - y;
-    const r = this.radius;
-    const w2 = width / 2;
+    const radius = this.radius;
+    const outerWidth = (1 - alignment) * width;
     const distance = Math.sqrt(dx * dx + dy * dy);
-    return distance < r + w2 && distance > r - w2;
+    return distance <= radius + outerWidth && distance > radius - (width - outerWidth);
   }
   /**
    * Returns the framing rectangle of the circle as a Rectangle object
@@ -5030,23 +5031,25 @@ var Ellipse = class _Ellipse {
    * Checks whether the x and y coordinates given are contained within this ellipse including stroke
    * @param x - The X coordinate of the point to test
    * @param y - The Y coordinate of the point to test
-   * @param width
+   * @param strokeWidth - The width of the line to check
+   * @param alignment - The alignment of the stroke
    * @returns Whether the x/y coords are within this ellipse
    */
-  strokeContains(x, y, width) {
+  strokeContains(x, y, strokeWidth, alignment = 0.5) {
     const { halfWidth, halfHeight } = this;
     if (halfWidth <= 0 || halfHeight <= 0) {
       return false;
     }
-    const halfStrokeWidth = width / 2;
-    const innerA = halfWidth - halfStrokeWidth;
-    const innerB = halfHeight - halfStrokeWidth;
-    const outerA = halfWidth + halfStrokeWidth;
-    const outerB = halfHeight + halfStrokeWidth;
+    const strokeOuterWidth = strokeWidth * (1 - alignment);
+    const strokeInnerWidth = strokeWidth - strokeOuterWidth;
+    const innerHorizontal = halfWidth - strokeInnerWidth;
+    const innerVertical = halfHeight - strokeInnerWidth;
+    const outerHorizontal = halfWidth + strokeOuterWidth;
+    const outerVertical = halfHeight + strokeOuterWidth;
     const normalizedX = x - this.x;
     const normalizedY = y - this.y;
-    const innerEllipse = normalizedX * normalizedX / (innerA * innerA) + normalizedY * normalizedY / (innerB * innerB);
-    const outerEllipse = normalizedX * normalizedX / (outerA * outerA) + normalizedY * normalizedY / (outerB * outerB);
+    const innerEllipse = normalizedX * normalizedX / (innerHorizontal * innerHorizontal) + normalizedY * normalizedY / (innerVertical * innerVertical);
+    const outerEllipse = normalizedX * normalizedX / (outerHorizontal * outerHorizontal) + normalizedY * normalizedY / (outerVertical * outerVertical);
     return innerEllipse > 1 && outerEllipse <= 1;
   }
   /**
@@ -5175,11 +5178,13 @@ var Polygon = class _Polygon {
    * @param x - The X coordinate of the point to test
    * @param y - The Y coordinate of the point to test
    * @param strokeWidth - The width of the line to check
+   * @param alignment - The alignment of the stroke, 0.5 by default
    * @returns Whether the x/y coordinates are within this polygon
    */
-  strokeContains(x, y, strokeWidth) {
-    const halfStrokeWidth = strokeWidth / 2;
-    const halfStrokeWidthSqrd = halfStrokeWidth * halfStrokeWidth;
+  strokeContains(x, y, strokeWidth, alignment = 0.5) {
+    const strokeWidthSquared = strokeWidth * strokeWidth;
+    const rightWidthSquared = strokeWidthSquared * (1 - alignment);
+    const leftWidthSquared = strokeWidthSquared - rightWidthSquared;
     const { points } = this;
     const iterationLength = points.length - (this.closePath ? 0 : 2);
     for (let i = 0; i < iterationLength; i += 2) {
@@ -5187,8 +5192,9 @@ var Polygon = class _Polygon {
       const y1 = points[i + 1];
       const x2 = points[(i + 2) % points.length];
       const y2 = points[(i + 3) % points.length];
-      const distanceSqrd = squaredDistanceToLineSegment(x, y, x1, y1, x2, y2);
-      if (distanceSqrd <= halfStrokeWidthSqrd) {
+      const distanceSquared = squaredDistanceToLineSegment(x, y, x1, y1, x2, y2);
+      const sign = Math.sign((x2 - x1) * (y - y1) - (y2 - y1) * (x - x1));
+      if (distanceSquared <= (sign < 0 ? leftWidthSquared : rightWidthSquared)) {
         return true;
       }
     }
@@ -5273,11 +5279,11 @@ var Polygon = class _Polygon {
 };
 
 // node_modules/pixi.js/lib/maths/shapes/RoundedRectangle.mjs
-var isCornerWithinStroke = (pX, pY, cornerX, cornerY, radius, halfStrokeWidth) => {
+var isCornerWithinStroke = (pX, pY, cornerX, cornerY, radius, strokeWidthInner, strokeWidthOuter) => {
   const dx = pX - cornerX;
   const dy = pY - cornerY;
   const distance = Math.sqrt(dx * dx + dy * dy);
-  return distance >= radius - halfStrokeWidth && distance <= radius + halfStrokeWidth;
+  return distance >= radius - strokeWidthInner && distance <= radius + strokeWidthOuter;
 };
 var RoundedRectangle = class _RoundedRectangle {
   /**
@@ -5379,26 +5385,60 @@ var RoundedRectangle = class _RoundedRectangle {
    * @param pX - The X coordinate of the point to test
    * @param pY - The Y coordinate of the point to test
    * @param strokeWidth - The width of the line to check
+   * @param alignment - The alignment of the stroke, 0.5 by default
    * @returns Whether the x/y coordinates are within this rectangle
    */
-  strokeContains(pX, pY, strokeWidth) {
+  strokeContains(pX, pY, strokeWidth, alignment = 0.5) {
     const { x, y, width, height, radius } = this;
-    const halfStrokeWidth = strokeWidth / 2;
+    const strokeWidthOuter = strokeWidth * (1 - alignment);
+    const strokeWidthInner = strokeWidth - strokeWidthOuter;
     const innerX = x + radius;
     const innerY = y + radius;
     const innerWidth = width - radius * 2;
     const innerHeight = height - radius * 2;
     const rightBound = x + width;
     const bottomBound = y + height;
-    if ((pX >= x - halfStrokeWidth && pX <= x + halfStrokeWidth || pX >= rightBound - halfStrokeWidth && pX <= rightBound + halfStrokeWidth) && pY >= innerY && pY <= innerY + innerHeight) {
+    if ((pX >= x - strokeWidthOuter && pX <= x + strokeWidthInner || pX >= rightBound - strokeWidthInner && pX <= rightBound + strokeWidthOuter) && pY >= innerY && pY <= innerY + innerHeight) {
       return true;
     }
-    if ((pY >= y - halfStrokeWidth && pY <= y + halfStrokeWidth || pY >= bottomBound - halfStrokeWidth && pY <= bottomBound + halfStrokeWidth) && pX >= innerX && pX <= innerX + innerWidth) {
+    if ((pY >= y - strokeWidthOuter && pY <= y + strokeWidthInner || pY >= bottomBound - strokeWidthInner && pY <= bottomBound + strokeWidthOuter) && pX >= innerX && pX <= innerX + innerWidth) {
       return true;
     }
     return (
       // Top-left
-      pX < innerX && pY < innerY && isCornerWithinStroke(pX, pY, innerX, innerY, radius, halfStrokeWidth) || pX > rightBound - radius && pY < innerY && isCornerWithinStroke(pX, pY, rightBound - radius, innerY, radius, halfStrokeWidth) || pX > rightBound - radius && pY > bottomBound - radius && isCornerWithinStroke(pX, pY, rightBound - radius, bottomBound - radius, radius, halfStrokeWidth) || pX < innerX && pY > bottomBound - radius && isCornerWithinStroke(pX, pY, innerX, bottomBound - radius, radius, halfStrokeWidth)
+      pX < innerX && pY < innerY && isCornerWithinStroke(
+        pX,
+        pY,
+        innerX,
+        innerY,
+        radius,
+        strokeWidthInner,
+        strokeWidthOuter
+      ) || pX > rightBound - radius && pY < innerY && isCornerWithinStroke(
+        pX,
+        pY,
+        rightBound - radius,
+        innerY,
+        radius,
+        strokeWidthInner,
+        strokeWidthOuter
+      ) || pX > rightBound - radius && pY > bottomBound - radius && isCornerWithinStroke(
+        pX,
+        pY,
+        rightBound - radius,
+        bottomBound - radius,
+        radius,
+        strokeWidthInner,
+        strokeWidthOuter
+      ) || pX < innerX && pY > bottomBound - radius && isCornerWithinStroke(
+        pX,
+        pY,
+        innerX,
+        bottomBound - radius,
+        radius,
+        strokeWidthInner,
+        strokeWidthOuter
+      )
     );
   }
   toString() {
@@ -6177,7 +6217,7 @@ var ShapePath = class {
     const delta = Math.PI * 2 / sides;
     const polygon = [];
     for (let i = 0; i < sides; i++) {
-      const angle = i * delta + startAngle;
+      const angle = startAngle - i * delta;
       polygon.push(
         x + radius * Math.cos(angle),
         y + radius * Math.sin(angle)
@@ -7832,13 +7872,13 @@ var _GraphicsContext = class _GraphicsContext2 extends eventemitter3_default {
       if (action === "stroke") {
         const data = instruction.data;
         const alignment = data.style.alignment;
-        const padding = data.style.width * (1 - alignment);
+        const outerPadding = data.style.width * (1 - alignment);
         const _bounds = data.path.bounds;
         bounds.addFrame(
-          _bounds.minX - padding,
-          _bounds.minY - padding,
-          _bounds.maxX + padding,
-          _bounds.maxY + padding
+          _bounds.minX - outerPadding,
+          _bounds.minY - outerPadding,
+          _bounds.maxX + outerPadding,
+          _bounds.maxY + outerPadding
         );
       }
     }
@@ -7871,7 +7911,8 @@ var _GraphicsContext = class _GraphicsContext2 extends eventemitter3_default {
         if (instruction.action === "fill") {
           hasHit = shape.contains(transformedPoint.x, transformedPoint.y);
         } else {
-          hasHit = shape.strokeContains(transformedPoint.x, transformedPoint.y, style.width);
+          const strokeStyle = style;
+          hasHit = shape.strokeContains(transformedPoint.x, transformedPoint.y, strokeStyle.width, strokeStyle.alignment);
         }
         const holes = data.hole;
         if (holes) {

package/dist/{chunk-PP3SBC3C.js → chunk-KAHX5SKO.js}

@@ -2324,22 +2324,25 @@ var Rectangle = class _Rectangle {
    * @param x - The X coordinate of the point to test
    * @param y - The Y coordinate of the point to test
    * @param strokeWidth - The width of the line to check
+   * @param alignment - The alignment of the stroke, 0.5 by default
    * @returns Whether the x/y coordinates are within this rectangle
    */
-  strokeContains(x2, y2, strokeWidth) {
+  strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
     const { width, height } = this;
     if (width <= 0 || height <= 0)
       return false;
     const _x = this.x;
     const _y = this.y;
-    const outerLeft = _x - strokeWidth / 2;
-    const outerRight = _x + width + strokeWidth / 2;
-    const outerTop = _y - strokeWidth / 2;
-    const outerBottom = _y + height + strokeWidth / 2;
-    const innerLeft = _x + strokeWidth / 2;
-    const innerRight = _x + width - strokeWidth / 2;
-    const innerTop = _y + strokeWidth / 2;
-    const innerBottom = _y + height - strokeWidth / 2;
+    const strokeWidthOuter = strokeWidth * (1 - alignment);
+    const strokeWidthInner = strokeWidth - strokeWidthOuter;
+    const outerLeft = _x - strokeWidthOuter;
+    const outerRight = _x + width + strokeWidthOuter;
+    const outerTop = _y - strokeWidthOuter;
+    const outerBottom = _y + height + strokeWidthOuter;
+    const innerLeft = _x + strokeWidthInner;
+    const innerRight = _x + width - strokeWidthInner;
+    const innerTop = _y + strokeWidthInner;
+    const innerBottom = _y + height - strokeWidthInner;
     return x2 >= outerLeft && x2 <= outerRight && y2 >= outerTop && y2 <= outerBottom && !(x2 > innerLeft && x2 < innerRight && y2 > innerTop && y2 < innerBottom);
   }
   /**
@@ -3376,19 +3379,17 @@ var toLocalGlobalMixin = {
 };
 
 // node_modules/pixi.js/lib/rendering/renderers/shared/instructions/InstructionSet.mjs
-var _tick = 0;
 var InstructionSet = class {
   constructor() {
     this.uid = uid("instructionSet");
     this.instructions = [];
     this.instructionSize = 0;
     this.renderables = [];
-    this.tick = 0;
+    this.gcTick = 0;
   }
   /** reset the instruction set so it can be reused set size back to 0 */
   reset() {
     this.instructionSize = 0;
-    this.tick = _tick++;
   }
   /**
    * Add an instruction to the set
@@ -4470,6 +4471,7 @@ var RenderGroup = class {
     this.worldAlpha = 1;
     this.childrenToUpdate = /* @__PURE__ */ Object.create(null);
     this.updateTick = 0;
+    this.gcTick = 0;
     this.childrenRenderablesToUpdate = { list: [], index: 0 };
     this.structureDidChange = true;
     this.instructionSet = new InstructionSet();
@@ -4485,7 +4487,9 @@ var RenderGroup = class {
     root.didChange = true;
     const children = root.children;
     for (let i2 = 0; i2 < children.length; i2++) {
-      this.addChild(children[i2]);
+      const child = children[i2];
+      child._updateFlags = 15;
+      this.addChild(child);
     }
   }
   enableCacheAsTexture(options = {}) {
@@ -5835,8 +5839,7 @@ var ViewContainer = class extends Container {
     this.canBundle = true;
     this.allowChildren = false;
     this._roundPixels = 0;
-    this._lastUsed = 0;
-    this._lastInstructionTick = -1;
+    this._lastUsed = -1;
     this._bounds = new Bounds(0, 1, 0, 0);
     this._boundsDirty = true;
   }