@rb-games/core 0.1.1 → 0.1.2

package/dist/chunk-FOZO6TLY.js

@@ -0,0 +1,673 @@
+import { Point, Container, Rectangle } from 'pixi.js';
+
+// layout/Bounds.ts
+function rectToBoundsLike(r) {
+  const left = r.x;
+  const top = r.y;
+  const width = r.width;
+  const height = r.height;
+  const right = left + width;
+  const bottom = top + height;
+  return {
+    left,
+    right,
+    top,
+    bottom,
+    width,
+    height,
+    centerX: left + width / 2,
+    centerY: top + height / 2
+  };
+}
+function getCommonParent(items) {
+  var _a;
+  const parent = (_a = items[0]) == null ? void 0 : _a.parent;
+  if (!parent) throw new Error("Items must have a parent");
+  for (const it of items) {
+    if (it.parent !== parent) throw new Error("All items must share the same parent");
+  }
+  return parent;
+}
+function getLocalBoundsInParent(child, parent) {
+  const world = child.getBounds();
+  const topLeft = parent.toLocal(new Point(world.x, world.y));
+  const bottomRight = parent.toLocal(new Point(world.x + world.width, world.y + world.height));
+  const left = Math.min(topLeft.x, bottomRight.x);
+  const right = Math.max(topLeft.x, bottomRight.x);
+  const top = Math.min(topLeft.y, bottomRight.y);
+  const bottom = Math.max(topLeft.y, bottomRight.y);
+  const width = right - left;
+  const height = bottom - top;
+  return {
+    left,
+    right,
+    top,
+    bottom,
+    width,
+    height,
+    centerX: left + width / 2,
+    centerY: top + height / 2
+  };
+}
+function getSelectionBounds(items, parent) {
+  const p = parent ?? getCommonParent(items);
+  let left = Infinity, right = -Infinity, top = Infinity, bottom = -Infinity;
+  for (const it of items) {
+    const b = getLocalBoundsInParent(it, p);
+    left = Math.min(left, b.left);
+    right = Math.max(right, b.right);
+    top = Math.min(top, b.top);
+    bottom = Math.max(bottom, b.bottom);
+  }
+  const width = right - left;
+  const height = bottom - top;
+  return {
+    left,
+    right,
+    top,
+    bottom,
+    width,
+    height,
+    centerX: left + width / 2,
+    centerY: top + height / 2
+  };
+}
+function getReferenceBounds(items, options) {
+  if (options == null ? void 0 : options.container) {
+    const box = options.container;
+    if (box instanceof Container) {
+      const parent2 = box;
+      const world = parent2.getBounds();
+      const topLeft = parent2.toLocal(new Point(world.x, world.y));
+      const bottomRight = parent2.toLocal(new Point(world.x + world.width, world.y + world.height));
+      const left = Math.min(topLeft.x, bottomRight.x);
+      const right = Math.max(topLeft.x, bottomRight.x);
+      const top = Math.min(topLeft.y, bottomRight.y);
+      const bottom = Math.max(topLeft.y, bottomRight.y);
+      const width = right - left;
+      const height = bottom - top;
+      return {
+        ref: {
+          left,
+          right,
+          top,
+          bottom,
+          width,
+          height,
+          centerX: left + width / 2,
+          centerY: top + height / 2
+        },
+        parent: parent2
+      };
+    } else {
+      const parent2 = getCommonParent(items);
+      return { ref: rectToBoundsLike(box), parent: parent2 };
+    }
+  }
+  const parent = getCommonParent(items);
+  if (options == null ? void 0 : options.key) {
+    if (options.key.parent !== parent) throw new Error("key and items must share the same parent");
+    return { ref: getLocalBoundsInParent(options.key, parent), parent };
+  }
+  return { ref: getSelectionBounds(items, parent), parent };
+}
+function nudgeX(child, dx) {
+  child.x += dx;
+}
+function nudgeY(child, dy) {
+  child.y += dy;
+}
+
+// layout/Align.ts
+var Align = class {
+  /**
+   * Aligns containers to the left edge of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   *
+   * @example
+   * ```typescript
+   * // Align to selection bounds (default)
+   * Align.left([sprite1, sprite2, sprite3]);
+   *
+   * // Align to container
+   * Align.left([sprite1, sprite2], { container: bounds });
+   * ```
+   */
+  static left(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, ref.left - b.left);
+    }
+  }
+  /**
+   * Aligns containers to the horizontal center of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   *
+   * @example
+   * ```typescript
+   * // Center horizontally within selection
+   * Align.hCenter([sprite1, sprite2, sprite3]);
+   * ```
+   */
+  static hCenter(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, ref.centerX - b.centerX);
+    }
+  }
+  /**
+   * Aligns containers to the right edge of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   */
+  static right(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, ref.right - b.right);
+    }
+  }
+  /**
+   * Aligns containers to the top edge of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   */
+  static top(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, ref.top - b.top);
+    }
+  }
+  /**
+   * Aligns containers to the vertical center of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   */
+  static vCenter(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, ref.centerY - b.centerY);
+    }
+  }
+  /**
+   * Aligns containers to the bottom edge of the reference bounds.
+   *
+   * @param items - Array of containers to align
+   * @param options - Alignment options to control the reference point
+   */
+  static bottom(items, options) {
+    const { ref, parent } = getReferenceBounds(items, options);
+    for (const it of items) {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, ref.bottom - b.bottom);
+    }
+  }
+};
+var Distribute = class {
+  static hLeft(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).left - getLocalBoundsInParent(b, parent).left
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).left;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).left;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, first + step * i - b.left);
+    });
+  }
+  static hCenters(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).centerX - getLocalBoundsInParent(b, parent).centerX
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).centerX;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).centerX;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, first + step * i - b.centerX);
+    });
+  }
+  static hRight(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).right - getLocalBoundsInParent(b, parent).right
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).right;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).right;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, first + step * i - b.right);
+    });
+  }
+  static vTop(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).top - getLocalBoundsInParent(b, parent).top
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).top;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).top;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, first + step * i - b.top);
+    });
+  }
+  static vCenters(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).centerY - getLocalBoundsInParent(b, parent).centerY
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).centerY;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).centerY;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, first + step * i - b.centerY);
+    });
+  }
+  static vBottom(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).bottom - getLocalBoundsInParent(b, parent).bottom
+    );
+    if (sorted.length <= 2) return;
+    const first = getLocalBoundsInParent(sorted[0], parent).bottom;
+    const last = getLocalBoundsInParent(sorted[sorted.length - 1], parent).bottom;
+    const step = (last - first) / (sorted.length - 1);
+    sorted.forEach((it, i) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, first + step * i - b.bottom);
+    });
+  }
+  static hSpacing(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    if (items.length <= 2) return;
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).left - getLocalBoundsInParent(b, parent).left
+    );
+    const ref = (options == null ? void 0 : options.container) ?? getSelectionBounds(sorted, parent);
+    const totalWidth = sorted.reduce(
+      (sum, it) => sum + getLocalBoundsInParent(it, parent).width,
+      0
+    );
+    const width = ref instanceof Rectangle ? ref.width : ref.width;
+    const left = ref instanceof Rectangle ? ref.x : ref.left;
+    const gap = (width - totalWidth) / (sorted.length - 1);
+    let cursor = left;
+    sorted.forEach((it) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeX(it, cursor - b.left);
+      const newB = getLocalBoundsInParent(it, parent);
+      cursor = newB.right + gap;
+    });
+  }
+  static vSpacing(items, options) {
+    const parent = (options == null ? void 0 : options.parent) ?? getCommonParent(items);
+    if (items.length <= 2) return;
+    const sorted = [...items].sort(
+      (a, b) => getLocalBoundsInParent(a, parent).top - getLocalBoundsInParent(b, parent).top
+    );
+    const ref = (options == null ? void 0 : options.container) ?? getSelectionBounds(sorted, parent);
+    const totalHeight = sorted.reduce(
+      (sum, it) => sum + getLocalBoundsInParent(it, parent).height,
+      0
+    );
+    const height = ref instanceof Rectangle ? ref.height : ref.height;
+    const top = ref instanceof Rectangle ? ref.y : ref.top;
+    const gap = (height - totalHeight) / (sorted.length - 1);
+    let cursor = top;
+    sorted.forEach((it) => {
+      const b = getLocalBoundsInParent(it, parent);
+      nudgeY(it, cursor - b.top);
+      const newB = getLocalBoundsInParent(it, parent);
+      cursor = newB.bottom + gap;
+    });
+  }
+};
+function normalizeGap(opts) {
+  if (typeof opts.gap === "number") return { h: opts.gap, v: opts.gap };
+  if (typeof opts.gap === "object" && opts.gap) return { h: opts.gap.h ?? 0, v: opts.gap.v ?? 0 };
+  const h = opts.columnGap ?? 0;
+  const v = opts.rowGap ?? 0;
+  return { h, v };
+}
+function normalizePadding(p) {
+  if (typeof p === "number") return { top: p, right: p, bottom: p, left: p };
+  return { top: (p == null ? void 0 : p.top) ?? 0, right: (p == null ? void 0 : p.right) ?? 0, bottom: (p == null ? void 0 : p.bottom) ?? 0, left: (p == null ? void 0 : p.left) ?? 0 };
+}
+function normalizeMargin(value) {
+  if (value === void 0) {
+    return { top: 0, right: 0, bottom: 0, left: 0 };
+  }
+  if (typeof value === "number") {
+    return { top: value, right: value, bottom: value, left: value };
+  }
+  const top = value.top ?? value.y ?? 0;
+  const bottom = value.bottom ?? value.y ?? 0;
+  const left = value.left ?? value.x ?? 0;
+  const right = value.right ?? value.x ?? 0;
+  return { top, right, bottom, left };
+}
+function getFlowBounds(items, opts, parent) {
+  const pad = normalizePadding(opts.padding);
+  if (opts.wrap === "bounds" && opts.bounds) {
+    let r;
+    if (opts.bounds instanceof Rectangle) {
+      r = opts.bounds;
+    } else {
+      const b = getLocalBoundsInParent(opts.bounds, parent);
+      r = new Rectangle(b.left, b.top, b.width, b.height);
+    }
+    return new Rectangle(
+      r.x + pad.left,
+      r.y + pad.top,
+      Math.max(0, r.width - pad.left - pad.right),
+      Math.max(0, r.height - pad.top - pad.bottom)
+    );
+  }
+  const sel = getSelectionBounds(items, parent);
+  return new Rectangle(
+    // TODO Not sure side effects check this out latter
+    /*sel.left +*/
+    pad.left,
+    /*sel.top + */
+    pad.top,
+    Math.max(0, sel.width - pad.left - pad.right),
+    Math.max(0, sel.height - pad.top - pad.bottom)
+  );
+}
+var Flow = class {
+  /**
+   * Arranges containers in a flexbox-like layout.
+   *
+   * This method modifies container positions in-place to create the desired layout.
+   * Items are sorted (if order function provided) and then arranged according to
+   * direction, wrapping, alignment, and justification settings.
+   *
+   * @param items - Array of containers to layout
+   * @param options - Layout configuration options
+   *
+   * @example
+   * ```typescript
+   * // Simple horizontal row
+   * Flow.layout(items, { direction: 'row', gap: 10 });
+   *
+   * // Grid with 4 columns
+   * Flow.layout(items, {
+   *   direction: 'row',
+   *   wrap: 'count',
+   *   columnCount: 4,
+   *   gap: { h: 10, v: 15 }
+   * });
+   *
+   * // Centered vertical list
+   * Flow.layout(items, {
+   *   direction: 'column',
+   *   align: 'center',
+   *   gap: 20
+   * });
+   * ```
+   */
+  static layout(items, options) {
+    if (!items || items.length === 0) return;
+    const opts = {
+      direction: "row",
+      wrap: "none",
+      gap: 0,
+      justify: "start",
+      align: "start",
+      ...options
+    };
+    const parent = getCommonParent(items);
+    const gap = normalizeGap(opts);
+    const dir = opts.direction ?? "row";
+    const wrap = opts.wrap ?? "none";
+    const ordered = opts.order ? [...items].sort(opts.order) : [...items];
+    const area = getFlowBounds(ordered, opts, parent);
+    if (wrap === "count") {
+      if (dir === "row") {
+        const cols = opts.columnCount ?? (opts.rowCount ? Math.ceil(ordered.length / opts.rowCount) : ordered.length);
+        const lines = [];
+        for (let i = 0; i < ordered.length; i += cols) lines.push(ordered.slice(i, i + cols));
+        layoutLinesRow(lines, parent, area, gap, opts.justify, opts.align, opts.margins);
+      } else {
+        const rows = opts.rowCount ?? (opts.columnCount ? Math.ceil(ordered.length / opts.columnCount) : ordered.length);
+        const columns = [];
+        for (let i = 0; i < ordered.length; i += rows) columns.push(ordered.slice(i, i + rows));
+        layoutLinesColumn(columns, parent, area, gap, opts.justify, opts.align, opts.margins);
+      }
+      return;
+    }
+    if (wrap === "bounds") {
+      if (dir === "row") {
+        const lines = [];
+        let line = [];
+        let lineW = 0;
+        for (const it of ordered) {
+          const b = getLocalBoundsInParent(it, parent);
+          const needed = line.length === 0 ? b.width : gap.h + b.width;
+          if (line.length > 0 && lineW + needed > area.width) {
+            lines.push(line);
+            line = [it];
+            lineW = b.width;
+          } else {
+            line.push(it);
+            lineW += needed;
+          }
+        }
+        if (line.length) lines.push(line);
+        layoutLinesRow(lines, parent, area, gap, opts.justify, opts.align, opts.margins);
+      } else {
+        const columns = [];
+        let col = [];
+        let colH = 0;
+        for (const it of ordered) {
+          const b = getLocalBoundsInParent(it, parent);
+          const needed = col.length === 0 ? b.height : gap.v + b.height;
+          if (col.length > 0 && colH + needed > area.height) {
+            columns.push(col);
+            col = [it];
+            colH = b.height;
+          } else {
+            col.push(it);
+            colH += needed;
+          }
+        }
+        if (col.length) columns.push(col);
+        layoutLinesColumn(columns, parent, area, gap, opts.justify, opts.align, opts.margins);
+      }
+      return;
+    }
+    if (wrap === "none") {
+      if (dir === "row") {
+        const lines = [ordered];
+        layoutLinesRow(lines, parent, area, gap, opts.justify, opts.align, opts.margins);
+      } else {
+        const columns = [ordered];
+        layoutLinesColumn(columns, parent, area, gap, opts.justify, opts.align, opts.margins);
+      }
+    }
+  }
+};
+function layoutLinesRow(lines, parent, area, gap, justify, align, margins) {
+  let y = area.y;
+  for (const line of lines) {
+    let contentW = 0;
+    let lineH = 0;
+    const sizes = line.map((it) => {
+      const b = getLocalBoundsInParent(it, parent);
+      lineH = Math.max(lineH, b.height);
+      return b;
+    });
+    if (line.length > 0) contentW = sizes.reduce((s, b, i) => s + b.width + (i > 0 ? gap.h : 0), 0);
+    let x = area.x;
+    if (justify === "center") {
+      x += Math.max(0, (area.width - contentW) / 2);
+    } else if (justify === "end") {
+      x += Math.max(0, area.width - contentW);
+    } else if (justify === "space-between" && line.length > 1) {
+      const free = Math.max(0, area.width - sizes.reduce((s, b) => s + b.width, 0));
+      const g = free / (line.length - 1);
+      positionRow(line, sizes, parent, x, y, lineH, { h: g, v: gap.v }, align, margins);
+      y += lineH + gap.v;
+      continue;
+    } else if (justify === "space-around" && line.length > 0) {
+      const free = Math.max(0, area.width - sizes.reduce((s, b) => s + b.width, 0));
+      const g = free / line.length;
+      x += g / 2;
+      positionRow(line, sizes, parent, x, y, lineH, { h: g, v: gap.v }, align, margins);
+      y += lineH + gap.v;
+      continue;
+    } else if (justify === "space-evenly" && line.length > 0) {
+      const free = Math.max(0, area.width - sizes.reduce((s, b) => s + b.width, 0));
+      const g = free / (line.length + 1);
+      x += g;
+      positionRow(line, sizes, parent, x, y, lineH, { h: g, v: gap.v }, align, margins);
+      y += lineH + gap.v;
+      continue;
+    }
+    positionRow(line, sizes, parent, x, y, lineH, gap, align, margins);
+    y += lineH + gap.v;
+  }
+}
+function positionRow(line, sizes, parent, x, y, lineH, gap, align, margins) {
+  let cursor = x;
+  for (let i = 0; i < line.length; i++) {
+    const it = line[i];
+    const b = sizes[i];
+    const margin = normalizeMargin(margins == null ? void 0 : margins[i]);
+    const dx = cursor + margin.left - b.left;
+    let dy = 0;
+    if (align === "start") dy = y + margin.top - b.top;
+    else if (align === "center") dy = y + margin.top + (lineH - b.height) / 2 - b.top;
+    else dy = y + margin.top + (lineH - b.height) - b.top;
+    nudgeX(it, dx);
+    nudgeY(it, dy);
+    cursor += margin.left + b.width + margin.right + gap.h;
+  }
+}
+function layoutLinesColumn(columns, parent, area, gap, justify, align, margins) {
+  let x = area.x;
+  for (const col of columns) {
+    let contentH = 0;
+    let colW = 0;
+    const sizes = col.map((it) => {
+      const b = getLocalBoundsInParent(it, parent);
+      colW = Math.max(colW, b.width);
+      return b;
+    });
+    if (col.length > 0) contentH = sizes.reduce((s, b, i) => s + b.height + (i > 0 ? gap.v : 0), 0);
+    let y = area.y;
+    if (justify === "center") {
+      y += Math.max(0, (area.height - contentH) / 2);
+    } else if (justify === "end") {
+      y += Math.max(0, area.height - contentH);
+    } else if (justify === "space-between" && col.length > 1) {
+      const free = Math.max(0, area.height - sizes.reduce((s, b) => s + b.height, 0));
+      const g = free / (col.length - 1);
+      positionColumn(col, sizes, parent, x, y, colW, { h: gap.h, v: g }, align, margins);
+      x += colW + gap.h;
+      continue;
+    } else if (justify === "space-around" && col.length > 0) {
+      const free = Math.max(0, area.height - sizes.reduce((s, b) => s + b.height, 0));
+      const g = free / col.length;
+      y += g / 2;
+      positionColumn(col, sizes, parent, x, y, colW, { h: gap.h, v: g }, align, margins);
+      x += colW + gap.h;
+      continue;
+    } else if (justify === "space-evenly" && col.length > 0) {
+      const free = Math.max(0, area.height - sizes.reduce((s, b) => s + b.height, 0));
+      const g = free / (col.length + 1);
+      y += g;
+      positionColumn(col, sizes, parent, x, y, colW, { h: gap.h, v: g }, align, margins);
+      x += colW + gap.h;
+      continue;
+    }
+    positionColumn(col, sizes, parent, x, y, colW, gap, align, margins);
+    x += colW + gap.h;
+  }
+}
+function positionColumn(col, sizes, parent, x, y, colW, gap, align, margins) {
+  let cursor = y;
+  for (let i = 0; i < col.length; i++) {
+    const it = col[i];
+    const b = sizes[i];
+    const margin = normalizeMargin(margins == null ? void 0 : margins[i]);
+    let dx = 0;
+    if (align === "start") dx = x + margin.left - b.left;
+    else if (align === "center") dx = x + margin.left + (colW - b.width) / 2 - b.left;
+    else dx = x + margin.left + (colW - b.width) - b.left;
+    const dy = cursor + margin.top - b.top;
+    nudgeX(it, dx);
+    nudgeY(it, dy);
+    cursor += margin.top + b.height + margin.bottom + gap.v;
+  }
+}
+
+// layout/PositionUtils.ts
+function resolvePositionValue(value, axis, viewportSize, sourceScaledSize) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (trimmed.endsWith("%")) {
+    const percent = parseFloat(trimmed) / 100;
+    return viewportSize * percent - sourceScaledSize * percent;
+  }
+  switch (trimmed) {
+    case "center":
+      return (viewportSize - sourceScaledSize) / 2;
+    case "top":
+      return axis === "y" ? 0 : (viewportSize - sourceScaledSize) / 2;
+    case "bottom":
+      return axis === "y" ? viewportSize - sourceScaledSize : (viewportSize - sourceScaledSize) / 2;
+    case "left":
+      return axis === "x" ? 0 : (viewportSize - sourceScaledSize) / 2;
+    case "right":
+      return axis === "x" ? viewportSize - sourceScaledSize : (viewportSize - sourceScaledSize) / 2;
+    default:
+      const num = parseFloat(trimmed);
+      return isNaN(num) ? 0 : num;
+  }
+}
+function resolvePosition(position, viewportWidth, viewportHeight, sourceScaledWidth, sourceScaledHeight) {
+  if (typeof position === "number") {
+    return { x: position, y: position };
+  }
+  const parts = position.trim().split(/\s+/);
+  if (parts.length === 1) {
+    const val = parts[0];
+    return {
+      x: resolvePositionValue(val, "x", viewportWidth, sourceScaledWidth),
+      y: resolvePositionValue(val, "y", viewportHeight, sourceScaledHeight)
+    };
+  }
+  return {
+    x: resolvePositionValue(parts[0], "x", viewportWidth, sourceScaledWidth),
+    y: resolvePositionValue(parts[1], "y", viewportHeight, sourceScaledHeight)
+  };
+}
+
+export { Align, Distribute, Flow, getCommonParent, getLocalBoundsInParent, getReferenceBounds, getSelectionBounds, nudgeX, nudgeY, resolvePosition, resolvePositionValue };
+//# sourceMappingURL=chunk-FOZO6TLY.js.map
+//# sourceMappingURL=chunk-FOZO6TLY.js.map