pixi-watchface-engine 0.1.5 → 0.1.7

package/dist/index.js

@@ -3,25 +3,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -10289,400 +10307,6 @@ var init_Geometry = __esm(() => {
   };
 });
 
-// node_modules/pixi.js/lib/maths/misc/squaredDistanceToLineSegment.mjs
-function squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22) {
-  const a2 = x2 - x1;
-  const b2 = y2 - y1;
-  const c2 = x22 - x1;
-  const d2 = y22 - y1;
-  const dot = a2 * c2 + b2 * d2;
-  const lenSq = c2 * c2 + d2 * d2;
-  let param = -1;
-  if (lenSq !== 0) {
-    param = dot / lenSq;
-  }
-  let xx;
-  let yy;
-  if (param < 0) {
-    xx = x1;
-    yy = y1;
-  } else if (param > 1) {
-    xx = x22;
-    yy = y22;
-  } else {
-    xx = x1 + param * c2;
-    yy = y1 + param * d2;
-  }
-  const dx = x2 - xx;
-  const dy = y2 - yy;
-  return dx * dx + dy * dy;
-}
-var init_squaredDistanceToLineSegment = () => {};
-
-// node_modules/pixi.js/lib/maths/shapes/Circle.mjs
-class Circle {
-  constructor(x2 = 0, y2 = 0, radius = 0) {
-    this.type = "circle";
-    this.x = x2;
-    this.y = y2;
-    this.radius = radius;
-  }
-  clone() {
-    return new Circle(this.x, this.y, this.radius);
-  }
-  contains(x2, y2) {
-    if (this.radius <= 0)
-      return false;
-    const r2 = this.radius * this.radius;
-    let dx = this.x - x2;
-    let dy = this.y - y2;
-    dx *= dx;
-    dy *= dy;
-    return dx + dy <= r2;
-  }
-  strokeContains(x2, y2, width, alignment = 0.5) {
-    if (this.radius === 0)
-      return false;
-    const dx = this.x - x2;
-    const dy = this.y - y2;
-    const radius = this.radius;
-    const outerWidth = (1 - alignment) * width;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    return distance <= radius + outerWidth && distance > radius - (width - outerWidth);
-  }
-  getBounds(out) {
-    out || (out = new Rectangle);
-    out.x = this.x - this.radius;
-    out.y = this.y - this.radius;
-    out.width = this.radius * 2;
-    out.height = this.radius * 2;
-    return out;
-  }
-  copyFrom(circle) {
-    this.x = circle.x;
-    this.y = circle.y;
-    this.radius = circle.radius;
-    return this;
-  }
-  copyTo(circle) {
-    circle.copyFrom(this);
-    return circle;
-  }
-  toString() {
-    return `[pixi.js/math:Circle x=${this.x} y=${this.y} radius=${this.radius}]`;
-  }
-}
-var init_Circle = __esm(() => {
-  init_Rectangle();
-});
-
-// node_modules/pixi.js/lib/maths/shapes/Ellipse.mjs
-class Ellipse {
-  constructor(x2 = 0, y2 = 0, halfWidth = 0, halfHeight = 0) {
-    this.type = "ellipse";
-    this.x = x2;
-    this.y = y2;
-    this.halfWidth = halfWidth;
-    this.halfHeight = halfHeight;
-  }
-  clone() {
-    return new Ellipse(this.x, this.y, this.halfWidth, this.halfHeight);
-  }
-  contains(x2, y2) {
-    if (this.halfWidth <= 0 || this.halfHeight <= 0) {
-      return false;
-    }
-    let normx = (x2 - this.x) / this.halfWidth;
-    let normy = (y2 - this.y) / this.halfHeight;
-    normx *= normx;
-    normy *= normy;
-    return normx + normy <= 1;
-  }
-  strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
-    const { halfWidth, halfHeight } = this;
-    if (halfWidth <= 0 || halfHeight <= 0) {
-      return false;
-    }
-    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 = x2 - this.x;
-    const normalizedY = y2 - this.y;
-    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;
-  }
-  getBounds(out) {
-    out || (out = new Rectangle);
-    out.x = this.x - this.halfWidth;
-    out.y = this.y - this.halfHeight;
-    out.width = this.halfWidth * 2;
-    out.height = this.halfHeight * 2;
-    return out;
-  }
-  copyFrom(ellipse) {
-    this.x = ellipse.x;
-    this.y = ellipse.y;
-    this.halfWidth = ellipse.halfWidth;
-    this.halfHeight = ellipse.halfHeight;
-    return this;
-  }
-  copyTo(ellipse) {
-    ellipse.copyFrom(this);
-    return ellipse;
-  }
-  toString() {
-    return `[pixi.js/math:Ellipse x=${this.x} y=${this.y} halfWidth=${this.halfWidth} halfHeight=${this.halfHeight}]`;
-  }
-}
-var init_Ellipse = __esm(() => {
-  init_Rectangle();
-});
-
-// node_modules/pixi.js/lib/maths/shapes/Polygon.mjs
-class Polygon {
-  constructor(...points) {
-    this.type = "polygon";
-    let flat = Array.isArray(points[0]) ? points[0] : points;
-    if (typeof flat[0] !== "number") {
-      const p2 = [];
-      for (let i2 = 0, il = flat.length;i2 < il; i2++) {
-        p2.push(flat[i2].x, flat[i2].y);
-      }
-      flat = p2;
-    }
-    this.points = flat;
-    this.closePath = true;
-  }
-  isClockwise() {
-    let area = 0;
-    const points = this.points;
-    const length = points.length;
-    for (let i2 = 0;i2 < length; i2 += 2) {
-      const x1 = points[i2];
-      const y1 = points[i2 + 1];
-      const x2 = points[(i2 + 2) % length];
-      const y2 = points[(i2 + 3) % length];
-      area += (x2 - x1) * (y2 + y1);
-    }
-    return area < 0;
-  }
-  containsPolygon(polygon) {
-    const thisBounds = this.getBounds(tempRect);
-    const otherBounds = polygon.getBounds(tempRect2);
-    if (!thisBounds.containsRect(otherBounds)) {
-      return false;
-    }
-    const points = polygon.points;
-    for (let i2 = 0;i2 < points.length; i2 += 2) {
-      const x2 = points[i2];
-      const y2 = points[i2 + 1];
-      if (!this.contains(x2, y2)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  clone() {
-    const points = this.points.slice();
-    const polygon = new Polygon(points);
-    polygon.closePath = this.closePath;
-    return polygon;
-  }
-  contains(x2, y2) {
-    let inside = false;
-    const length = this.points.length / 2;
-    for (let i2 = 0, j2 = length - 1;i2 < length; j2 = i2++) {
-      const xi = this.points[i2 * 2];
-      const yi = this.points[i2 * 2 + 1];
-      const xj = this.points[j2 * 2];
-      const yj = this.points[j2 * 2 + 1];
-      const intersect = yi > y2 !== yj > y2 && x2 < (xj - xi) * ((y2 - yi) / (yj - yi)) + xi;
-      if (intersect) {
-        inside = !inside;
-      }
-    }
-    return inside;
-  }
-  strokeContains(x2, y2, 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 i2 = 0;i2 < iterationLength; i2 += 2) {
-      const x1 = points[i2];
-      const y1 = points[i2 + 1];
-      const x22 = points[(i2 + 2) % points.length];
-      const y22 = points[(i2 + 3) % points.length];
-      const distanceSquared = squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22);
-      const sign = Math.sign((x22 - x1) * (y2 - y1) - (y22 - y1) * (x2 - x1));
-      if (distanceSquared <= (sign < 0 ? leftWidthSquared : rightWidthSquared)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  getBounds(out) {
-    out || (out = new Rectangle);
-    const points = this.points;
-    let minX = Infinity;
-    let maxX = -Infinity;
-    let minY = Infinity;
-    let maxY = -Infinity;
-    for (let i2 = 0, n2 = points.length;i2 < n2; i2 += 2) {
-      const x2 = points[i2];
-      const y2 = points[i2 + 1];
-      minX = x2 < minX ? x2 : minX;
-      maxX = x2 > maxX ? x2 : maxX;
-      minY = y2 < minY ? y2 : minY;
-      maxY = y2 > maxY ? y2 : maxY;
-    }
-    out.x = minX;
-    out.width = maxX - minX;
-    out.y = minY;
-    out.height = maxY - minY;
-    return out;
-  }
-  copyFrom(polygon) {
-    this.points = polygon.points.slice();
-    this.closePath = polygon.closePath;
-    return this;
-  }
-  copyTo(polygon) {
-    polygon.copyFrom(this);
-    return polygon;
-  }
-  toString() {
-    return `[pixi.js/math:PolygoncloseStroke=${this.closePath}points=${this.points.reduce((pointsDesc, currentPoint) => `${pointsDesc}, ${currentPoint}`, "")}]`;
-  }
-  get lastX() {
-    return this.points[this.points.length - 2];
-  }
-  get lastY() {
-    return this.points[this.points.length - 1];
-  }
-  get x() {
-    deprecation("8.11.0", "Polygon.lastX is deprecated, please use Polygon.lastX instead.");
-    return this.points[this.points.length - 2];
-  }
-  get y() {
-    deprecation("8.11.0", "Polygon.y is deprecated, please use Polygon.lastY instead.");
-    return this.points[this.points.length - 1];
-  }
-  get startX() {
-    return this.points[0];
-  }
-  get startY() {
-    return this.points[1];
-  }
-}
-var tempRect, tempRect2;
-var init_Polygon = __esm(() => {
-  init_deprecation();
-  init_squaredDistanceToLineSegment();
-  init_Rectangle();
-});
-
-// node_modules/pixi.js/lib/maths/shapes/RoundedRectangle.mjs
-class RoundedRectangle {
-  constructor(x2 = 0, y2 = 0, width = 0, height = 0, radius = 20) {
-    this.type = "roundedRectangle";
-    this.x = x2;
-    this.y = y2;
-    this.width = width;
-    this.height = height;
-    this.radius = radius;
-  }
-  getBounds(out) {
-    out || (out = new Rectangle);
-    out.x = this.x;
-    out.y = this.y;
-    out.width = this.width;
-    out.height = this.height;
-    return out;
-  }
-  clone() {
-    return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
-  }
-  copyFrom(rectangle) {
-    this.x = rectangle.x;
-    this.y = rectangle.y;
-    this.width = rectangle.width;
-    this.height = rectangle.height;
-    return this;
-  }
-  copyTo(rectangle) {
-    rectangle.copyFrom(this);
-    return rectangle;
-  }
-  contains(x2, y2) {
-    if (this.width <= 0 || this.height <= 0) {
-      return false;
-    }
-    if (x2 >= this.x && x2 <= this.x + this.width) {
-      if (y2 >= this.y && y2 <= this.y + this.height) {
-        const radius = Math.max(0, Math.min(this.radius, Math.min(this.width, this.height) / 2));
-        if (y2 >= this.y + radius && y2 <= this.y + this.height - radius || x2 >= this.x + radius && x2 <= this.x + this.width - radius) {
-          return true;
-        }
-        let dx = x2 - (this.x + radius);
-        let dy = y2 - (this.y + radius);
-        const radius2 = radius * radius;
-        if (dx * dx + dy * dy <= radius2) {
-          return true;
-        }
-        dx = x2 - (this.x + this.width - radius);
-        if (dx * dx + dy * dy <= radius2) {
-          return true;
-        }
-        dy = y2 - (this.y + this.height - radius);
-        if (dx * dx + dy * dy <= radius2) {
-          return true;
-        }
-        dx = x2 - (this.x + radius);
-        if (dx * dx + dy * dy <= radius2) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  strokeContains(pX, pY, strokeWidth, alignment = 0.5) {
-    const { x: x2, y: y2, width, height, radius } = this;
-    const strokeWidthOuter = strokeWidth * (1 - alignment);
-    const strokeWidthInner = strokeWidth - strokeWidthOuter;
-    const innerX = x2 + radius;
-    const innerY = y2 + radius;
-    const innerWidth = width - radius * 2;
-    const innerHeight = height - radius * 2;
-    const rightBound = x2 + width;
-    const bottomBound = y2 + height;
-    if ((pX >= x2 - strokeWidthOuter && pX <= x2 + strokeWidthInner || pX >= rightBound - strokeWidthInner && pX <= rightBound + strokeWidthOuter) && pY >= innerY && pY <= innerY + innerHeight) {
-      return true;
-    }
-    if ((pY >= y2 - strokeWidthOuter && pY <= y2 + strokeWidthInner || pY >= bottomBound - strokeWidthInner && pY <= bottomBound + strokeWidthOuter) && pX >= innerX && pX <= innerX + innerWidth) {
-      return true;
-    }
-    return 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() {
-    return `[pixi.js/math:RoundedRectangle x=${this.x} y=${this.y}width=${this.width} height=${this.height} radius=${this.radius}]`;
-  }
-}
-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 - strokeWidthInner && distance <= radius + strokeWidthOuter;
-};
-var init_RoundedRectangle = __esm(() => {
-  init_Rectangle();
-});
-
 // node_modules/pixi.js/lib/scene/container/bounds/getRenderableBounds.mjs
 function getGlobalRenderableBounds(renderables, bounds) {
   bounds.clear();
@@ -15175,7 +14799,7 @@ class GenerateTextureSystem {
     } else {
       clearColor = noColor;
     }
-    const region = options.frame?.copyTo(tempRect3) || getLocalBounds(container, tempBounds3).rectangle;
+    const region = options.frame?.copyTo(tempRect) || getLocalBounds(container, tempBounds3).rectangle;
     region.width = Math.max(region.width, 1 / resolution) | 0;
     region.height = Math.max(region.height, 1 / resolution) | 0;
     const target = RenderTexture.create({
@@ -15199,7 +14823,7 @@ class GenerateTextureSystem {
     this._renderer = null;
   }
 }
-var tempRect3, tempBounds3, noColor;
+var tempRect, tempBounds3, noColor;
 var init_GenerateTextureSystem = __esm(() => {
   init_Color();
   init_Extensions();
@@ -15209,7 +14833,7 @@ var init_GenerateTextureSystem = __esm(() => {
   init_getLocalBounds();
   init_Container();
   init_RenderTexture();
-  tempRect3 = new Rectangle;
+  tempRect = new Rectangle;
   tempBounds3 = new Bounds;
   noColor = [0, 0, 0, 0];
   GenerateTextureSystem.extension = {
@@ -23756,7 +23380,7 @@ var init_buildTriangle = __esm(() => {
 function generateTextureMatrix(out, style, shape, matrix) {
   const textureMatrix = style.matrix ? out.copyFrom(style.matrix).invert() : out.identity();
   if (style.textureSpace === "local") {
-    const bounds = shape.getBounds(tempRect5);
+    const bounds = shape.getBounds(tempRect2);
     if (style.width) {
       bounds.pad(style.width);
     }
@@ -23789,13 +23413,13 @@ function generateTextureMatrix(out, style, shape, matrix) {
   }
   return textureMatrix;
 }
-var tempTextureMatrix, tempRect5;
+var tempTextureMatrix, tempRect2;
 var init_generateTextureFillMatrix = __esm(() => {
   init_Matrix();
   init_Rectangle();
   init_FillGradient();
   tempTextureMatrix = new Matrix;
-  tempRect5 = new Rectangle;
+  tempRect2 = new Rectangle;
 });
 
 // node_modules/pixi.js/lib/scene/graphics/shared/utils/buildContextBatches.mjs
@@ -23827,7 +23451,7 @@ function buildContextBatches(context2, gpuContext) {
 function addTextureToGeometryData(data, batches, geometryData) {
   const points = [];
   const build = shapeBuilders.rectangle;
-  const rect = tempRect6;
+  const rect = tempRect3;
   rect.x = data.dx;
   rect.y = data.dy;
   rect.width = data.dw;
@@ -23927,7 +23551,7 @@ function getHoleArrays(holePrimitives) {
   }
   return holeArrays;
 }
-var shapeBuilders, tempRect6, tempTextureMatrix2;
+var shapeBuilders, tempRect3, tempTextureMatrix2;
 var init_buildContextBatches = __esm(() => {
   init_Extensions();
   init_Matrix();
@@ -23948,7 +23572,7 @@ var init_buildContextBatches = __esm(() => {
   shapeBuilders = {};
   extensions.handleByMap(ExtensionType.ShapeBuilder, shapeBuilders);
   extensions.add(buildRectangle, buildPolygon, buildTriangle, buildCircle, buildEllipse, buildRoundedRectangle);
-  tempRect6 = new Rectangle;
+  tempRect3 = new Rectangle;
   tempTextureMatrix2 = new Matrix;
 });
 
@@ -24635,6 +24259,400 @@ var init_parseSVGPath = __esm(() => {
   import_parse_svg_path = __toESM(require_parse_svg_path(), 1);
 });
 
+// node_modules/pixi.js/lib/maths/shapes/Circle.mjs
+class Circle {
+  constructor(x2 = 0, y2 = 0, radius = 0) {
+    this.type = "circle";
+    this.x = x2;
+    this.y = y2;
+    this.radius = radius;
+  }
+  clone() {
+    return new Circle(this.x, this.y, this.radius);
+  }
+  contains(x2, y2) {
+    if (this.radius <= 0)
+      return false;
+    const r2 = this.radius * this.radius;
+    let dx = this.x - x2;
+    let dy = this.y - y2;
+    dx *= dx;
+    dy *= dy;
+    return dx + dy <= r2;
+  }
+  strokeContains(x2, y2, width, alignment = 0.5) {
+    if (this.radius === 0)
+      return false;
+    const dx = this.x - x2;
+    const dy = this.y - y2;
+    const radius = this.radius;
+    const outerWidth = (1 - alignment) * width;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+    return distance <= radius + outerWidth && distance > radius - (width - outerWidth);
+  }
+  getBounds(out) {
+    out || (out = new Rectangle);
+    out.x = this.x - this.radius;
+    out.y = this.y - this.radius;
+    out.width = this.radius * 2;
+    out.height = this.radius * 2;
+    return out;
+  }
+  copyFrom(circle) {
+    this.x = circle.x;
+    this.y = circle.y;
+    this.radius = circle.radius;
+    return this;
+  }
+  copyTo(circle) {
+    circle.copyFrom(this);
+    return circle;
+  }
+  toString() {
+    return `[pixi.js/math:Circle x=${this.x} y=${this.y} radius=${this.radius}]`;
+  }
+}
+var init_Circle = __esm(() => {
+  init_Rectangle();
+});
+
+// node_modules/pixi.js/lib/maths/shapes/Ellipse.mjs
+class Ellipse {
+  constructor(x2 = 0, y2 = 0, halfWidth = 0, halfHeight = 0) {
+    this.type = "ellipse";
+    this.x = x2;
+    this.y = y2;
+    this.halfWidth = halfWidth;
+    this.halfHeight = halfHeight;
+  }
+  clone() {
+    return new Ellipse(this.x, this.y, this.halfWidth, this.halfHeight);
+  }
+  contains(x2, y2) {
+    if (this.halfWidth <= 0 || this.halfHeight <= 0) {
+      return false;
+    }
+    let normx = (x2 - this.x) / this.halfWidth;
+    let normy = (y2 - this.y) / this.halfHeight;
+    normx *= normx;
+    normy *= normy;
+    return normx + normy <= 1;
+  }
+  strokeContains(x2, y2, strokeWidth, alignment = 0.5) {
+    const { halfWidth, halfHeight } = this;
+    if (halfWidth <= 0 || halfHeight <= 0) {
+      return false;
+    }
+    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 = x2 - this.x;
+    const normalizedY = y2 - this.y;
+    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;
+  }
+  getBounds(out) {
+    out || (out = new Rectangle);
+    out.x = this.x - this.halfWidth;
+    out.y = this.y - this.halfHeight;
+    out.width = this.halfWidth * 2;
+    out.height = this.halfHeight * 2;
+    return out;
+  }
+  copyFrom(ellipse) {
+    this.x = ellipse.x;
+    this.y = ellipse.y;
+    this.halfWidth = ellipse.halfWidth;
+    this.halfHeight = ellipse.halfHeight;
+    return this;
+  }
+  copyTo(ellipse) {
+    ellipse.copyFrom(this);
+    return ellipse;
+  }
+  toString() {
+    return `[pixi.js/math:Ellipse x=${this.x} y=${this.y} halfWidth=${this.halfWidth} halfHeight=${this.halfHeight}]`;
+  }
+}
+var init_Ellipse = __esm(() => {
+  init_Rectangle();
+});
+
+// node_modules/pixi.js/lib/maths/misc/squaredDistanceToLineSegment.mjs
+function squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22) {
+  const a2 = x2 - x1;
+  const b2 = y2 - y1;
+  const c2 = x22 - x1;
+  const d2 = y22 - y1;
+  const dot = a2 * c2 + b2 * d2;
+  const lenSq = c2 * c2 + d2 * d2;
+  let param = -1;
+  if (lenSq !== 0) {
+    param = dot / lenSq;
+  }
+  let xx;
+  let yy;
+  if (param < 0) {
+    xx = x1;
+    yy = y1;
+  } else if (param > 1) {
+    xx = x22;
+    yy = y22;
+  } else {
+    xx = x1 + param * c2;
+    yy = y1 + param * d2;
+  }
+  const dx = x2 - xx;
+  const dy = y2 - yy;
+  return dx * dx + dy * dy;
+}
+var init_squaredDistanceToLineSegment = () => {};
+
+// node_modules/pixi.js/lib/maths/shapes/Polygon.mjs
+class Polygon {
+  constructor(...points) {
+    this.type = "polygon";
+    let flat = Array.isArray(points[0]) ? points[0] : points;
+    if (typeof flat[0] !== "number") {
+      const p2 = [];
+      for (let i2 = 0, il = flat.length;i2 < il; i2++) {
+        p2.push(flat[i2].x, flat[i2].y);
+      }
+      flat = p2;
+    }
+    this.points = flat;
+    this.closePath = true;
+  }
+  isClockwise() {
+    let area2 = 0;
+    const points = this.points;
+    const length = points.length;
+    for (let i2 = 0;i2 < length; i2 += 2) {
+      const x1 = points[i2];
+      const y1 = points[i2 + 1];
+      const x2 = points[(i2 + 2) % length];
+      const y2 = points[(i2 + 3) % length];
+      area2 += (x2 - x1) * (y2 + y1);
+    }
+    return area2 < 0;
+  }
+  containsPolygon(polygon) {
+    const thisBounds = this.getBounds(tempRect4);
+    const otherBounds = polygon.getBounds(tempRect22);
+    if (!thisBounds.containsRect(otherBounds)) {
+      return false;
+    }
+    const points = polygon.points;
+    for (let i2 = 0;i2 < points.length; i2 += 2) {
+      const x2 = points[i2];
+      const y2 = points[i2 + 1];
+      if (!this.contains(x2, y2)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  clone() {
+    const points = this.points.slice();
+    const polygon = new Polygon(points);
+    polygon.closePath = this.closePath;
+    return polygon;
+  }
+  contains(x2, y2) {
+    let inside = false;
+    const length = this.points.length / 2;
+    for (let i2 = 0, j2 = length - 1;i2 < length; j2 = i2++) {
+      const xi = this.points[i2 * 2];
+      const yi = this.points[i2 * 2 + 1];
+      const xj = this.points[j2 * 2];
+      const yj = this.points[j2 * 2 + 1];
+      const intersect = yi > y2 !== yj > y2 && x2 < (xj - xi) * ((y2 - yi) / (yj - yi)) + xi;
+      if (intersect) {
+        inside = !inside;
+      }
+    }
+    return inside;
+  }
+  strokeContains(x2, y2, 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 i2 = 0;i2 < iterationLength; i2 += 2) {
+      const x1 = points[i2];
+      const y1 = points[i2 + 1];
+      const x22 = points[(i2 + 2) % points.length];
+      const y22 = points[(i2 + 3) % points.length];
+      const distanceSquared = squaredDistanceToLineSegment(x2, y2, x1, y1, x22, y22);
+      const sign2 = Math.sign((x22 - x1) * (y2 - y1) - (y22 - y1) * (x2 - x1));
+      if (distanceSquared <= (sign2 < 0 ? leftWidthSquared : rightWidthSquared)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getBounds(out) {
+    out || (out = new Rectangle);
+    const points = this.points;
+    let minX = Infinity;
+    let maxX = -Infinity;
+    let minY = Infinity;
+    let maxY = -Infinity;
+    for (let i2 = 0, n2 = points.length;i2 < n2; i2 += 2) {
+      const x2 = points[i2];
+      const y2 = points[i2 + 1];
+      minX = x2 < minX ? x2 : minX;
+      maxX = x2 > maxX ? x2 : maxX;
+      minY = y2 < minY ? y2 : minY;
+      maxY = y2 > maxY ? y2 : maxY;
+    }
+    out.x = minX;
+    out.width = maxX - minX;
+    out.y = minY;
+    out.height = maxY - minY;
+    return out;
+  }
+  copyFrom(polygon) {
+    this.points = polygon.points.slice();
+    this.closePath = polygon.closePath;
+    return this;
+  }
+  copyTo(polygon) {
+    polygon.copyFrom(this);
+    return polygon;
+  }
+  toString() {
+    return `[pixi.js/math:PolygoncloseStroke=${this.closePath}points=${this.points.reduce((pointsDesc, currentPoint) => `${pointsDesc}, ${currentPoint}`, "")}]`;
+  }
+  get lastX() {
+    return this.points[this.points.length - 2];
+  }
+  get lastY() {
+    return this.points[this.points.length - 1];
+  }
+  get x() {
+    deprecation("8.11.0", "Polygon.lastX is deprecated, please use Polygon.lastX instead.");
+    return this.points[this.points.length - 2];
+  }
+  get y() {
+    deprecation("8.11.0", "Polygon.y is deprecated, please use Polygon.lastY instead.");
+    return this.points[this.points.length - 1];
+  }
+  get startX() {
+    return this.points[0];
+  }
+  get startY() {
+    return this.points[1];
+  }
+}
+var tempRect4, tempRect22;
+var init_Polygon = __esm(() => {
+  init_deprecation();
+  init_squaredDistanceToLineSegment();
+  init_Rectangle();
+});
+
+// node_modules/pixi.js/lib/maths/shapes/RoundedRectangle.mjs
+class RoundedRectangle {
+  constructor(x2 = 0, y2 = 0, width = 0, height = 0, radius = 20) {
+    this.type = "roundedRectangle";
+    this.x = x2;
+    this.y = y2;
+    this.width = width;
+    this.height = height;
+    this.radius = radius;
+  }
+  getBounds(out) {
+    out || (out = new Rectangle);
+    out.x = this.x;
+    out.y = this.y;
+    out.width = this.width;
+    out.height = this.height;
+    return out;
+  }
+  clone() {
+    return new RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
+  }
+  copyFrom(rectangle) {
+    this.x = rectangle.x;
+    this.y = rectangle.y;
+    this.width = rectangle.width;
+    this.height = rectangle.height;
+    return this;
+  }
+  copyTo(rectangle) {
+    rectangle.copyFrom(this);
+    return rectangle;
+  }
+  contains(x2, y2) {
+    if (this.width <= 0 || this.height <= 0) {
+      return false;
+    }
+    if (x2 >= this.x && x2 <= this.x + this.width) {
+      if (y2 >= this.y && y2 <= this.y + this.height) {
+        const radius = Math.max(0, Math.min(this.radius, Math.min(this.width, this.height) / 2));
+        if (y2 >= this.y + radius && y2 <= this.y + this.height - radius || x2 >= this.x + radius && x2 <= this.x + this.width - radius) {
+          return true;
+        }
+        let dx = x2 - (this.x + radius);
+        let dy = y2 - (this.y + radius);
+        const radius2 = radius * radius;
+        if (dx * dx + dy * dy <= radius2) {
+          return true;
+        }
+        dx = x2 - (this.x + this.width - radius);
+        if (dx * dx + dy * dy <= radius2) {
+          return true;
+        }
+        dy = y2 - (this.y + this.height - radius);
+        if (dx * dx + dy * dy <= radius2) {
+          return true;
+        }
+        dx = x2 - (this.x + radius);
+        if (dx * dx + dy * dy <= radius2) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  strokeContains(pX, pY, strokeWidth, alignment = 0.5) {
+    const { x: x2, y: y2, width, height, radius } = this;
+    const strokeWidthOuter = strokeWidth * (1 - alignment);
+    const strokeWidthInner = strokeWidth - strokeWidthOuter;
+    const innerX = x2 + radius;
+    const innerY = y2 + radius;
+    const innerWidth = width - radius * 2;
+    const innerHeight = height - radius * 2;
+    const rightBound = x2 + width;
+    const bottomBound = y2 + height;
+    if ((pX >= x2 - strokeWidthOuter && pX <= x2 + strokeWidthInner || pX >= rightBound - strokeWidthInner && pX <= rightBound + strokeWidthOuter) && pY >= innerY && pY <= innerY + innerHeight) {
+      return true;
+    }
+    if ((pY >= y2 - strokeWidthOuter && pY <= y2 + strokeWidthInner || pY >= bottomBound - strokeWidthInner && pY <= bottomBound + strokeWidthOuter) && pX >= innerX && pX <= innerX + innerWidth) {
+      return true;
+    }
+    return 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() {
+    return `[pixi.js/math:RoundedRectangle x=${this.x} y=${this.y}width=${this.width} height=${this.height} radius=${this.radius}]`;
+  }
+}
+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 - strokeWidthInner && distance <= radius + strokeWidthOuter;
+};
+var init_RoundedRectangle = __esm(() => {
+  init_Rectangle();
+});
+
 // node_modules/pixi.js/lib/scene/graphics/shared/GraphicsContextSystem.mjs
 class GpuGraphicsContext {
   constructor() {
@@ -29858,6 +29876,9 @@ _Application._plugins = [];
 var Application = _Application;
 extensions.handleByList(ExtensionType.Application, Application._plugins);
 extensions.add(ApplicationInitHook);
+// node_modules/pixi.js/lib/index.mjs
+init_Point();
+init_Rectangle();
 
 // node_modules/pixi.js/lib/scene/text/Text.mjs
 init_TextureStyle();
@@ -30088,7 +30109,7 @@ function getCanvasBoundingBox(...args) {
 init_CanvasTextMetrics();
 init_fontStringFromTextStyle();
 init_getCanvasFillStyle();
-var tempRect7 = new Rectangle;
+var tempRect5 = new Rectangle;
 
 class CanvasTextGeneratorClass {
   getCanvasAndContext(options) {
@@ -30099,7 +30120,7 @@ class CanvasTextGeneratorClass {
     const height = Math.ceil(Math.ceil(Math.max(1, measured.height) + padding * 2) * resolution);
     const canvasAndContext = CanvasPool.getOptimalCanvasAndContext(width, height);
     this._renderTextToCanvas(style, padding, resolution, canvasAndContext, measured);
-    const frame = style.trim ? getCanvasBoundingBox({ canvas: canvasAndContext.canvas, width, height, resolution: 1, output: tempRect7 }) : tempRect7.set(0, 0, width, height);
+    const frame = style.trim ? getCanvasBoundingBox({ canvas: canvasAndContext.canvas, width, height, resolution: 1, output: tempRect5 }) : tempRect5.set(0, 0, width, height);
     return {
       canvasAndContext,
       frame
@@ -30705,9 +30726,8 @@ class Text extends AbstractText {
     bounds.maxY = bounds.minY + height;
   }
 }
+
 // node_modules/pixi.js/lib/index.mjs
-init_Point();
-init_Rectangle();
 init_ImageSource();
 init_Texture();
 init_textureFrom();
@@ -31080,12 +31100,14 @@ class BaseElement {
 // src/elements/TextElement.ts
 class TextElement extends BaseElement {
   pixiText;
+  charSprites = [];
   _text;
   _fontFamily;
   _fontSize;
   _fontWeight;
   _align;
   _color;
+  _arcPath = null;
   constructor(text, x2, y2, style) {
     super("text");
     this._text = text;
@@ -31094,20 +31116,20 @@ class TextElement extends BaseElement {
     this._fontWeight = style?.fontWeight ?? "normal";
     this._align = style?.align ?? "left";
     this._color = style?.color ?? 16777215;
-    this.pixiText = new Text({
-      text: this._text,
-      style: new TextStyle({
-        fontFamily: this._fontFamily,
-        fontSize: this._fontSize,
-        fontWeight: this._fontWeight,
-        fill: this._color,
-        align: this._align
-      })
-    });
+    this.pixiText = this.makeText(this._text);
     this.container.addChild(this.pixiText);
     this.x = x2;
     this.y = y2;
   }
+  get arcPath() {
+    return this._arcPath;
+  }
+  set arcPath(value) {
+    const old = this._arcPath;
+    this._arcPath = value;
+    this.redraw();
+    this.emitChange("arcPath", old, value);
+  }
   get text() {
     return this._text;
   }
@@ -31116,7 +31138,7 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._text = value;
-    this.pixiText.text = value;
+    this.redraw();
     this.emitChange("text", old, value);
   }
   get fontFamily() {
@@ -31127,7 +31149,9 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._fontFamily = value;
-    this.pixiText.style.fontFamily = value;
+    this.applyStyleToAll((s2) => {
+      s2.fontFamily = value;
+    });
     this.emitChange("fontFamily", old, value);
   }
   get fontSize() {
@@ -31138,7 +31162,9 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._fontSize = value;
-    this.pixiText.style.fontSize = value;
+    this.applyStyleToAll((s2) => {
+      s2.fontSize = value;
+    });
     this.emitChange("fontSize", old, value);
   }
   get fontWeight() {
@@ -31149,7 +31175,9 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._fontWeight = value;
-    this.pixiText.style.fontWeight = value;
+    this.applyStyleToAll((s2) => {
+      s2.fontWeight = value;
+    });
     this.emitChange("fontWeight", old, value);
   }
   get align() {
@@ -31160,7 +31188,8 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._align = value;
-    this.pixiText.style.align = value;
+    if (this.pixiText)
+      this.pixiText.style.align = value;
     this.emitChange("align", old, value);
   }
   get color() {
@@ -31171,30 +31200,95 @@ class TextElement extends BaseElement {
     if (old === value)
       return;
     this._color = value;
-    this.pixiText.style.fill = value;
+    this.applyStyleToAll((s2) => {
+      s2.fill = value;
+    });
     this.emitChange("color", old, value);
   }
   get width() {
-    return this.pixiText.width;
-  }
-  set width(value) {
-    const old = this.pixiText.width;
-    if (old === value)
-      return;
-    this.pixiText.width = value;
-    this.emitChange("width", old, value);
+    if (this._arcPath)
+      return this._arcPath.radius * 2;
+    return this.pixiText?.width ?? 0;
   }
+  set width(_value) {}
   get height() {
-    return this.pixiText.height;
+    if (this._arcPath)
+      return this._arcPath.radius * 2;
+    return this.pixiText?.height ?? 0;
   }
-  set height(value) {
-    const old = this.pixiText.height;
-    if (old === value)
+  set height(_value) {}
+  redraw() {
+    if (this._arcPath) {
+      this.drawArcText();
+    } else {
+      this.drawNormalText();
+    }
+  }
+  drawNormalText() {
+    for (const s2 of this.charSprites) {
+      this.container.removeChild(s2);
+      s2.destroy();
+    }
+    this.charSprites = [];
+    if (!this.pixiText) {
+      this.pixiText = this.makeText(this._text);
+      this.container.addChild(this.pixiText);
+    } else {
+      this.pixiText.text = this._text;
+      this.pixiText.visible = true;
+    }
+  }
+  drawArcText() {
+    const arc = this._arcPath;
+    if (this.pixiText) {
+      this.pixiText.visible = false;
+    }
+    for (const s2 of this.charSprites) {
+      this.container.removeChild(s2);
+      s2.destroy();
+    }
+    this.charSprites = [];
+    const chars = Array.from(this._text);
+    if (chars.length === 0)
       return;
-    this.pixiText.height = value;
-    this.emitChange("height", old, value);
+    const sprites = chars.map((ch) => this.makeText(ch));
+    const span = arc.endAngle - arc.startAngle;
+    const arcLength = Math.abs(arc.radius * span);
+    const totalWidth = sprites.reduce((sum, s2) => sum + s2.width, 0);
+    const spacingScale = arcLength > 0 ? arcLength / totalWidth : 1;
+    const flip = arc.side === "inside" ? Math.PI : 0;
+    const anchorY = arc.side === "outside" ? 1 : 0;
+    let angle = arc.startAngle;
+    for (const sprite of sprites) {
+      const halfAngular = sprite.width * spacingScale / 2 / arc.radius;
+      angle += halfAngular * Math.sign(span);
+      sprite.x = Math.cos(angle) * arc.radius;
+      sprite.y = Math.sin(angle) * arc.radius;
+      sprite.rotation = angle + Math.PI / 2 + flip;
+      sprite.anchor.set(0.5, anchorY);
+      this.container.addChild(sprite);
+      this.charSprites.push(sprite);
+      angle += halfAngular * Math.sign(span);
+    }
+  }
+  makeText(content) {
+    return new Text({
+      text: content,
+      style: new TextStyle({
+        fontFamily: this._fontFamily,
+        fontSize: this._fontSize,
+        fontWeight: this._fontWeight,
+        fill: this._color,
+        align: this._align
+      })
+    });
+  }
+  applyStyleToAll(mutate) {
+    if (this.pixiText)
+      mutate(this.pixiText.style);
+    for (const s2 of this.charSprites)
+      mutate(s2.style);
   }
-  redraw() {}
   toJSON() {
     return {
       ...super.toJSON(),
@@ -31203,7 +31297,8 @@ class TextElement extends BaseElement {
       fontSize: this._fontSize,
       fontWeight: this._fontWeight,
       align: this._align,
-      color: this._color
+      color: this._color,
+      arcPath: this._arcPath ?? undefined
     };
   }
   applyJSON(data) {
@@ -31219,6 +31314,8 @@ class TextElement extends BaseElement {
       this.align = data.align;
     if (data.color !== undefined)
       this.color = data.color;
+    if ("arcPath" in data)
+      this.arcPath = data.arcPath ?? null;
     this.x = data.x;
     this.y = data.y;
     this.rotation = data.rotation;
@@ -31235,6 +31332,8 @@ class TextElement extends BaseElement {
       align: data.align,
       color: data.color
     });
+    if (data.arcPath)
+      el.arcPath = data.arcPath;
     el.rotation = data.rotation;
     el.zIndex = data.zIndex;
     el.visible = data.visible;
@@ -31484,7 +31583,11 @@ class ShapeElement extends BaseElement {
     if (old === clamped)
       return;
     this._fillPercentage = clamped;
-    this.updateMask();
+    if (this._shapeType === "arc") {
+      this.redraw();
+    } else {
+      this.updateMask();
+    }
     this.emitChange("fillPercentage", old, clamped);
   }
   get fillDirection() {
@@ -31495,7 +31598,11 @@ class ShapeElement extends BaseElement {
     if (old === value)
       return;
     this._fillDirection = value;
-    this.updateMask();
+    if (this._shapeType === "arc") {
+      this.redraw();
+    } else {
+      this.updateMask();
+    }
     this.emitChange("fillDirection", old, value);
   }
   get strokeWidth() {
@@ -31596,9 +31703,34 @@ class ShapeElement extends BaseElement {
   redraw() {
     this.bgGraphics.clear();
     this.fgGraphics.clear();
-    this.drawShape(this.bgGraphics, this._backgroundColor);
-    this.drawShape(this.fgGraphics, this._foregroundColor);
-    this.updateMask();
+    if (this._shapeType === "arc") {
+      this.drawArc(this.bgGraphics, this._backgroundColor, 100);
+      this.drawArc(this.fgGraphics, this._foregroundColor, this._fillPercentage);
+      this.fillMask.update(this.getLocalBounds(), 100, this._fillDirection);
+    } else {
+      this.drawShape(this.bgGraphics, this._backgroundColor);
+      this.drawShape(this.fgGraphics, this._foregroundColor);
+      this.updateMask();
+    }
+  }
+  drawArc(g2, color, fillPct) {
+    const r2 = this._shapeParams["radius"];
+    const start = this._shapeParams["startAngle"];
+    const end = this._shapeParams["endAngle"];
+    const pct = clamp(fillPct, 0, 100) / 100;
+    const span = end - start;
+    let arcStart;
+    let arcEnd;
+    if (this._fillDirection === "right-to-left" || this._fillDirection === "bottom-to-top") {
+      arcStart = end - span * pct;
+      arcEnd = end;
+    } else {
+      arcStart = start;
+      arcEnd = start + span * pct;
+    }
+    if (pct === 0)
+      return;
+    g2.arc(0, 0, r2, arcStart, arcEnd).stroke({ color, width: this._strokeWidth, cap: this._lineCap });
   }
   drawShape(g2, color) {
     switch (this._shapeType) {
@@ -31621,13 +31753,6 @@ class ShapeElement extends BaseElement {
         g2.rect(0, 0, w2, h2).fill({ color });
         break;
       }
-      case "arc": {
-        const r2 = this._shapeParams["radius"];
-        const start = this._shapeParams["startAngle"];
-        const end = this._shapeParams["endAngle"];
-        g2.arc(0, 0, r2, start, end).stroke({ color, width: this._strokeWidth, cap: this._lineCap });
-        break;
-      }
     }
   }
   updateMask() {
@@ -31814,9 +31939,16 @@ class SelectionBox {
     this.rotateHandle = new TransformHandle("rotate");
     this.container.addChild(this.rotateHandle.graphics);
   }
-  show(bounds, config, showRotation) {
+  show(bounds, config, showRotation, transform) {
     this.container.visible = true;
     const { x: x2, y: y2, width: w2, height: h2 } = bounds;
+    if (transform) {
+      this.container.position.set(transform.x, transform.y);
+      this.container.rotation = transform.rotation;
+    } else {
+      this.container.position.set(0, 0);
+      this.container.rotation = 0;
+    }
     this.outline.clear();
     this.outline.rect(x2, y2, w2, h2).stroke({ color: config.color, width: 1 });
     const positions = [
@@ -32288,8 +32420,14 @@ class SelectionManager {
       this.selectionBox.hide();
       return;
     }
+    if (this.selected.size === 1) {
+      const el = this.getSelected()[0];
+      const b2 = el.getDisplayObject().getLocalBounds();
+      this.selectionBox.show({ x: b2.x, y: b2.y, width: b2.width, height: b2.height }, this.handleConfig, true, { x: el.x, y: el.y, rotation: el.rotation });
+      return;
+    }
     const bounds = this.computeCombinedBounds(this.getSelected());
-    this.selectionBox.show(bounds, this.handleConfig, this.selected.size === 1);
+    this.selectionBox.show(bounds, this.handleConfig, false);
   }
   computeCombinedBounds(elements) {
     let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
@@ -34341,6 +34479,105 @@ class ViewportPlugin {
     this._viewport.destroy();
   }
 }
+// src/plugins/AlignmentGuidesPlugin.ts
+var DEFAULTS3 = {
+  color: 16724838,
+  opacity: 0.85,
+  threshold: 0
+};
+
+class AlignmentGuidesPlugin {
+  name = "alignmentGuides";
+  engine;
+  graphics;
+  options;
+  unsubscribers = [];
+  constructor(options) {
+    this.options = { ...DEFAULTS3, ...options };
+  }
+  init(engine) {
+    this.engine = engine;
+    this.graphics = new Graphics;
+    this.graphics.alpha = this.options.opacity;
+    this.graphics.visible = false;
+    engine.app.stage.addChild(this.graphics);
+    const bus = engine.eventBus;
+    this.unsubscribers.push(bus.on("interaction:dragMove", ({ elements }) => {
+      this.drawGuides(elements);
+    }), bus.on("interaction:dragEnd", () => {
+      this.hide();
+    }), bus.on("interaction:resizeEnd", () => {
+      this.hide();
+    }), bus.on("interaction:rotateEnd", () => {
+      this.hide();
+    }));
+  }
+  hide() {
+    this.graphics.clear();
+    this.graphics.visible = false;
+  }
+  elementCenterInWorld(elements) {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const el of elements) {
+      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 { cx: (minX + maxX) / 2, cy: (minY + maxY) / 2 };
+  }
+  drawGuides(elements) {
+    if (elements.length === 0) {
+      this.hide();
+      return;
+    }
+    const { width, height } = this.engine.options;
+    const viewportPlugin = this.engine.plugins.get("viewport");
+    const viewport = viewportPlugin?.viewport;
+    const scale = viewport?.scale.x ?? 1;
+    const panX = viewport?.x ?? 0;
+    const panY = viewport?.y ?? 0;
+    const { x: ox, y: oy } = this.engine.originOffset;
+    const canvasCenterWorld = this.engine.options.coordinateOrigin === "center" ? { x: 0, y: 0 } : { x: width / 2, y: height / 2 };
+    const { cx, cy } = this.elementCenterInWorld(elements);
+    const diffX = Math.abs(cx - canvasCenterWorld.x);
+    const diffY = Math.abs(cy - canvasCenterWorld.y);
+    const showH = diffY <= this.options.threshold;
+    const showV = diffX <= this.options.threshold;
+    if (!showH && !showV) {
+      this.hide();
+      return;
+    }
+    this.graphics.clear();
+    this.graphics.visible = true;
+    const { color } = this.options;
+    const worldLeft = this.engine.options.coordinateOrigin === "center" ? -width / 2 : 0;
+    const worldRight = this.engine.options.coordinateOrigin === "center" ? width / 2 : width;
+    const worldTop = this.engine.options.coordinateOrigin === "center" ? -height / 2 : 0;
+    const worldBottom = this.engine.options.coordinateOrigin === "center" ? height / 2 : height;
+    const toScreenX = (wx) => panX + (wx + ox) * scale;
+    const toScreenY = (wy) => panY + (wy + oy) * scale;
+    if (showH) {
+      const screenY = toScreenY(canvasCenterWorld.y);
+      const screenLeft = toScreenX(worldLeft);
+      const screenRight = toScreenX(worldRight);
+      this.graphics.moveTo(screenLeft, screenY).lineTo(screenRight, screenY).stroke({ color, width: 1 });
+    }
+    if (showV) {
+      const screenX = toScreenX(canvasCenterWorld.x);
+      const screenTop = toScreenY(worldTop);
+      const screenBottom = toScreenY(worldBottom);
+      this.graphics.moveTo(screenX, screenTop).lineTo(screenX, screenBottom).stroke({ color, width: 1 });
+    }
+  }
+  destroy() {
+    this.unsubscribers.forEach((unsub) => unsub());
+    this.graphics.destroy();
+  }
+}
 export {
   ZOrderManager,
   WatchfaceEngine,
@@ -34359,5 +34596,6 @@ export {
   ElementRegistry,
   ElementManager,
   BaseElement,
-  AutosavePlugin
+  AutosavePlugin,
+  AlignmentGuidesPlugin
 };