ooxml-core 0.21.2 → 0.22.1

package/dist/index.mjs

@@ -12,13 +12,16 @@ __export(color_exports, {
   blendColorOntoWhite: () => blendColorOntoWhite,
   clampUnitInterval: () => clampUnitInterval,
   colorWithOpacity: () => colorWithOpacity,
+  contrastTextColor: () => contrastTextColor,
   hexToRgbChannels: () => hexToRgbChannels,
+  hexToRgbUnit: () => hexToRgbUnit,
   hslToRgb: () => hslToRgb,
   linearToSrgb255: () => linearToSrgb255,
   normalizeHexColor: () => normalizeHexColor,
   parseDrawingFraction: () => parseDrawingFraction,
   parseDrawingHueDegrees: () => parseDrawingHueDegrees,
   parseDrawingPercent: () => parseDrawingPercent,
+  parseHex: () => parseHex,
   parseOoxmlPercent: () => parseOoxmlPercent,
   rgbToHsl: () => rgbToHsl,
   scrgbLinearToSrgb8: () => scrgbLinearToSrgb8,
@@ -186,22 +189,68 @@ function linearToSrgb255(linear) {
   return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
 }
 
+// color/contrast.ts
+function parseHex(hex) {
+  let h = hex.trim().replace(/^#/u, "");
+  if (h.length === 3) {
+    h = h.split("").map((c) => c + c).join("");
+  }
+  if (h.length !== 6 || /[^0-9a-fA-F]/u.test(h)) {
+    return [128, 128, 128];
+  }
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function contrastTextColor(fill2) {
+  const [r, g, b] = parseHex(fill2);
+  const lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return lum > 0.6 ? "#1a1a1a" : "#ffffff";
+}
+
+// color/unit-rgb.ts
+function hexToRgbUnit(hex) {
+  const clean = hex.replace(/^#/u, "");
+  const r = Number.parseInt(clean.substring(0, 2), 16) / 255;
+  const g = Number.parseInt(clean.substring(2, 4), 16) / 255;
+  const b = Number.parseInt(clean.substring(4, 6), 16) / 255;
+  return {
+    r: Number.isFinite(r) ? r : 0,
+    g: Number.isFinite(g) ? g : 0,
+    b: Number.isFinite(b) ? b : 0
+  };
+}
+
 // chart/index.ts
 var chart_exports = {};
 __export(chart_exports, {
+  BEST_FIT_EDGE_TOLERANCE: () => BEST_FIT_EDGE_TOLERANCE,
+  BEST_FIT_OUTSIDE_GAP: () => BEST_FIT_OUTSIDE_GAP,
+  BEST_FIT_RIM_INSET: () => BEST_FIT_RIM_INSET,
+  LABEL_COLLISION_GAP: () => LABEL_COLLISION_GAP,
   aggregateByCategory: () => aggregateByCategory,
   axisTargetIntervals: () => axisTargetIntervals,
   computeBoxStats: () => computeBoxStats,
   computeHistogramBins: () => computeHistogramBins,
   computeLinearRegression: () => computeLinearRegression,
   computeRSquared: () => computeRSquared,
+  computeRadarPoints: () => computeRadarPoints,
   computeStackedSeriesPlots: () => computeStackedSeriesPlots,
   fitPolynomial: () => fitPolynomial,
+  formatExponentialEquation: () => formatExponentialEquation,
+  formatLinearEquation: () => formatLinearEquation,
+  formatLogarithmicEquation: () => formatLogarithmicEquation,
+  formatPolynomialEquation: () => formatPolynomialEquation,
+  formatPowerEquation: () => formatPowerEquation,
+  formatTrendlineCoefficient: () => formatTrendlineCoefficient,
   groupRowsByCategory: () => groupRowsByCategory,
   niceAxisStep: () => niceAxisStep,
   niceValueAxisBounds: () => niceValueAxisBounds,
+  nudgeOutsideLabels: () => nudgeOutsideLabels,
+  placeBestFitLabel: () => placeBestFitLabel,
+  radarAngle: () => radarAngle,
+  radarRingPoints: () => radarRingPoints,
   resolveBlankDisplay: () => resolveBlankDisplay,
   scottBinCount: () => scottBinCount,
+  squarify: () => squarify,
   visibleRuns: () => visibleRuns
 });
 
@@ -585,10 +634,241 @@ function aggregateByCategory(values, rawCategories) {
   });
 }
 
+// chart/treemap-squarify.ts
+function worstAspectRatio(areas, side) {
+  const sum = areas.reduce((total, area) => total + area, 0);
+  const max = Math.max(...areas);
+  const min = Math.min(...areas);
+  const sideSq = side * side;
+  const sumSq = sum * sum;
+  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
+}
+function squarify(nodes, box) {
+  const sorted = [...nodes].sort((a, b) => b.weight - a.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  const scale = total > 0 ? box.w * box.h / total : box.w * box.h / sorted.length;
+  const items = sorted.map((node) => ({ node, area: (total > 0 ? node.weight : 1) * scale }));
+  const result = [];
+  let rect2 = { ...box };
+  let remaining = items;
+  for (let first2 = remaining[0]; first2 !== void 0; first2 = remaining[0]) {
+    const side = Math.min(rect2.w, rect2.h);
+    let row = [first2];
+    let rowAreas = [first2.area];
+    let worst = worstAspectRatio(rowAreas, side);
+    let cursor = 1;
+    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
+      const candidateAreas = [...rowAreas, next.area];
+      const candidateWorst = worstAspectRatio(candidateAreas, side);
+      if (candidateWorst > worst) {
+        break;
+      }
+      row = [...row, next];
+      rowAreas = candidateAreas;
+      worst = candidateWorst;
+      cursor++;
+    }
+    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
+    const thickness = side > 0 ? rowTotalArea / side : 0;
+    const layoutVertically = rect2.w >= rect2.h;
+    let offset = layoutVertically ? rect2.y : rect2.x;
+    for (const item of row) {
+      const length = thickness > 0 ? item.area / thickness : 0;
+      if (layoutVertically) {
+        result.push([item.node, { x: rect2.x, y: offset, w: thickness, h: length }]);
+      } else {
+        result.push([item.node, { x: offset, y: rect2.y, w: length, h: thickness }]);
+      }
+      offset += length;
+    }
+    rect2 = layoutVertically ? { ...rect2, x: rect2.x + thickness, w: rect2.w - thickness } : { ...rect2, y: rect2.y + thickness, h: rect2.h - thickness };
+    remaining = remaining.slice(row.length);
+  }
+  return result;
+}
+
+// chart/trendline-equation.ts
+var SIGNIFICANT_DIGITS = 4;
+function formatTrendlineCoefficient(value) {
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  const rounded = Number(value.toPrecision(SIGNIFICANT_DIGITS));
+  return rounded === 0 ? "0" : String(rounded);
+}
+function signedTerm(value) {
+  return { sign: value < 0 ? "-" : "+", abs: formatTrendlineCoefficient(Math.abs(value)) };
+}
+function formatLinearEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}x ${sign} ${abs}`;
+}
+function formatExponentialEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)} e^(${formatTrendlineCoefficient(b)}x)`;
+}
+function formatLogarithmicEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}ln(x) ${sign} ${abs}`;
+}
+function formatPowerEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)}x^${formatTrendlineCoefficient(b)}`;
+}
+function formatPolynomialEquation(coeffsAscending) {
+  const order = coeffsAscending.length - 1;
+  let out = "y = ";
+  for (let power = order; power >= 0; power--) {
+    const coeff = coeffsAscending[power] ?? 0;
+    const { sign, abs } = signedTerm(coeff);
+    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
+    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+  }
+  return out;
+}
+
+// chart/radar-geometry.ts
+function radarAngle(index, catCount) {
+  const n = Math.max(catCount, 1);
+  return Math.PI * 2 * index / n - Math.PI / 2;
+}
+function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
+  const denom = maxVal > 0 ? maxVal : 1;
+  return values.slice(0, Math.max(catCount, 1)).map((val2, i) => {
+    const angle = radarAngle(i, catCount), r = Math.abs(val2) / denom * radius;
+    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
+  });
+}
+function radarRingPoints(cx, cy, rr, catCount) {
+  const n = Math.max(catCount, 1);
+  return Array.from({ length: n }, (_, i) => {
+    const angle = radarAngle(i, n);
+    return `${(cx + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
+  }).join(" ");
+}
+
+// chart/pie-best-fit.ts
+var PX_PER_PT = 4 / 3;
+var BEST_FIT_RIM_INSET = 4 * PX_PER_PT;
+var BEST_FIT_EDGE_TOLERANCE = 1.5 * PX_PER_PT;
+var BEST_FIT_OUTSIDE_GAP = 2 * PX_PER_PT;
+function farCorner(x, y, w, h) {
+  return Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + h / 2);
+}
+function insideDistance(ux, uy, w, h, limit) {
+  if (farCorner(0, 0, w, h) > limit) {
+    return void 0;
+  }
+  let lo = 0;
+  let hi = limit;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (farCorner(mid * ux, mid * uy, w, h) > limit) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo;
+}
+function edgeOverhang(x, y, w, h, slice) {
+  let worst = Number.NEGATIVE_INFINITY;
+  const corners = [
+    [-w / 2, -h / 2],
+    [w / 2, -h / 2],
+    [-w / 2, h / 2],
+    [w / 2, h / 2]
+  ];
+  for (const [dx, dy] of corners) {
+    const px2 = x + dx;
+    const py = y + dy;
+    const fromStart = Math.cos(slice.startAngle) * py - Math.sin(slice.startAngle) * px2;
+    const fromEnd = Math.sin(slice.endAngle) * px2 - Math.cos(slice.endAngle) * py;
+    worst = Math.max(worst, -fromStart, -fromEnd);
+  }
+  return worst;
+}
+function placeBestFitLabel(slice, w, h) {
+  const mid = (slice.startAngle + slice.endAngle) / 2;
+  const ux = Math.cos(mid);
+  const uy = Math.sin(mid);
+  const distance = insideDistance(ux, uy, w, h, slice.outerR - BEST_FIT_RIM_INSET);
+  if (distance !== void 0) {
+    const x = distance * ux;
+    const y = distance * uy;
+    const reflex = slice.endAngle - slice.startAngle >= Math.PI;
+    if (reflex || edgeOverhang(x, y, w, h, slice) <= BEST_FIT_EDGE_TOLERANCE) {
+      return { x: slice.cx + x, y: slice.cy + y, inside: true };
+    }
+  }
+  const extent = Math.abs(ux) * w / 2 + Math.abs(uy) * h / 2;
+  const outside = slice.outerR + BEST_FIT_OUTSIDE_GAP + extent;
+  return { x: slice.cx + outside * ux, y: slice.cy + outside * uy, inside: false };
+}
+
+// chart/pie-label-collision.ts
+var LABEL_COLLISION_GAP = 2;
+function boxDistanceToCentre(box, y, disc) {
+  const nearestX = Math.max(box.x - box.w / 2, Math.min(disc.cx, box.x + box.w / 2));
+  const nearestY = Math.max(y - box.h / 2, Math.min(disc.cy, y + box.h / 2));
+  return Math.hypot(nearestX - disc.cx, nearestY - disc.cy);
+}
+function clearOfDisc(box, y, disc) {
+  if (boxDistanceToCentre(box, y, disc) >= disc.r) {
+    return 0;
+  }
+  const sign = box.x >= disc.cx ? 1 : -1;
+  let dx = 0;
+  while (dx < disc.r * 2 && boxDistanceToCentre({ ...box, x: box.x + sign * dx }, y, disc) < disc.r) {
+    dx += 1;
+  }
+  return sign * dx;
+}
+function overlapsX(a, b) {
+  return Math.abs(a.x - b.x) < (a.w + b.w) / 2;
+}
+function sweepSide(boxes, minY, maxY) {
+  const sorted = [...boxes].sort((a, b) => a.y - b.y || a.id - b.id);
+  const ys = sorted.map((box) => box.y);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const box = sorted[i];
+    if (overlapsX(prev, box)) {
+      ys[i] = Math.max(ys[i], ys[i - 1] + (prev.h + box.h) / 2 + LABEL_COLLISION_GAP);
+    }
+  }
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const box = sorted[i];
+    const limit = i === sorted.length - 1 ? maxY - box.h / 2 : ys[i + 1] - (box.h + sorted[i + 1].h) / 2 - LABEL_COLLISION_GAP;
+    if (ys[i] > limit) {
+      ys[i] = Math.max(limit, minY + box.h / 2);
+    }
+  }
+  return new Map(sorted.map((box, i) => [box.id, ys[i]]));
+}
+function nudgeOutsideLabels(boxes, disc, minY, maxY) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const side of [
+    boxes.filter((box) => box.x >= disc.cx),
+    boxes.filter((box) => box.x < disc.cx)
+  ]) {
+    for (const [id, y] of sweepSide(side, minY, maxY)) {
+      resolved.set(id, y);
+    }
+  }
+  return boxes.map((box) => {
+    const y = resolved.get(box.id) ?? box.y;
+    return { id: box.id, dx: y === box.y ? 0 : clearOfDisc(box, y, disc), dy: y - box.y };
+  });
+}
+
 // text/index.ts
 var text_exports = {};
 __export(text_exports, {
+  buildLeaderString: () => buildLeaderString,
+  decimalAnchorIndex: () => decimalAnchorIndex,
+  decimalSeparatorForLanguage: () => decimalSeparatorForLanguage,
   detectFontScript: () => detectFontScript,
+  getLeaderCharacter: () => getLeaderCharacter,
+  getLeaderStyles: () => getLeaderStyles,
   hasDistinctScriptFonts: () => hasDistinctScriptFonts,
   resolveFontForScript: () => resolveFontForScript,
   segmentByScript: () => segmentByScript
@@ -710,6 +990,73 @@ function hasDistinctScriptFonts(fonts) {
   return Boolean(fonts.eastAsia) && fonts.eastAsia !== base || Boolean(fonts.complexScript) && fonts.complexScript !== base || Boolean(fonts.symbol) && fonts.symbol !== base;
 }
 
+// text/tab-leader.ts
+function getLeaderCharacter(leader) {
+  switch (leader) {
+    case "dot":
+      return ".";
+    case "hyphen":
+      return "-";
+    case "underscore":
+      return "_";
+    case "heavy":
+      return "\u2501";
+    // box-drawing heavy horizontal
+    case "middleDot":
+      return "\xB7";
+    // middle dot
+    default:
+      return void 0;
+  }
+}
+function getLeaderStyles(widthPx, color) {
+  if (widthPx <= 0) {
+    return void 0;
+  }
+  return {
+    display: "inline-block",
+    width: `${widthPx}px`,
+    overflow: "hidden",
+    whiteSpace: "pre",
+    verticalAlign: "baseline",
+    ...color ? { color } : {}
+  };
+}
+function buildLeaderString(leader, widthPx, fontSizePx = 16) {
+  const char = getLeaderCharacter(leader);
+  if (!char || widthPx <= 0) {
+    return "	";
+  }
+  const charWidth = Math.max(1, fontSizePx * 0.6);
+  const count = Math.max(1, Math.ceil(widthPx / charWidth));
+  return char.repeat(count);
+}
+
+// text/decimal-tab.ts
+function decimalSeparatorForLanguage(language) {
+  if (!language) {
+    return ".";
+  }
+  try {
+    const part = new Intl.NumberFormat(language).formatToParts(1.5).find((p) => p.type === "decimal");
+    return part?.value ?? ".";
+  } catch {
+    return ".";
+  }
+}
+function decimalAnchorIndex(text, separator) {
+  const first2 = text.search(/[0-9]/u);
+  if (first2 < 0) {
+    return text.length;
+  }
+  let end = first2;
+  while (end < text.length && /[0-9.,]/u.test(text.charAt(end))) {
+    end++;
+  }
+  const sep = text.slice(first2, end).indexOf(separator);
+  return sep >= 0 ? first2 + sep : end;
+}
+
 // diagram/index.ts
 var diagram_exports = {};
 __export(diagram_exports, {
@@ -3442,6 +3789,7 @@ __export(geometry_exports, {
   RIBBON_CONNECTION_SITES: () => RIBBON_CONNECTION_SITES,
   RIBBON_TEXT_RECTS: () => RIBBON_TEXT_RECTS,
   SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS: () => SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS,
+  SNAP_THRESHOLD: () => SNAP_THRESHOLD,
   STAR_CONNECTION_SITES: () => STAR_CONNECTION_SITES,
   STAR_TEXT_RECTS: () => STAR_TEXT_RECTS,
   ST_SHAPE_TYPE_VALUES: () => ST_SHAPE_TYPE_VALUES,
@@ -3449,17 +3797,23 @@ __export(geometry_exports, {
   TAB_CONNECTION_SITES: () => TAB_CONNECTION_SITES,
   TAB_TEXT_RECTS: () => TAB_TEXT_RECTS,
   _internalForTests: () => _internalForTests,
+  alignElements: () => alignElements,
   angleToRadians: () => angleToRadians,
   at: () => at,
   buildCalloutLeaderLineSvgPath: () => buildCalloutLeaderLineSvgPath,
   clipPolygons: () => clipPolygons,
   combineShapes: () => combineShapes,
+  computeAlign: () => computeAlign,
+  computeDistribute: () => computeDistribute,
+  computeSnap: () => computeSnap,
+  computeSnapToShape: () => computeSnapToShape,
   computeUnionWalk: () => computeUnionWalk,
   convexHull: () => convexHull,
   createBuiltinVariables: () => createBuiltinVariables,
   cross2: () => cross2,
   cxn: () => cxn,
   dedupPoly: () => dedupPoly,
+  distributeElements: () => distributeElements,
   elbowCurveSegments: () => elbowCurveSegments,
   elbowWaypoints: () => elbowWaypoints,
   ensureCCW: () => ensureCCW,
@@ -3503,10 +3857,14 @@ __export(geometry_exports, {
   pointInTriangle: () => pointInTriangle,
   polygonArea: () => polygonArea,
   polygonsToSvgPath: () => polygonsToSvgPath,
+  resolveAlignReferenceBox: () => resolveAlignReferenceBox,
   resolveCoordinate: () => resolveCoordinate,
   resolveOperand: () => resolveOperand,
   segmentIntersection: () => segmentIntersection,
   signedArea: () => signedArea,
+  snapBox: () => snapBox,
+  snapToGridStep: () => snapToGridStep,
+  snapValue: () => snapValue,
   subtractPolygons: () => subtractPolygons,
   subtractShapes: () => subtractShapes,
   subtractSvgPaths: () => subtractSvgPaths,
@@ -3516,6 +3874,7 @@ __export(geometry_exports, {
   unionPolygons: () => unionPolygons,
   unionShapes: () => unionShapes,
   unionSvgPaths: () => unionSvgPaths,
+  usesSlideReference: () => usesSlideReference,
   vec2Eq: () => vec2Eq
 });
 
@@ -18606,6 +18965,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(elements2, options) {
+  if (elements2.length === 0) {
+    return null;
+  }
+  if (usesSlideReference(elements2.length, options)) {
+    return { minX: 0, minY: 0, maxX: options.slideSize.width, maxY: options.slideSize.height };
+  }
+  if (elements2.length < 2) {
+    return null;
+  }
+  return {
+    minX: Math.min(...elements2.map((e) => e.x)),
+    minY: Math.min(...elements2.map((e) => e.y)),
+    maxX: Math.max(...elements2.map((e) => e.x + e.width)),
+    maxY: Math.max(...elements2.map((e) => e.y + e.height))
+  };
+}
+function alignElements(elements2, edge, options) {
+  const result = /* @__PURE__ */ new Map();
+  const ref = resolveAlignReferenceBox(elements2, 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 elements2) {
+    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(elements2, 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 = [...elements2].sort((a, b) => start(a) - start(b));
+  const totalSize = sorted.reduce((sum, e) => sum + size(e), 0);
+  let cursor;
+  let gap;
+  if (usesSlideReference(elements2.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 first2 = sorted[0];
+    const last = sorted[sorted.length - 1];
+    const span = start(last) + size(last) - start(first2);
+    gap = (span - totalSize) / (sorted.length - 1);
+    cursor = start(first2);
+  }
+  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));
+}
+
 // units/index.ts
 var units_exports = {};
 __export(units_exports, {