ooxml-core 0.21.2 → 0.22.0

package/dist/docx/index.cjs

@@ -1787,7 +1787,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(

package/dist/docx/index.mjs

@@ -1781,7 +1781,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(

package/dist/docx/load/index.cjs

@@ -2110,7 +2110,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(

package/dist/docx/load/index.mjs

@@ -2104,7 +2104,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(

package/dist/geometry/align-distribute.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Pure geometry helpers for the align / distribute editor operations.
+ *
+ * These functions operate over a list of slide elements (anything carrying the
+ * `{ id, x, y, width, height }` bounding-box fields of {@link PptxElement}) and
+ * return a `Map` keyed by element `id` describing the *new* position(s) for the
+ * elements that need to move. Elements that already sit on the target edge (or
+ * the two outer-most elements during distribution) are still included with
+ * their unchanged coordinate so callers can apply the whole map uniformly; the
+ * map only ever contains the axis that the operation touches.
+ *
+ * The reference box the selection is aligned against is either the union of
+ * the selected boxes (PowerPoint's "Align Selected Objects") or the slide
+ * itself ("Align to Slide"). PowerPoint defaults to the slide whenever a
+ * single object is selected, which is why a one-element selection is not a
+ * no-op once a `slideSize` is supplied: Align Center on a lone title is one
+ * of the commonest arrange gestures there is.
+ *
+ * The helpers are deliberately framework-agnostic: no DOM, no Vue reactivity,
+ * no side effects. The host wires them into the editor by feeding the current
+ * selection in and applying the returned `Map` via its element-transform
+ * operation (one batched history entry per call).
+ */
+/** Edge / centre that {@link alignElements} can snap a selection to. */
+export type AlignEdge = 'left' | 'centerH' | 'right' | 'top' | 'middle' | 'bottom';
+/** Axis along which {@link distributeElements} evenly spaces a selection. */
+export type DistributeAxis = 'horizontal' | 'vertical';
+/**
+ * What a selection is aligned / distributed against.
+ *
+ * - `'selection'`: the union bounding box of the selected elements
+ *   (PowerPoint's "Align Selected Objects"). Needs at least two elements.
+ * - `'slide'`: the slide bounds (`0, 0, slideSize.width, slideSize.height`),
+ *   PowerPoint's "Align to Slide". Works for any non-empty selection.
+ */
+export type AlignReference = 'selection' | 'slide';
+/** Slide dimensions in the same (pixel) units as the element boxes. */
+export interface AlignSlideSize {
+    width: number;
+    height: number;
+}
+/** Optional reference selection for {@link alignElements} and friends. */
+export interface AlignOptions {
+    /**
+     * Explicit reference. When omitted, `'slide'` is assumed for a single
+     * element (PowerPoint's default) and `'selection'` otherwise. Either way
+     * the slide is only used when `slideSize` is supplied.
+     */
+    reference?: AlignReference;
+    /** Slide bounds; required for the slide to act as the reference. */
+    slideSize?: AlignSlideSize;
+}
+/** New position for a single element. Only the affected axis is populated. */
+export interface ElementPosition {
+    x?: number;
+    y?: number;
+}
+/**
+ * The minimal bounding-box shape the helpers need. {@link PptxElement} already
+ * satisfies this, but accepting the structural subset keeps the helpers usable
+ * (and testable) with plain geometry objects too.
+ */
+export interface BoundingBoxElement {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** An axis-aligned reference rectangle. */
+export interface AlignReferenceBox {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+/**
+ * Decide whether the slide (rather than the selection) is the reference for a
+ * given selection + options. The slide is chosen when asked for explicitly or
+ * when only one element is selected, but only when its size is known.
+ */
+export declare function usesSlideReference(elementCount: number, options: AlignOptions | undefined): options is AlignOptions & {
+    slideSize: AlignSlideSize;
+};
+/**
+ * The rectangle a selection is aligned against, or `null` when there is
+ * nothing to align to (an empty selection, or a lone element with no slide
+ * size to fall back on).
+ */
+export declare function resolveAlignReferenceBox(elements: readonly BoundingBoxElement[], options?: AlignOptions): AlignReferenceBox | null;
+/**
+ * Align every element in the selection to a shared edge (or centre line) of
+ * the reference box (see {@link resolveAlignReferenceBox}).
+ *
+ * - `left` / `right` / `centerH` move elements horizontally (set `x`).
+ * - `top` / `bottom` / `middle` move elements vertically (set `y`).
+ *
+ * Without a `slideSize` the behaviour is unchanged from before the option
+ * existed: the reference is the selection's union box and fewer than two
+ * elements yields an empty map.
+ *
+ * @param elements - The selected elements.
+ * @param edge - The edge / centre line to align to.
+ * @param options - Reference selection; see {@link AlignOptions}.
+ * @returns A `Map<id, {x?, y?}>` of new positions (only the touched axis set).
+ */
+export declare function alignElements(elements: readonly BoundingBoxElement[], edge: AlignEdge, options?: AlignOptions): Map<string, ElementPosition>;
+/**
+ * Distribute a selection so the gaps between adjacent elements are equal.
+ *
+ * Elements are ordered by their leading edge on the chosen axis. Against the
+ * selection, the two outer-most elements are pinned and the free space (span
+ * minus the sum of element sizes) is divided evenly into the gaps between
+ * consecutive elements; this needs at least three elements (two outer + one
+ * interior to move). Against the slide (`'slide'` reference, or a single
+ * element with a `slideSize`), the span is the whole slide and the free space
+ * is divided into `n + 1` equal gaps so the margins to both slide edges match
+ * the gaps between elements, as PowerPoint's "Align to Slide" distribution
+ * does; any non-empty selection qualifies.
+ *
+ * @param elements - The selected elements.
+ * @param axis - `'horizontal'` distributes along `x`; `'vertical'` along `y`.
+ * @param options - Reference selection; see {@link AlignOptions}.
+ * @returns A `Map<id, {x?, y?}>` of new positions (only the touched axis set).
+ */
+export declare function distributeElements(elements: readonly BoundingBoxElement[], axis: DistributeAxis, options?: AlignOptions): Map<string, ElementPosition>;
+/** Alias of {@link AlignEdge}. */
+export type AlignMode = AlignEdge;
+/** Alias of {@link DistributeAxis}. */
+export type DistributeMode = DistributeAxis;
+/** Alias of {@link BoundingBoxElement}. */
+export type AlignBox = BoundingBoxElement;
+/** Alias of {@link ElementPosition}. */
+export type PositionUpdate = ElementPosition;
+/**
+ * {@link alignElements} (slide reference included) filtered to the boxes that
+ * actually move.
+ */
+export declare function computeAlign(boxes: readonly AlignBox[], mode: AlignMode, options?: AlignOptions): Map<string, PositionUpdate>;
+/**
+ * {@link distributeElements} (slide reference included) filtered to the boxes
+ * that actually move.
+ */
+export declare function computeDistribute(boxes: readonly AlignBox[], mode: DistributeMode, options?: AlignOptions): Map<string, PositionUpdate>;
+//# sourceMappingURL=align-distribute.d.ts.map

package/dist/geometry/align-distribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"align-distribute.d.ts","sourceRoot":"","sources":["../../geometry/align-distribute.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,wEAAwE;AACxE,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEnF,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,UAAU,CAAC;AAEvD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,OAAO,CAAC;AAEnD,uEAAuE;AACvE,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC5B;;;;OAIG;IACH,SAAS,CAAC,EAAE,cAAc,CAAC;IAC3B,oEAAoE;IACpE,SAAS,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC/B,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,2CAA2C;AAC3C,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,YAAY,GAAG,SAAS,GAC/B,OAAO,IAAI,YAAY,GAAG;IAAE,SAAS,EAAE,cAAc,CAAA;CAAE,CAKzD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,OAAO,CAAC,EAAE,YAAY,GACpB,iBAAiB,GAAG,IAAI,CAgB1B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAC5B,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,IAAI,EAAE,SAAS,EACf,OAAO,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAkC9B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,eAAe,CAAC,CAkC9B;AASD,kCAAkC;AAClC,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC;AAClC,uCAAuC;AACvC,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAC5C,2CAA2C;AAC3C,MAAM,MAAM,QAAQ,GAAG,kBAAkB,CAAC;AAC1C,wCAAwC;AACxC,MAAM,MAAM,cAAc,GAAG,eAAe,CAAC;AAuB7C;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,IAAI,EAAE,SAAS,EACf,OAAO,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAE7B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,IAAI,EAAE,cAAc,EACpB,OAAO,CAAC,EAAE,YAAY,GACpB,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAE7B"}

package/dist/geometry/index.cjs

@@ -15087,6 +15087,312 @@ function flattenSvgPath(d, curveSegments = 16) {
   return loops;
 }
 
+// geometry/snap-guides.ts
+var SNAP_THRESHOLD = 6;
+function computeSnapToShape(dragX, dragY, dragW, dragH, siblings, draggedIds, guides, threshold = SNAP_THRESHOLD) {
+  let bestDx = Infinity;
+  let bestDy = Infinity;
+  let snapX = dragX;
+  let snapY = dragY;
+  const lines = [];
+  const dragCx = dragX + dragW / 2;
+  const dragCy = dragY + dragH / 2;
+  const dragRight = dragX + dragW;
+  const dragBottom = dragY + dragH;
+  const hRefs = [dragX, dragCx, dragRight];
+  const vRefs = [dragY, dragCy, dragBottom];
+  for (const sib of siblings) {
+    if (draggedIds.has(sib.id)) {
+      continue;
+    }
+    const sibCx = sib.x + sib.width / 2;
+    const sibCy = sib.y + sib.height / 2;
+    const sibRight = sib.x + sib.width;
+    const sibBottom = sib.y + sib.height;
+    for (const ref of [sib.x, sibCx, sibRight]) {
+      for (const hr of hRefs) {
+        const dx = Math.abs(ref - hr);
+        if (dx < threshold && dx < bestDx) {
+          bestDx = dx;
+          snapX = dragX + (ref - hr);
+        }
+      }
+    }
+    for (const ref of [sib.y, sibCy, sibBottom]) {
+      for (const vr of vRefs) {
+        const dy = Math.abs(ref - vr);
+        if (dy < threshold && dy < bestDy) {
+          bestDy = dy;
+          snapY = dragY + (ref - vr);
+        }
+      }
+    }
+  }
+  for (const guide of guides) {
+    if (guide.axis === "v") {
+      for (const hr of hRefs) {
+        const dx = Math.abs(guide.position - hr);
+        if (dx < threshold && dx < bestDx) {
+          bestDx = dx;
+          snapX = dragX + (guide.position - hr);
+        }
+      }
+    } else {
+      for (const vr of vRefs) {
+        const dy = Math.abs(guide.position - vr);
+        if (dy < threshold && dy < bestDy) {
+          bestDy = dy;
+          snapY = dragY + (guide.position - vr);
+        }
+      }
+    }
+  }
+  if (bestDx < threshold) {
+    const snappedCx = snapX + dragW / 2;
+    const snappedRight = snapX + dragW;
+    for (const sib of siblings) {
+      if (draggedIds.has(sib.id)) {
+        continue;
+      }
+      for (const ref of [sib.x, sib.x + sib.width / 2, sib.x + sib.width]) {
+        if (Math.abs(ref - snapX) < 1 || Math.abs(ref - snappedCx) < 1 || Math.abs(ref - snappedRight) < 1) {
+          lines.push({ axis: "v", position: ref });
+        }
+      }
+    }
+    for (const g of guides) {
+      if (g.axis === "v" && (Math.abs(g.position - snapX) < 1 || Math.abs(g.position - snappedCx) < 1 || Math.abs(g.position - snappedRight) < 1)) {
+        lines.push({ axis: "v", position: g.position });
+      }
+    }
+  }
+  if (bestDy < threshold) {
+    const snappedCy = snapY + dragH / 2;
+    const snappedBottom = snapY + dragH;
+    for (const sib of siblings) {
+      if (draggedIds.has(sib.id)) {
+        continue;
+      }
+      for (const ref of [sib.y, sib.y + sib.height / 2, sib.y + sib.height]) {
+        if (Math.abs(ref - snapY) < 1 || Math.abs(ref - snappedCy) < 1 || Math.abs(ref - snappedBottom) < 1) {
+          lines.push({ axis: "h", position: ref });
+        }
+      }
+    }
+    for (const g of guides) {
+      if (g.axis === "h" && (Math.abs(g.position - snapY) < 1 || Math.abs(g.position - snappedCy) < 1 || Math.abs(g.position - snappedBottom) < 1)) {
+        lines.push({ axis: "h", position: g.position });
+      }
+    }
+  }
+  return { x: snapX, y: snapY, lines };
+}
+function xCandidates(box) {
+  return {
+    leading: box.x,
+    centre: box.x + box.width / 2,
+    trailing: box.x + box.width
+  };
+}
+function yCandidates(box) {
+  return {
+    leading: box.y,
+    centre: box.y + box.height / 2,
+    trailing: box.y + box.height
+  };
+}
+function findSnapHit(movingValues, others, axisCandidates, threshold) {
+  let best = null;
+  let bestDist = threshold + 1;
+  for (const other of others) {
+    const target = axisCandidates(other);
+    const targetValues = [target.leading, target.centre, target.trailing];
+    for (const mv of movingValues) {
+      for (const tv of targetValues) {
+        const dist = mv > tv ? mv - tv : tv - mv;
+        if (dist <= threshold && dist < bestDist) {
+          bestDist = dist;
+          best = { delta: tv - mv, matchedLine: tv, otherBox: other };
+        }
+      }
+    }
+  }
+  return best;
+}
+function unionExtent(aStart, aEnd, bStart, bEnd) {
+  const start = aStart < bStart ? aStart : bStart;
+  const end = aEnd > bEnd ? aEnd : bEnd;
+  return { start, end };
+}
+function computeSnap(box, others, threshold) {
+  const guides = [];
+  let snappedX = box.x;
+  let snappedY = box.y;
+  const xMoving = xCandidates(box);
+  const hitX = findSnapHit(
+    [xMoving.leading, xMoving.centre, xMoving.trailing],
+    others,
+    xCandidates,
+    threshold
+  );
+  if (hitX !== null) {
+    snappedX = box.x + hitX.delta;
+    const { start, end } = unionExtent(
+      box.y,
+      box.y + box.height,
+      hitX.otherBox.y,
+      hitX.otherBox.y + hitX.otherBox.height
+    );
+    guides.push({ axis: "x", pos: hitX.matchedLine, start, end });
+  }
+  const yMoving = yCandidates(box);
+  const hitY = findSnapHit(
+    [yMoving.leading, yMoving.centre, yMoving.trailing],
+    others,
+    yCandidates,
+    threshold
+  );
+  if (hitY !== null) {
+    snappedY = box.y + hitY.delta;
+    const { start, end } = unionExtent(
+      snappedX,
+      snappedX + box.width,
+      hitY.otherBox.x,
+      hitY.otherBox.x + hitY.otherBox.width
+    );
+    guides.push({ axis: "y", pos: hitY.matchedLine, start, end });
+  }
+  return { x: snappedX, y: snappedY, guides };
+}
+function snapToGridStep(value, step) {
+  if (step <= 0) {
+    return value;
+  }
+  return Math.round(value / step) * step || 0;
+}
+function snapValue(value, size) {
+  return Math.round(value / size) * size;
+}
+function snapBox(box, size) {
+  return {
+    x: snapValue(box.x, size),
+    y: snapValue(box.y, size),
+    width: Math.max(size, snapValue(box.width, size)),
+    height: Math.max(size, snapValue(box.height, size))
+  };
+}
+
+// geometry/align-distribute.ts
+function usesSlideReference(elementCount, options) {
+  if (!options?.slideSize) {
+    return false;
+  }
+  return options.reference === "slide" || options.reference === void 0 && elementCount === 1;
+}
+function resolveAlignReferenceBox(elements, options) {
+  if (elements.length === 0) {
+    return null;
+  }
+  if (usesSlideReference(elements.length, options)) {
+    return { minX: 0, minY: 0, maxX: options.slideSize.width, maxY: options.slideSize.height };
+  }
+  if (elements.length < 2) {
+    return null;
+  }
+  return {
+    minX: Math.min(...elements.map((e) => e.x)),
+    minY: Math.min(...elements.map((e) => e.y)),
+    maxX: Math.max(...elements.map((e) => e.x + e.width)),
+    maxY: Math.max(...elements.map((e) => e.y + e.height))
+  };
+}
+function alignElements(elements, edge, options) {
+  const result = /* @__PURE__ */ new Map();
+  const ref = resolveAlignReferenceBox(elements, options);
+  if (!ref) {
+    return result;
+  }
+  const { minX, minY, maxX, maxY } = ref;
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  for (const el of elements) {
+    switch (edge) {
+      case "left":
+        result.set(el.id, { x: minX });
+        break;
+      case "right":
+        result.set(el.id, { x: maxX - el.width });
+        break;
+      case "centerH":
+        result.set(el.id, { x: centerX - el.width / 2 });
+        break;
+      case "top":
+        result.set(el.id, { y: minY });
+        break;
+      case "bottom":
+        result.set(el.id, { y: maxY - el.height });
+        break;
+      case "middle":
+        result.set(el.id, { y: centerY - el.height / 2 });
+        break;
+    }
+  }
+  return result;
+}
+function distributeElements(elements, axis, options) {
+  const result = /* @__PURE__ */ new Map();
+  const horizontal = axis === "horizontal";
+  const start = (e) => horizontal ? e.x : e.y;
+  const size = (e) => horizontal ? e.width : e.height;
+  const sorted = [...elements].sort((a, b) => start(a) - start(b));
+  const totalSize = sorted.reduce((sum, e) => sum + size(e), 0);
+  let cursor;
+  let gap;
+  if (usesSlideReference(elements.length, options)) {
+    if (sorted.length === 0) {
+      return result;
+    }
+    const span = horizontal ? options.slideSize.width : options.slideSize.height;
+    gap = (span - totalSize) / (sorted.length + 1);
+    cursor = gap;
+  } else {
+    if (sorted.length < 3) {
+      return result;
+    }
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    const span = start(last) + size(last) - start(first);
+    gap = (span - totalSize) / (sorted.length - 1);
+    cursor = start(first);
+  }
+  for (const el of sorted) {
+    result.set(el.id, horizontal ? { x: cursor } : { y: cursor });
+    cursor += size(el) + gap;
+  }
+  return result;
+}
+function onlyMoved(boxes, positions) {
+  const byId = new Map(boxes.map((box) => [box.id, box]));
+  const result = /* @__PURE__ */ new Map();
+  for (const [id, pos] of positions) {
+    const box = byId.get(id);
+    if (!box) {
+      continue;
+    }
+    const moved = pos.x !== void 0 && pos.x !== box.x || pos.y !== void 0 && pos.y !== box.y;
+    if (moved) {
+      result.set(id, pos);
+    }
+  }
+  return result;
+}
+function computeAlign(boxes, mode, options) {
+  return onlyMoved(boxes, alignElements(boxes, mode, options));
+}
+function computeDistribute(boxes, mode, options) {
+  return onlyMoved(boxes, distributeElements(boxes, mode, options));
+}
+
 exports.ACTION_BUTTON_CONNECTION_SITES = ACTION_BUTTON_CONNECTION_SITES;
 exports.ACTION_BUTTON_PRESET_DEFINITIONS = ACTION_BUTTON_PRESET_DEFINITIONS;
 exports.ACTION_BUTTON_TEXT_RECTS = ACTION_BUTTON_TEXT_RECTS;
@@ -15146,6 +15452,7 @@ exports.REFINED_ARROW_PRESET_DEFINITIONS = REFINED_ARROW_PRESET_DEFINITIONS;
 exports.RIBBON_CONNECTION_SITES = RIBBON_CONNECTION_SITES;
 exports.RIBBON_TEXT_RECTS = RIBBON_TEXT_RECTS;
 exports.SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS = SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS;
+exports.SNAP_THRESHOLD = SNAP_THRESHOLD;
 exports.STAR_CONNECTION_SITES = STAR_CONNECTION_SITES;
 exports.STAR_TEXT_RECTS = STAR_TEXT_RECTS;
 exports.ST_SHAPE_TYPE_VALUES = ST_SHAPE_TYPE_VALUES;
@@ -15153,17 +15460,23 @@ exports.TABS_DECORATIONS_PRESET_DEFINITIONS = TABS_DECORATIONS_PRESET_DEFINITION
 exports.TAB_CONNECTION_SITES = TAB_CONNECTION_SITES;
 exports.TAB_TEXT_RECTS = TAB_TEXT_RECTS;
 exports._internalForTests = _internalForTests;
+exports.alignElements = alignElements;
 exports.angleToRadians = angleToRadians;
 exports.at = at;
 exports.buildCalloutLeaderLineSvgPath = buildCalloutLeaderLineSvgPath;
 exports.clipPolygons = clipPolygons;
 exports.combineShapes = combineShapes;
+exports.computeAlign = computeAlign;
+exports.computeDistribute = computeDistribute;
+exports.computeSnap = computeSnap;
+exports.computeSnapToShape = computeSnapToShape;
 exports.computeUnionWalk = computeUnionWalk;
 exports.convexHull = convexHull;
 exports.createBuiltinVariables = createBuiltinVariables;
 exports.cross2 = cross2;
 exports.cxn = cxn;
 exports.dedupPoly = dedupPoly;
+exports.distributeElements = distributeElements;
 exports.elbowCurveSegments = elbowCurveSegments;
 exports.elbowWaypoints = elbowWaypoints;
 exports.ensureCCW = ensureCCW;
@@ -15207,10 +15520,14 @@ exports.pointInPolygon = pointInPolygon;
 exports.pointInTriangle = pointInTriangle;
 exports.polygonArea = polygonArea;
 exports.polygonsToSvgPath = polygonsToSvgPath;
+exports.resolveAlignReferenceBox = resolveAlignReferenceBox;
 exports.resolveCoordinate = resolveCoordinate;
 exports.resolveOperand = resolveOperand;
 exports.segmentIntersection = segmentIntersection;
 exports.signedArea = signedArea;
+exports.snapBox = snapBox;
+exports.snapToGridStep = snapToGridStep;
+exports.snapValue = snapValue;
 exports.subtractPolygons = subtractPolygons;
 exports.subtractShapes = subtractShapes;
 exports.subtractSvgPaths = subtractSvgPaths;
@@ -15220,4 +15537,5 @@ exports.triangulate = triangulate;
 exports.unionPolygons = unionPolygons;
 exports.unionShapes = unionShapes;
 exports.unionSvgPaths = unionSvgPaths;
+exports.usesSlideReference = usesSlideReference;
 exports.vec2Eq = vec2Eq;

package/dist/geometry/index.d.ts

@@ -78,4 +78,6 @@ export * from './shape-definitions-extended.js';
 export * from './shape-definitions-primary.js';
 export { at } from './indexed.js';
 export * from './svg-path-flatten.js';
+export * from './snap-guides.js';
+export * from './align-distribute.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/geometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC;AACzD,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wDAAwD,CAAC;AACvE,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,wDAAwD,CAAC;AACvE,cAAc,mDAAmD,CAAC;AAClE,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../geometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,0CAA0C,CAAC;AACzD,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,qCAAqC,CAAC;AACpD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wDAAwD,CAAC;AACvE,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,8CAA8C,CAAC;AAC7D,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,mDAAmD,CAAC;AAClE,cAAc,wDAAwD,CAAC;AACvE,cAAc,mDAAmD,CAAC;AAClE,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,uDAAuD,CAAC;AACtE,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,OAAO,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC"}