@drincs/pixi-vn 0.9.7 → 0.9.8

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;
   }

package/dist/{chunk-ODIEVSQX.js → chunk-OPLBQKS2.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-DXOIIOAQ.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-Y3WNBACN.js → chunk-R4J2U4HN.js}

@@ -15,10 +15,10 @@ import {
   ResizePlugin,
   TickerPlugin,
   TilingSpritePipe
-} from "./chunk-CAWOWL3P.js";
+} from "./chunk-IG7HSAEJ.js";
 import {
   extensions
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // node_modules/pixi.js/lib/app/init.mjs
 extensions.add(ResizePlugin);

package/dist/{chunk-WS3FY4Q6.js → chunk-X55ALTH7.js}

@@ -1,14 +1,14 @@
 import {
   LoaderParserPriority,
   path
-} from "./chunk-CAWOWL3P.js";
+} from "./chunk-IG7HSAEJ.js";
 import {
   DOMAdapter,
   ExtensionType,
   Ticker,
   eventemitter3_default,
   extensions
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 import {
   __export
 } from "./chunk-N342G4HO.js";

package/dist/{chunk-5JREOVCG.js → chunk-XGGTEP7V.js}

@@ -4,7 +4,7 @@ import {
   Texture,
   getMaxTexturesPerBatch,
   nextPow2
-} from "./chunk-PP3SBC3C.js";
+} from "./chunk-KAHX5SKO.js";
 
 // node_modules/pixi.js/lib/rendering/batcher/gpu/getTextureBatchBindGroup.mjs
 var cachedGroups = {};