ooxml-core 1.5.0 → 1.6.1

package/dist/index.cjs

@@ -2458,7 +2458,7 @@ function drawingFillXml(fill) {
   const root = doc.documentElement;
   if (root.namespaceURI !== NS.a || root.localName !== "gradFill")
     throw new Error("Invalid gradient source XML");
-  const fragment = (xml) => doc.importNode(elements(parseXml(`<w xmlns:a="${NS.a}">${xml}</w>`).documentElement)[0], true);
+  const fragment2 = (xml) => doc.importNode(elements(parseXml(`<w xmlns:a="${NS.a}">${xml}</w>`).documentElement)[0], true);
   let list2 = first(root, "gsLst", NS.a);
   if (!list2) {
     list2 = doc.createElementNS(NS.a, "a:gsLst");
@@ -2473,7 +2473,7 @@ function drawingFillXml(fill) {
     node.setAttribute("pos", String(Math.round(stop.position * 1e3)));
     for (const old of elements(node))
       if (old.namespaceURI === NS.a && old.localName.endsWith("Clr")) node.removeChild(old);
-    node.insertBefore(fragment(drawingColorXml(stop.color)), node.firstChild);
+    node.insertBefore(fragment2(drawingColorXml(stop.color)), node.firstChild);
   });
   for (const stop of stops.slice(fill.stops.length)) list2.removeChild(stop);
   for (const node of elements(root))
@@ -2776,14 +2776,14 @@ function resolveChartGradient(fill, resolve) {
     ...focus ? { focalPoint: { x: (1 + focus.l - focus.r) / 2, y: (1 + focus.t - focus.b) / 2 } } : {}
   };
 }
-function buildChartGradientDef(id, fill, bounds) {
+function buildChartGradientDef(id, fill, bounds2) {
   const sourceStops = sortGradientStops(fill.stops).map((stop) => ({
     offset: Math.min(Math.max(stop.position / 100, 0), 1),
     color: stop.color,
     ...stop.opacity !== void 0 ? { opacity: stop.opacity } : {}
   }));
   const stops = fill.interpolation === "sigma-gamma22" ? sigmaGradientStops(sourceStops) ?? sourceStops : sourceStops;
-  if (fill.type === "radial" && (fill.path === "rect" || fill.path === "shape" && bounds?.shape === "rect")) {
+  if (fill.type === "radial" && (fill.path === "rect" || fill.path === "shape" && bounds2?.shape === "rect")) {
     const markup = buildRectPathGradientSvg(
       stops.map((stop) => ({
         position: stop.offset * 100,
@@ -2804,7 +2804,7 @@ function buildChartGradientDef(id, fill, bounds) {
   if (fill.type === "radial") {
     const cx = fill.focalPoint?.x ?? 0.5;
     const cy = fill.focalPoint?.y ?? 0.5;
-    const aspect = fill.path === "circle" && bounds && Number.isFinite(bounds.width) && Number.isFinite(bounds.height) && bounds.width > 0 && bounds.height > 0 ? bounds.height / bounds.width : 1;
+    const aspect = fill.path === "circle" && bounds2 && Number.isFinite(bounds2.width) && Number.isFinite(bounds2.height) && bounds2.width > 0 && bounds2.height > 0 ? bounds2.height / bounds2.width : 1;
     return {
       kind: "radialGradient",
       id,
@@ -2880,7 +2880,7 @@ function extractAllTagText(xml, localName2) {
 function chartGradientMarkup(def) {
   if (def.kind === "rectPath")
     return `<pattern id="${escapeXmlAttr(def.id)}" patternUnits="objectBoundingBox" patternContentUnits="objectBoundingBox" width="1" height="1"><image href="${escapeXmlAttr(def.href)}" width="1" height="1" preserveAspectRatio="none"/></pattern>`;
-  const geometry = def.kind === "linearGradient" ? `x1="${def.x1}" y1="${def.y1}" x2="${def.x2}" y2="${def.y2}"` : `cx="${def.cx}" cy="${def.cy}" r="${def.r}"`;
+  const geometry = def.kind === "linearGradient" ? `${def.gradientUnits ? `gradientUnits="${def.gradientUnits}" ` : ""}x1="${def.x1}" y1="${def.y1}" x2="${def.x2}" y2="${def.y2}"` : `cx="${def.cx}" cy="${def.cy}" r="${def.r}"`;
   const stops = def.stops.map(
     (stop) => `<stop offset="${stop.offset}" stop-color="${escapeXmlAttr(stop.color)}" stop-opacity="${stop.opacity ?? 1}"/>`
   ).join("");
@@ -3659,17 +3659,17 @@ function parseView3D(context, element) {
     }
   );
 }
-function chartStyle(context, space) {
-  const direct = cNumber(context, space, "style");
+function chartStyle(context, space3) {
+  const direct = cNumber(context, space3, "style");
   if (direct !== void 0) return direct;
-  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+  for (const alternate of children(space3, "AlternateContent", NS.mc)) {
     const style = cNumber(context, first(alternate, "Fallback", NS.mc), "style");
     if (style !== void 0) return style;
   }
   return void 0;
 }
-function c14Style(space) {
-  for (const alternate of children(space, "AlternateContent", NS.mc)) {
+function c14Style(space3) {
+  for (const alternate of children(space3, "AlternateContent", NS.mc)) {
     const raw2 = attribute(first(first(alternate, "Choice", NS.mc), "style", NS.c14, false), "val");
     const value = raw2?.trim() ? Number(raw2) : Number.NaN;
     if (Number.isFinite(value)) return value;
@@ -4178,10 +4178,10 @@ function legendXml(context, legend) {
     valXml("legendPos", legend.position) + entries + layoutXml(context, legend.layout) + valXml("overlay", legend.overlay) + shapePropertiesXml(context, legend.spPr) + textBodyXml(context, legend.txPr) + raw(context, legend.extLst)
   );
 }
-function styleXml(context, space) {
-  const style = valXml("style", space.style);
-  if (space.c14Style === void 0) return style;
-  const choice = `<mc:Choice Requires="c14" xmlns:c14="${NS.c14}"><c14:style val="${space.c14Style}"/></mc:Choice>`;
+function styleXml(context, space3) {
+  const style = valXml("style", space3.style);
+  if (space3.c14Style === void 0) return style;
+  const choice = `<mc:Choice Requires="c14" xmlns:c14="${NS.c14}"><c14:style val="${space3.c14Style}"/></mc:Choice>`;
   const fallback = style ? `<mc:Fallback>${style}</mc:Fallback>` : "<mc:Fallback/>";
   return raw(
     context,
@@ -4189,21 +4189,21 @@ function styleXml(context, space) {
   );
 }
 var relationship = (local, id, content2 = "") => id === void 0 ? "" : elementXml(local, content2, ` r:id="${escapeAttribute(id)}"`);
-function writeChartSpace(space, options = {}) {
+function writeChartSpace(space3, options = {}) {
   const bindings = new Map(CHART_ROOT_BINDINGS);
-  for (const { prefix, uri } of space.namespaceDeclarations ?? [])
+  for (const { prefix, uri } of space3.namespaceDeclarations ?? [])
     if (!bindings.has(prefix) && /^[A-Za-z_][\w.-]*$/.test(prefix)) bindings.set(prefix, uri);
   const context = { bindings };
   const declarations = [...bindings].map(([prefix, uri]) => ` xmlns:${prefix}="${escapeAttribute(uri)}"`).join("");
   const chart = elementXml(
     "chart",
-    titleXml(context, space.title) + valXml("autoTitleDeleted", space.autoTitleDeleted) + view3DXml(space.view3D) + surfaceXml(context, "floor", space.floor) + surfaceXml(context, "sideWall", space.sideWall) + surfaceXml(context, "backWall", space.backWall) + plotAreaXml(context, space.plotArea) + legendXml(context, space.legend) + valXml("plotVisOnly", space.plotVisibleOnly) + valXml("dispBlanksAs", space.displayBlanksAs) + valXml("showDLblsOverMax", space.showDataLabelsOverMax) + raw(context, space.chartExtLst)
+    titleXml(context, space3.title) + valXml("autoTitleDeleted", space3.autoTitleDeleted) + view3DXml(space3.view3D) + surfaceXml(context, "floor", space3.floor) + surfaceXml(context, "sideWall", space3.sideWall) + surfaceXml(context, "backWall", space3.backWall) + plotAreaXml(context, space3.plotArea) + legendXml(context, space3.legend) + valXml("plotVisOnly", space3.plotVisibleOnly) + valXml("dispBlanksAs", space3.displayBlanksAs) + valXml("showDLblsOverMax", space3.showDataLabelsOverMax) + raw(context, space3.chartExtLst)
   );
-  const body = valXml("date1904", space.date1904) + valXml("lang", space.language) + valXml("roundedCorners", space.roundedCorners) + styleXml(context, space) + chart + shapePropertiesXml(context, space.spPr) + textBodyXml(context, space.txPr) + relationship(
+  const body = valXml("date1904", space3.date1904) + valXml("lang", space3.language) + valXml("roundedCorners", space3.roundedCorners) + styleXml(context, space3) + chart + shapePropertiesXml(context, space3.spPr) + textBodyXml(context, space3.txPr) + relationship(
     "externalData",
-    space.externalDataRelId,
-    valXml("autoUpdate", space.externalDataAutoUpdate)
-  ) + raw(context, space.printSettings) + relationship("userShapes", space.userShapesRelId) + raw(context, space.extLst);
+    space3.externalDataRelId,
+    valXml("autoUpdate", space3.externalDataAutoUpdate)
+  ) + raw(context, space3.printSettings) + relationship("userShapes", space3.userShapesRelId) + raw(context, space3.extLst);
   const breakAfter = options.declarationBreak ?? "\r\n";
   return `${DECLARATION2}${breakAfter}<c:chartSpace${declarations}>${body}</c:chartSpace>`;
 }
@@ -4999,8 +4999,8 @@ function chartGradientPaint(model, width = 1024, height = 768) {
         textShadowFilter: shadowPaint(entry3.textShadow, `${part}-text-shadow`)
       };
   }
-  const paint = (gradient, suffix, bounds) => {
-    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds);
+  const paint = (gradient, suffix, bounds2) => {
+    const def = buildChartGradientDef(`${prefix}-${suffix}`, gradient, bounds2);
     defs.push(chartGradientMarkup(def));
     return `url(#${def.id})`;
   };
@@ -5016,12 +5016,12 @@ function chartGradientPaint(model, width = 1024, height = 768) {
   const series = model.series.map((source, index) => {
     const view = { ...source };
     if (source.shadow) view.shadowFilter = shadowPaint(source.shadow, `s${index}-shadow`);
-    const bounds = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
-    if (source.gradient) view.color = paint(source.gradient, `s${index}`, bounds);
+    const bounds2 = model.type === "bar" || model.type === "column" ? { width: 1, height: 1, shape: "rect" } : void 0;
+    if (source.gradient) view.color = paint(source.gradient, `s${index}`, bounds2);
     if (source.pointGradients) {
       view.pointColors = [...source.pointColors ?? []];
       for (const [key, gradient] of Object.entries(source.pointGradients))
-        view.pointColors[Number(key)] = paint(gradient, `s${index}-p${key}`, bounds);
+        view.pointColors[Number(key)] = paint(gradient, `s${index}-p${key}`, bounds2);
     }
     return view;
   });
@@ -5220,7 +5220,7 @@ function linesAndAreas(model, frame2, out) {
   const stacked = model.grouping === "stacked" || model.grouping === "percentStacked";
   const acc = new Array(model.categories.length).fill(0);
   const area = model.type === "area";
-  const layers = [];
+  const layers2 = [];
   model.series.forEach((s, si) => {
     const points = [];
     const lower = [];
@@ -5236,14 +5236,14 @@ function linesAndAreas(model, frame2, out) {
       points.push([frame2.band(i2), frame2.value(top)]);
       lower.push([frame2.band(i2), frame2.value(below)]);
     });
-    layers.push({
+    layers2.push({
       points,
       lower,
       color: s.color,
       filter: s.shadowFilter ? ` filter="${s.shadowFilter}"` : ""
     });
   });
-  for (const { points, lower, color, filter } of area ? [...layers].reverse() : layers) {
+  for (const { points, lower, color, filter } of area ? [...layers2].reverse() : layers2) {
     if (area) {
       const poly = [...points, ...[...lower].reverse()].map(([x, y]) => `${n(x)},${n(y)}`).join(" ");
       out.push(`<polygon points="${poly}" fill="${color}" fill-opacity="0.85"${filter}/>`);
@@ -5467,10 +5467,10 @@ function fitChartText(content2, maxWidth, attrs, options) {
 // chart/render/chart-svg-legend.ts
 function chartLegendSvg(model, area, frame2, options) {
   const automatic = [];
-  const bounds = {};
-  const reserved = automaticLegend(model, area, automatic, options, bounds);
+  const bounds2 = {};
+  const reserved = automaticLegend(model, area, automatic, options, bounds2);
   const plot = model.legendOverlay ? area : reserved;
-  const box = bounds.box;
+  const box = bounds2.box;
   if (!box) return { plot, markup: "", foreground: false };
   const manual = resolveManualLayoutRect(model.legendLayout, frame2, {
     x: box.x,
@@ -5529,7 +5529,7 @@ function legendEntries(model) {
   }
   return model.series.map((s) => ({ label: s.name, color: s.color }));
 }
-function automaticLegend(model, area, out, options, bounds) {
+function automaticLegend(model, area, out, options, bounds2) {
   const entries = legendEntries(model);
   if (!model.showLegend || entries.length === 0) return area;
   const pos = model.legendPosition;
@@ -5543,7 +5543,7 @@ function automaticLegend(model, area, out, options, bounds) {
     const total = widths.reduce((a2, b) => a2 + b, 0);
     let x2 = area.x + Math.max(0, (area.w - total) / 2);
     const y = pos === "t" ? area.y + 4 : area.y + area.h - rowH + 4;
-    bounds.box = { x: x2 - 4, y: y - 4, w: Math.min(total, area.w) + 8, h: rowH + 4 };
+    bounds2.box = { x: x2 - 4, y: y - 4, w: Math.min(total, area.w) + 8, h: rowH + 4 };
     out.push(
       chartAreaRect(model, "legend", {
         x: x2 - 4,
@@ -5567,7 +5567,7 @@ function automaticLegend(model, area, out, options, bounds) {
   const height = entries.length * rowH;
   const x = pos === "l" ? area.x + 4 : area.x + area.w - width;
   const y0 = pos === "tr" ? area.y + 4 : area.y + Math.max(0, (area.h - height) / 2);
-  bounds.box = { x: x - 4, y: y0, w: width + 4, h: Math.min(height, area.y + area.h - y0) };
+  bounds2.box = { x: x - 4, y: y0, w: width + 4, h: Math.min(height, area.y + area.h - y0) };
   out.push(
     chartAreaRect(model, "legend", {
       x: x - 4,
@@ -5871,14 +5871,14 @@ function chartThemePalette(theme, fonts = {}) {
     minorFont: fonts.minor ?? "Calibri"
   };
 }
-function chartSpaceKind(space) {
-  if (!space.plotArea.groups.length) return { drawn: false };
-  const type = chartSummaryFromSpace(space).chartType;
+function chartSpaceKind(space3) {
+  if (!space3.plotArea.groups.length) return { drawn: false };
+  const type = chartSummaryFromSpace(space3).chartType;
   return { type, drawn: DRAWN_CHART_TYPES.has(type) };
 }
-function renderChartSpaceSvg(space, options) {
+function renderChartSpaceSvg(space3, options) {
   const { width, height, theme, fonts, formatting, colorPalette, styleDefinition, ...svg } = options;
-  const summary = chartSummaryFromSpace(space, {
+  const summary = chartSummaryFromSpace(space3, {
     ...formatting ? { formatting } : {},
     ...colorPalette !== void 0 ? { colorPalette } : {},
     ...styleDefinition ? { styleDefinition } : {}
@@ -5890,7 +5890,10 @@ function renderChartSpaceSvg(space, options) {
 // text/index.ts
 var text_exports = {};
 __export(text_exports, {
+  TEXT_CASE_MODES: () => TEXT_CASE_MODES,
   buildLeaderString: () => buildLeaderString,
+  changeTextCase: () => changeTextCase,
+  changeTextCaseRanges: () => changeTextCaseRanges,
   decimalAnchorIndex: () => decimalAnchorIndex,
   decimalSeparatorForLanguage: () => decimalSeparatorForLanguage,
   detectFontScript: () => detectFontScript,
@@ -6085,6 +6088,73 @@ function decimalAnchorIndex(text3, separator) {
   return sep >= 0 ? first2 + sep : end;
 }
 
+// text/change-case.ts
+var TEXT_CASE_MODES = Object.freeze([
+  "sentence",
+  "lower",
+  "upper",
+  "capitalize",
+  "toggle"
+]);
+var letter = /\p{L}/u;
+var wordCharacter = /[\p{L}\p{N}\p{M}'’]/u;
+var sentenceEnd = /[.!?。！？]/u;
+var space = /\s/u;
+function convert(text3, mode) {
+  if (!TEXT_CASE_MODES.includes(mode)) throw new TypeError(`Unknown text case mode: ${mode}`);
+  const points = [];
+  let offset = 0, sentenceStart = true, pendingEnd = false, previous = "";
+  for (const point of text3) {
+    let out = point;
+    if (letter.test(point)) {
+      const lower = point.toLowerCase(), upper = point.toUpperCase();
+      if (mode === "upper") out = upper;
+      else if (mode === "lower") out = lower;
+      else if (mode === "toggle") out = point === upper && point !== lower ? lower : upper;
+      else if (mode === "sentence") out = sentenceStart ? upper : lower;
+      else out = previous && wordCharacter.test(previous) ? lower : upper;
+      sentenceStart = false;
+      pendingEnd = false;
+    } else if (point === "\n") {
+      sentenceStart = true;
+      pendingEnd = false;
+    } else if (sentenceEnd.test(point)) pendingEnd = true;
+    else if (space.test(point)) {
+      if (pendingEnd) sentenceStart = true;
+      pendingEnd = false;
+    } else if (/\p{N}/u.test(point)) {
+      sentenceStart = false;
+      pendingEnd = false;
+    }
+    points.push({ start: offset, end: offset + point.length, text: point, out });
+    offset += point.length;
+    previous = point;
+  }
+  return points;
+}
+function changeTextCase(text3, mode) {
+  return convert(text3, mode).map((point) => point.out).join("");
+}
+function changeTextCaseRanges(text3, mode, boundaries = []) {
+  const breaks = new Set(boundaries);
+  const ranges = [];
+  let current;
+  for (const point of convert(text3, mode)) {
+    if (point.out === point.text) {
+      current = void 0;
+      continue;
+    }
+    if (current && current.end === point.start && !breaks.has(point.start)) {
+      current.end = point.end;
+      current.text += point.out;
+    } else {
+      current = { start: point.start, end: point.end, text: point.out };
+      ranges.push(current);
+    }
+  }
+  return ranges;
+}
+
 // i18n/index.ts
 var i18n_exports = {};
 __export(i18n_exports, {
@@ -6172,6 +6242,7 @@ __export(drawingml_exports, {
   drawingColorCss: () => drawingColorCss,
   drawingColorXml: () => drawingColorXml,
   drawingFillXml: () => drawingFillXml,
+  drawingThemeXml: () => drawingThemeXml,
   fillElementOf: () => fillElementOf,
   integerAttribute: () => integerAttribute,
   isThemeColorSlot: () => isThemeColorSlot,
@@ -6343,6 +6414,83 @@ function parseDrawingGeometry(spPr) {
   return { geometry, ...Object.keys(adjustments).length > 0 ? { adjustments } : {} };
 }
 
+// drawingml/write-theme.ts
+function fragment(host, xml, namespaces) {
+  const declarations = Object.entries({ a: NS.a, ...namespaces }).map(([prefix, uri]) => ` xmlns:${prefix}="${uri}"`).join("");
+  const wrapper = parseXml(`<w${declarations}>${xml}</w>`, { label: "DrawingML theme fragment" });
+  return elements(wrapper.documentElement).map(
+    (node) => host.ownerDocument.importNode(node, true)
+  );
+}
+function extensionList2(parent, extensions, namespaces) {
+  const entries = Object.entries(extensions ?? {});
+  if (!entries.length) return;
+  const doc = parent.ownerDocument;
+  const list2 = doc.createElementNS(NS.a, "a:extLst");
+  for (const [uri, xml] of entries) {
+    const ext = doc.createElementNS(NS.a, "a:ext");
+    ext.setAttribute("uri", uri);
+    for (const node of fragment(ext, xml, namespaces)) ext.appendChild(node);
+    list2.appendChild(ext);
+  }
+  parent.appendChild(list2);
+}
+function fontCollection(parent, name, fonts) {
+  const doc = parent.ownerDocument;
+  const node = doc.createElementNS(NS.a, `a:${name}`);
+  for (const [local, face] of [
+    ["latin", fonts.latin],
+    ["ea", fonts.eastAsia],
+    ["cs", fonts.complexScript]
+  ]) {
+    const font = doc.createElementNS(NS.a, `a:${local}`);
+    font.setAttribute("typeface", face ?? "");
+    node.appendChild(font);
+  }
+  for (const [script, face] of Object.entries(fonts.scripts)) {
+    const font = doc.createElementNS(NS.a, "a:font");
+    font.setAttribute("script", script);
+    font.setAttribute("typeface", face);
+    node.appendChild(font);
+  }
+  parent.appendChild(node);
+}
+function drawingThemeXml(theme, parts) {
+  const namespaces = parts.namespaces ?? {};
+  const doc = parseXml(
+    `<a:theme xmlns:a="${NS.a}"${Object.entries(namespaces).map(([prefix, uri]) => ` xmlns:${prefix}="${uri}"`).join("")}/>`
+  );
+  const root = doc.documentElement;
+  if (theme.name !== void 0) root.setAttribute("name", theme.name);
+  const elementsNode = doc.createElementNS(NS.a, "a:themeElements");
+  root.appendChild(elementsNode);
+  const scheme = doc.createElementNS(NS.a, "a:clrScheme");
+  scheme.setAttribute("name", theme.colorScheme.name ?? theme.name ?? "Custom");
+  for (const slot2 of THEME_COLOR_SLOTS) {
+    const color = theme.colorScheme.colors[slot2];
+    if (!color) throw new Error(`The theme colour scheme has no ${slot2} colour.`);
+    const node = doc.createElementNS(NS.a, `a:${slot2}`);
+    for (const child3 of fragment(node, drawingColorXml(color), namespaces)) node.appendChild(child3);
+    scheme.appendChild(node);
+  }
+  extensionList2(scheme, parts.colorSchemeExtensions, namespaces);
+  elementsNode.appendChild(scheme);
+  const fonts = doc.createElementNS(NS.a, "a:fontScheme");
+  fonts.setAttribute("name", theme.fontScheme.name ?? theme.name ?? "Custom");
+  fontCollection(fonts, "majorFont", theme.fontScheme.major);
+  fontCollection(fonts, "minorFont", theme.fontScheme.minor);
+  elementsNode.appendChild(fonts);
+  const format = fragment(elementsNode, parts.formatScheme, namespaces);
+  if (format.length !== 1 || format[0].localName !== "fmtScheme" || format[0].namespaceURI !== NS.a)
+    throw new Error("The theme format scheme must be one a:fmtScheme element.");
+  elementsNode.appendChild(format[0]);
+  extensionList2(elementsNode, parts.themeElementsExtensions, namespaces);
+  root.appendChild(doc.createElementNS(NS.a, "a:objectDefaults"));
+  root.appendChild(doc.createElementNS(NS.a, "a:extraClrSchemeLst"));
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+${buildXml(doc)}`;
+}
+
 // drawingml/gradient-preset-data.ts
 var OFFICE_GRADIENT_PRESET_DATA = [
   [
@@ -18407,13 +18555,13 @@ function textFitsAt(node, text3, sizePt, metrics, refSize) {
   }
   return paragraphsFit(text3, sizePt, availW, availH, metrics);
 }
-function fitNodeFontPt(node, text3, bounds, metrics, refSize) {
-  for (let size = bounds.start; size > bounds.floor; size--) {
+function fitNodeFontPt(node, text3, bounds2, metrics, refSize) {
+  for (let size = bounds2.start; size > bounds2.floor; size--) {
     if (textFitsAt(node, text3, size, metrics, refSize)) {
       return size;
     }
   }
-  return bounds.floor;
+  return bounds2.floor;
 }
 
 // diagram/engine/text-grow.ts
@@ -19446,9 +19594,9 @@ function placeTwoColumns(shapes, centre, top, gap, sp) {
     const left = side === 0 ? centre - gap / 2 - width : centre + gap / 2;
     let y = top;
     for (const shape of column) {
-      const bounds = boundsOf(shape.rects);
-      rects.push(...shiftShape(shape, left - bounds.x, y - bounds.y).rects);
-      y += bounds.h + sp;
+      const bounds2 = boundsOf(shape.rects);
+      rects.push(...shiftShape(shape, left - bounds2.x, y - bounds2.y).rects);
+      y += bounds2.h + sp;
       bottom = Math.max(bottom, y - sp);
     }
   }
@@ -19515,9 +19663,9 @@ function pack(shapes, vertical, gap, end) {
   const across = (s) => vertical ? boundsOf(s.rects).w : boundsOf(s.rects).h;
   const thickness = Math.max(0, ...shapes.map(across));
   for (const shape of shapes) {
-    const bounds = boundsOf(shape.rects);
+    const bounds2 = boundsOf(shape.rects);
     const crossShift = end ? thickness - across(shape) : 0;
-    let placed = vertical ? shiftShape(shape, crossShift - bounds.x, 0) : shiftShape(shape, 0, crossShift - bounds.y);
+    let placed = vertical ? shiftShape(shape, crossShift - bounds2.x, 0) : shiftShape(shape, 0, crossShift - bounds2.y);
     if (rects.length > 0 && vertical) {
       const above = boundsOf(rects);
       placed = shiftShape(placed, 0, above.y + above.h + gap - boundsOf(placed.rects).y);
@@ -19654,21 +19802,21 @@ function fitContainers(node) {
   if (boxes.length === 0) {
     return void 0;
   }
-  const bounds = boundsOf(boxes);
+  const bounds2 = boundsOf(boxes);
   if (HIER_ALGS.has(node.alg.type) && hasHierAncestor(node)) {
-    node.box = bounds;
+    node.box = bounds2;
   }
-  return bounds;
+  return bounds2;
 }
 function placeScaled(node, shape) {
   const box = node.box;
-  const bounds = boundsOf(shape.rects);
-  if (!box || !(bounds.w > 0) || !(bounds.h > 0)) {
+  const bounds2 = boundsOf(shape.rects);
+  if (!box || !(bounds2.w > 0) || !(bounds2.h > 0)) {
     return;
   }
-  const scale = Math.min(box.w / bounds.w, box.h / bounds.h);
-  const ox = box.x + (box.w - bounds.w * scale) / 2 - bounds.x * scale;
-  const oy = box.y + (box.h - bounds.h * scale) / 2 - bounds.y * scale;
+  const scale = Math.min(box.w / bounds2.w, box.h / bounds2.h);
+  const ox = box.x + (box.w - bounds2.w * scale) / 2 - bounds2.x * scale;
+  const oy = box.y + (box.h - bounds2.h * scale) / 2 - bounds2.y * scale;
   for (const r of shape.rects) {
     r.node.box = { x: ox + r.x * scale, y: oy + r.y * scale, w: r.w * scale, h: r.h * scale };
   }
@@ -20465,20 +20613,20 @@ var UnionFind = class {
   }
 };
 function allNodes(entries) {
-  const roots = /* @__PURE__ */ new Set();
+  const roots2 = /* @__PURE__ */ new Set();
   for (const { node } of entries) {
     let top = node;
     while (top.parent) {
       top = top.parent;
     }
-    roots.add(top);
+    roots2.add(top);
   }
   const out = [];
   const visit = (n2) => {
     out.push(n2);
     n2.children.forEach(visit);
   };
-  roots.forEach(visit);
+  roots2.forEach(visit);
   return out;
 }
 function buildLinks(entries) {
@@ -20557,8 +20705,8 @@ function resolveEngineFonts(entries, metrics) {
     const refSize = (ref) => previous.get(ref) ?? starts.get(ref);
     const sizes = /* @__PURE__ */ new Map();
     for (const entry3 of entries) {
-      const bounds = nodeFontBounds(entry3.node);
-      sizes.set(entry3.node, fitNodeFontPt(entry3.node, entry3.text, bounds, metrics, refSize));
+      const bounds2 = nodeFontBounds(entry3.node);
+      sizes.set(entry3.node, fitNodeFontPt(entry3.node, entry3.text, bounds2, metrics, refSize));
     }
     equalise(sizes, starts, groups, caps);
     resolved = sizes;
@@ -21341,11 +21489,11 @@ function ancestorsOf(node, parentOf) {
   }
   return out;
 }
-function siblingGroupOf(node, parentOf, childrenOf, roots) {
+function siblingGroupOf(node, parentOf, childrenOf, roots2) {
   const parent = parentOf.get(node.id);
-  return parent ? childrenOf.get(parent.id) ?? [] : roots;
+  return parent ? childrenOf.get(parent.id) ?? [] : roots2;
 }
-function navigateAxisHop(current, axis, nodes, childrenOf, parentOf, roots) {
+function navigateAxisHop(current, axis, nodes, childrenOf, parentOf, roots2) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
   const add = (node) => {
@@ -21390,7 +21538,7 @@ function navigateAxisHop(current, axis, nodes, childrenOf, parentOf, roots) {
         break;
       case "followSib":
       case "precedSib": {
-        const siblings = siblingGroupOf(node, parentOf, childrenOf, roots);
+        const siblings = siblingGroupOf(node, parentOf, childrenOf, roots2);
         const index = siblings.findIndex((sibling) => sibling.id === node.id);
         addAll(axis === "followSib" ? siblings.slice(index + 1) : siblings.slice(0, index));
         break;
@@ -21468,30 +21616,30 @@ function resolveAxisNodes(nodes, axis, pointTypes, start, count, context) {
       }
     }
   }
-  const roots = nodes.filter((n2) => !n2.parentId || !byId.has(n2.parentId));
+  const roots2 = nodes.filter((n2) => !n2.parentId || !byId.has(n2.parentId));
   let current;
   let nextHop;
   if (axis[0] === "root" && axis.length > 1) {
-    current = applyPointTypeAndRange(roots, pointTypes?.[1], start?.[1], count?.[1]);
+    current = applyPointTypeAndRange(roots2, pointTypes?.[1], start?.[1], count?.[1]);
     nextHop = 2;
   } else if (axis[0] === "root") {
-    current = applyPointTypeAndRange(roots, pointTypes?.[0], start?.[0], count?.[0]);
+    current = applyPointTypeAndRange(roots2, pointTypes?.[0], start?.[0], count?.[0]);
     nextHop = 1;
   } else if (context !== void 0) {
     current = applyPointTypeAndRange(
-      navigateAxisHop(context, axis[0], nodes, childrenOf, parentOf, roots),
+      navigateAxisHop(context, axis[0], nodes, childrenOf, parentOf, roots2),
       pointTypes?.[0],
       start?.[0],
       count?.[0]
     );
     nextHop = 1;
   } else {
-    current = applyPointTypeAndRange(roots, pointTypes?.[0], start?.[0], count?.[0]);
+    current = applyPointTypeAndRange(roots2, pointTypes?.[0], start?.[0], count?.[0]);
     nextHop = 1;
   }
   for (let hop = nextHop; hop < axis.length; hop += 1) {
     current = applyPointTypeAndRange(
-      navigateAxisHop(current, axis[hop], nodes, childrenOf, parentOf, roots),
+      navigateAxisHop(current, axis[hop], nodes, childrenOf, parentOf, roots2),
       pointTypes?.[hop],
       start?.[hop],
       count?.[hop]
@@ -22671,12 +22819,12 @@ function collectFollowSibNodeCounts(node) {
 function isChildOnlyAxis(iter) {
   return iter.axis?.length === 1 && iter.axis[0] === "ch";
 }
-function selectArrangedNodes(node, flat, roots) {
+function selectArrangedNodes(node, flat, roots2) {
   const iterators = qualifyingIterators(node);
   if (iterators.length === 0) {
-    return roots && roots.length > 1 ? roots : flat;
+    return roots2 && roots2.length > 1 ? roots2 : flat;
   }
-  const base = roots && roots.length > 0 && iterators.every(isChildOnlyAxis) ? roots : flat;
+  const base = roots2 && roots2.length > 0 && iterators.every(isChildOnlyAxis) ? roots2 : flat;
   const indices = /* @__PURE__ */ new Set();
   for (const iter of iterators) {
     for (const i2 of resolveIteratorIndices(iter, base.length)) {
@@ -22709,16 +22857,16 @@ function buildForest(nodes) {
   for (const n2 of nodes) {
     map.set(n2.id, { node: n2, children: [] });
   }
-  const roots = [];
+  const roots2 = [];
   for (const n2 of nodes) {
     const tn = map.get(n2.id);
     if (n2.parentId && map.has(n2.parentId)) {
       map.get(n2.parentId).children.push(tn);
     } else {
-      roots.push(tn);
+      roots2.push(tn);
     }
   }
-  return roots;
+  return roots2;
 }
 function buildTree(nodes) {
   const hasNestedChildren = nodes.some((n2) => n2.children !== void 0 && n2.children.length > 0);
@@ -22730,8 +22878,8 @@ function buildTree(nodes) {
     children: (n2.children ?? []).map(toTreeNode)
   });
   const allIds = new Set(nodes.map((n2) => n2.id));
-  const roots = nodes.filter((n2) => !n2.parentId || !allIds.has(n2.parentId));
-  return roots.map(toTreeNode);
+  const roots2 = nodes.filter((n2) => !n2.parentId || !allIds.has(n2.parentId));
+  return roots2.map(toTreeNode);
 }
 var MAX_TREE_DEPTH = 256;
 function treeWidth(t, depth = 0) {
@@ -22878,8 +23026,8 @@ function resolveRoleFontSize(roleNode, index, items, fontName) {
     void 0
   );
 }
-function fitSharedFontSize(bounds, index, items, fontName, naturalAspect) {
-  const { ceilingPx, floorPx, role } = bounds;
+function fitSharedFontSize(bounds2, index, items, fontName, naturalAspect) {
+  const { ceilingPx, floorPx, role } = bounds2;
   if (items.length === 0) {
     return snapToWholePoint(ceilingPx);
   }
@@ -24376,9 +24524,9 @@ function smartArtChildrenOf(nodes, connections) {
 
 // diagram/layout/smartart-layout-interpreter-arranged-selection.ts
 function selectArrangedPoints(view, plan, nodes, flat, connections) {
-  const roots = topLevelSmartArtNodes(nodes);
+  const roots2 = topLevelSmartArtNodes(nodes);
   const childrenOf = smartArtChildrenOf(nodes, connections);
-  const preArranged = plan.kind === "composite" ? roots.length > 0 ? roots : flat : selectArrangedNodes(plan.node, flat, roots);
+  const preArranged = plan.kind === "composite" ? roots2.length > 0 ? roots2 : flat : selectArrangedNodes(plan.node, flat, roots2);
   const hub = plan.kind === "composite" ? void 0 : detectHubExpansion(view, plan.node, preArranged, childrenOf);
   const arranged = hub ? applyChildOrder(hub.satellites, buildChildOrder(connections)) : preArranged;
   return { childrenOf, hub, arranged };
@@ -25013,10 +25161,10 @@ function arrangeRecursiveTable(view, plan, nodes, box, palette, style, elementId
       childIds.add(c2.id);
     }
   }
-  const roots = nodes.filter((n2) => !childIds.has(n2.id));
+  const roots2 = nodes.filter((n2) => !childIds.has(n2.id));
   const depthOf2 = /* @__PURE__ */ new Map();
   let maxDepth2 = 0;
-  const depthStack = roots.map((r) => ({
+  const depthStack = roots2.map((r) => ({
     node: r,
     depth: 0
   }));
@@ -25058,7 +25206,7 @@ function arrangeRecursiveTable(view, plan, nodes, box, palette, style, elementId
       place(child3, childX, childWidth);
     }
   };
-  for (const [root, rootX, rootWidth] of splitAcross(roots, 0, w)) {
+  for (const [root, rootX, rootWidth] of splitAcross(roots2, 0, w)) {
     place(root, rootX, rootWidth);
   }
   const itemShape = findCompositeItemShape(plan.node);
@@ -27190,13 +27338,13 @@ function allChildrenHangForRoot(root, orgChart, perRow) {
     return r.deepestFanLevel === childLevel;
   });
 }
-function computeHangShape(roots, orgChart, perRow) {
+function computeHangShape(roots2, orgChart, perRow) {
   let fannedGenerations = 1;
   let maxHangDepth = 0;
   let maxHangRows = 0;
   let allChildrenHang = false;
   let hangingColumns = 0;
-  for (const root of roots) {
+  for (const root of roots2) {
     const r = walk2(root, 0, perRow, orgChart, void 0);
     fannedGenerations = Math.max(fannedGenerations, r.deepestFanLevel + 1);
     maxHangDepth = Math.max(maxHangDepth, r.maxHangDepth);
@@ -27229,9 +27377,9 @@ function widthWalk(t, level2, perRow, orgChart, siblingCount, map) {
   map.set(t, width);
   return width;
 }
-function buildFanAwareWidthMap(roots, orgChart, perRow) {
+function buildFanAwareWidthMap(roots2, orgChart, perRow) {
   const map = /* @__PURE__ */ new Map();
-  for (const root of roots) {
+  for (const root of roots2) {
     widthWalk(root, 0, perRow, orgChart, void 0, map);
   }
   return map;
@@ -27343,7 +27491,7 @@ function placeDescendantColumn(hc, node, edgeX, side, y, descW, descH, stackGapP
   }
   return nextY;
 }
-function arrangeFannedHangingForest(view, nodes, box, palette, style, elementId, roots, itemShape, connectorLabels, algorithmNode, index, fontName, presLayoutVars, orgChart) {
+function arrangeFannedHangingForest(view, nodes, box, palette, style, elementId, roots2, itemShape, connectorLabels, algorithmNode, index, fontName, presLayoutVars, orgChart) {
   if (orgChart) {
     return void 0;
   }
@@ -27353,7 +27501,7 @@ function arrangeFannedHangingForest(view, nodes, box, palette, style, elementId,
     index,
     nodes.length,
     presLayoutVars,
-    roots.length,
+    roots2.length,
     box
   );
   if (!geometry) {
@@ -27372,8 +27520,8 @@ function arrangeFannedHangingForest(view, nodes, box, palette, style, elementId,
     resolveHierarchyItemFontSizePx(nodes, algorithmNode, index, descW, descH, fontName)
   );
   const rootChildGap = ROOT_CHILD_GAP_RATIO * descH;
-  const branchCount = roots.length;
-  roots.forEach((root, i2) => {
+  const branchCount = roots2.length;
+  roots2.forEach((root, i2) => {
     const columnIndex = reversed ? branchCount - 1 - i2 : i2;
     const branchX = columnIndex * (rootW + gap);
     pushNode(hc, root.node, branchX, 0, rootW, rootH);
@@ -27446,9 +27594,9 @@ function placeHangingTree(hc, t, x, options, cursor, size, level2 = 0) {
     placeHangingTree(hc, child3, childX, options, cursor, void 0, level2 + 1);
   }
 }
-function placeHangingForest(hc, roots, startX, startY, options, rootSize) {
+function placeHangingForest(hc, roots2, startX, startY, options, rootSize) {
   const cursor = { y: startY };
-  for (const root of roots) {
+  for (const root of roots2) {
     placeHangingTree(hc, root, startX, options, cursor, rootSize);
   }
 }
@@ -27530,16 +27678,16 @@ function countRows(t, level2, orgChart, fold) {
   }
   return count;
 }
-function countHangingRows(roots, orgChart, fold) {
-  return roots.reduce((sum, root) => sum + countRows(root, 0, orgChart, fold), 0);
+function countHangingRows(roots2, orgChart, fold) {
+  return roots2.reduce((sum, root) => sum + countRows(root, 0, orgChart, fold), 0);
 }
 
 // diagram/hierarchy/smartart-hierarchy-hanging-arrange.ts
 var HANGING_MODE_INSET = 6;
-function arrangeFullyHangingTree(view, nodes, box, palette, style, elementId, roots, itemShape, connectorLabels, algorithmNode, index, fontName, linDir, orgChart, presLayoutVars, cornerSide) {
+function arrangeFullyHangingTree(view, nodes, box, palette, style, elementId, roots2, itemShape, connectorLabels, algorithmNode, index, fontName, linDir, orgChart, presLayoutVars, cornerSide) {
   const { width: w, height: h2 } = box;
   const foldDeeperGenerations = algorithmNode ? hierarchyLeafFoldsDescendants(algorithmNode) : false;
-  const rows = countHangingRows(roots, orgChart, foldDeeperGenerations);
+  const rows = countHangingRows(roots2, orgChart, foldDeeperGenerations);
   const fit2 = fitHangingBox(view, algorithmNode, index, w, h2, rows, nodes.length, presLayoutVars);
   const { boxW, boxH, vGap } = fit2;
   const indent = boxW * 0.35;
@@ -27562,7 +27710,7 @@ function arrangeFullyHangingTree(view, nodes, box, palette, style, elementId, ro
   } : void 0;
   placeHangingForest(
     hc,
-    roots,
+    roots2,
     HANGING_MODE_INSET + indent,
     columnAlign ? 0 : HANGING_MODE_INSET,
     {
@@ -27585,8 +27733,8 @@ function arrangeFullyHangingTree(view, nodes, box, palette, style, elementId, ro
 }
 
 // diagram/hierarchy/smartart-hierarchy-hang-dispatch.ts
-function dispatchHangingMode(view, nodes, box, palette, style, elementId, roots, itemShape, connectorLabels, algorithmNode, index, fontName, presLayoutVars, orgChart, cornerPlan) {
-  if (roots.length > 1) {
+function dispatchHangingMode(view, nodes, box, palette, style, elementId, roots2, itemShape, connectorLabels, algorithmNode, index, fontName, presLayoutVars, orgChart, cornerPlan) {
+  if (roots2.length > 1) {
     const fanned = arrangeFannedHangingForest(
       view,
       nodes,
@@ -27594,7 +27742,7 @@ function dispatchHangingMode(view, nodes, box, palette, style, elementId, roots,
       palette,
       style,
       elementId,
-      roots,
+      roots2,
       itemShape,
       connectorLabels,
       algorithmNode,
@@ -27614,7 +27762,7 @@ function dispatchHangingMode(view, nodes, box, palette, style, elementId, roots,
     palette,
     style,
     elementId,
-    roots,
+    roots2,
     itemShape,
     connectorLabels,
     algorithmNode,
@@ -28393,7 +28541,7 @@ function arrangeHierarchy(view, nodes, box, palette, style, elementId, presLayou
   const { width: w, height: h2 } = box;
   const orgChart = presLayoutVars?.orgChart === true;
   const orderedNodes = applyChildOrder(nodes, childOrder);
-  const roots = buildTree(flattenOrgChartGroupWrappers(orderedNodes, orgChart));
+  const roots2 = buildTree(flattenOrgChartGroupWrappers(orderedNodes, orgChart));
   const cornerPlan = resolveCornerHangPlan(
     view,
     algorithmNode,
@@ -28411,7 +28559,7 @@ function arrangeHierarchy(view, nodes, box, palette, style, elementId, presLayou
       palette,
       style,
       elementId,
-      roots,
+      roots2,
       itemShape,
       connectorLabels,
       algorithmNode,
@@ -28431,14 +28579,14 @@ function arrangeHierarchy(view, nodes, box, palette, style, elementId, presLayou
     presLayoutVars,
     box
   );
-  const rawDepth = roots.length > 0 ? Math.max(...roots.map((r) => treeDepth(r))) : 1;
+  const rawDepth = roots2.length > 0 ? Math.max(...roots2.map((r) => treeDepth(r))) : 1;
   const rowSize = resolveRowSize(presLayoutVars);
   const noHang = { maxHangDepth: 0, maxHangRows: 0, allChildrenHang: false, hangingColumns: 0 };
-  const hangShape = mode === "tailed" ? computeHangShape(roots, orgChart, rowSize) : { fannedGenerations: rawDepth, ...noHang };
+  const hangShape = mode === "tailed" ? computeHangShape(roots2, orgChart, rowSize) : { fannedGenerations: rawDepth, ...noHang };
   const depth = hangShape.fannedGenerations;
-  const fanAwareWidthMap = mode === "tailed" ? buildFanAwareWidthMap(roots, orgChart, rowSize) : void 0;
+  const fanAwareWidthMap = mode === "tailed" ? buildFanAwareWidthMap(roots2, orgChart, rowSize) : void 0;
   const spanOfRoot = (r) => resolveSpanWidth(fanAwareWidthMap, r, orgChart);
-  const totalLeaves = roots.reduce((sum, r) => sum + spanOfRoot(r), 0);
+  const totalLeaves = roots2.reduce((sum, r) => sum + spanOfRoot(r), 0);
   const { boxW, boxH } = fitItemBox(
     effectiveBox,
     totalLeaves,
@@ -28505,7 +28653,7 @@ function arrangeHierarchy(view, nodes, box, palette, style, elementId, presLayou
     orgChart
   );
   let offset = 0;
-  for (const root of roots) {
+  for (const root of roots2) {
     placeStandardTree(hc, root, offset, 0, cellW, cellH, standardOptions);
     offset += spanOfRoot(root);
   }
@@ -32900,6 +33048,7 @@ __export(geometry_exports, {
   FLOWCHART_PRESET_DEFINITIONS: () => FLOWCHART_PRESET_DEFINITIONS,
   FLOWCHART_TEXT_RECTS: () => FLOWCHART_TEXT_RECTS,
   GEAR9_CONNECTION_SITES: () => GEAR9_CONNECTION_SITES,
+  GRAPH_LAYOUT_STYLES: () => GRAPH_LAYOUT_STYLES,
   IDENTITY_AFFINE: () => IDENTITY_AFFINE,
   LEFT_CIRCULAR_ARROW_CONNECTION_SITES: () => LEFT_CIRCULAR_ARROW_CONNECTION_SITES,
   LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES: () => LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES,
@@ -32936,6 +33085,7 @@ __export(geometry_exports, {
   alignElements: () => alignElements,
   angleToRadians: () => angleToRadians,
   at: () => at,
+  autoAlignBoxes: () => autoAlignBoxes,
   buildCalloutLeaderLineSvgPath: () => buildCalloutLeaderLineSvgPath,
   clipPolygons: () => clipPolygons,
   combineShapes: () => combineShapes,
@@ -32985,6 +33135,7 @@ __export(geometry_exports, {
   isConvex: () => isConvex,
   isHorizontalPrimaryAxis: () => isHorizontalPrimaryAxis,
   isStShapeType: () => isStShapeType,
+  layoutGraph: () => layoutGraph,
   lineIntersection: () => lineIntersection,
   lookupPresetConnectionSites: () => lookupPresetConnectionSites,
   lookupPresetTextRectOverride: () => lookupPresetTextRectOverride,
@@ -39227,11 +39378,11 @@ function createRotationDrag(center, startPointer, startRotation, options = {}) {
 
 // geometry/rotate-handle-placement.ts
 function resolveRotateHandlePlacement(input) {
-  const { preferred, selection, bounds, hitWidth, hitHeight, obstacles } = input;
+  const { preferred, selection, bounds: bounds2, hitWidth, hitHeight, obstacles } = input;
   if (![
     ...Object.values(preferred),
     ...Object.values(selection),
-    ...Object.values(bounds),
+    ...Object.values(bounds2),
     hitWidth,
     hitHeight
   ].every(Number.isFinite) || hitWidth <= 0 || hitHeight <= 0) {
@@ -39245,7 +39396,7 @@ function resolveRotateHandlePlacement(input) {
   };
   const fits3 = ({ x, y }) => {
     const rect3 = { left: x - halfX, right: x + halfX, top: y - halfY, bottom: y + halfY };
-    return rect3.left >= bounds.left + 1 && rect3.right <= bounds.right - 1 && rect3.top >= bounds.top + 1 && rect3.bottom <= bounds.bottom - 1 && // A target over the rotation center has no usable initial bearing.
+    return rect3.left >= bounds2.left + 1 && rect3.right <= bounds2.right - 1 && rect3.top >= bounds2.top + 1 && rect3.bottom <= bounds2.bottom - 1 && // A target over the rotation center has no usable initial bearing.
     !(center.x >= rect3.left && center.x <= rect3.right && center.y >= rect3.top && center.y <= rect3.bottom) && !obstacles.some(
       (other) => rect3.left < other.right + 2 && rect3.right > other.left - 2 && rect3.top < other.bottom + 2 && rect3.bottom > other.top - 2
     );
@@ -39273,10 +39424,10 @@ function resolveRotateHandlePlacement(input) {
     { x: center.x, y: selection.bottom + padY },
     { x: selection.left - padX, y: center.y }
   ];
-  const left = Math.max(selection.left, bounds.left) + halfX + 3;
-  const right = Math.min(selection.right, bounds.right) - halfX - 3;
-  const top = Math.max(selection.top, bounds.top) + halfY + 3;
-  const bottom = Math.min(selection.bottom, bounds.bottom) - halfY - 3;
+  const left = Math.max(selection.left, bounds2.left) + halfX + 3;
+  const right = Math.min(selection.right, bounds2.right) - halfX - 3;
+  const top = Math.max(selection.top, bounds2.top) + halfY + 3;
+  const bottom = Math.min(selection.bottom, bounds2.bottom) - halfY - 3;
   if (left <= right && top <= bottom) {
     for (const fraction of [0.25, 0.75]) {
       const x = left + (right - left) * fraction;
@@ -39290,6 +39441,357 @@ function resolveRotateHandlePlacement(input) {
   })[0] ?? null;
 }
 
+// geometry/graph-layout.ts
+var GRAPH_LAYOUT_STYLES = [
+  "flowchart-tb",
+  "flowchart-lr",
+  "hierarchy",
+  "compact-tree",
+  "circular"
+];
+function components(graph) {
+  const seen = /* @__PURE__ */ new Set();
+  const connected = [];
+  const isolated = [];
+  for (const node of graph.nodes) {
+    if (seen.has(node.id)) continue;
+    const ids = [];
+    const stack = [node.id];
+    seen.add(node.id);
+    while (stack.length) {
+      const id = stack.pop();
+      ids.push(id);
+      for (const next of [...graph.out.get(id), ...graph.into.get(id)])
+        if (!seen.has(next)) {
+          seen.add(next);
+          stack.push(next);
+        }
+    }
+    if (ids.length === 1) isolated.push(node.id);
+    else {
+      const order = new Map(graph.nodes.map((entry3, index) => [entry3.id, index]));
+      connected.push(ids.sort((a2, b) => order.get(a2) - order.get(b)));
+    }
+  }
+  return { connected, isolated };
+}
+function roots(ids, graph) {
+  const found = ids.filter((id) => !graph.into.get(id).some((from) => ids.includes(from)));
+  return found.length ? found : [ids[0]];
+}
+function forwardEdges(ids, graph) {
+  const state = /* @__PURE__ */ new Map();
+  const forward = new Map(ids.map((id) => [id, []]));
+  const visit = (start) => {
+    const stack = [{ id: start, next: 0 }];
+    state.set(start, 1);
+    while (stack.length) {
+      const top = stack.at(-1);
+      const targets = graph.out.get(top.id);
+      if (top.next >= targets.length) {
+        state.set(top.id, 2);
+        stack.pop();
+        continue;
+      }
+      const target = targets[top.next++];
+      const mark = state.get(target);
+      if (mark === 1) continue;
+      forward.get(top.id).push(target);
+      if (mark === void 0) {
+        state.set(target, 1);
+        stack.push({ id: target, next: 0 });
+      }
+    }
+  };
+  for (const root of roots(ids, graph)) if (!state.has(root)) visit(root);
+  for (const id of ids) if (!state.has(id)) visit(id);
+  return forward;
+}
+function layers(ids, forward, shortest) {
+  const rank = /* @__PURE__ */ new Map();
+  const incoming = new Map(ids.map((id) => [id, 0]));
+  for (const targets of forward.values())
+    for (const target of targets) incoming.set(target, incoming.get(target) + 1);
+  const queue = ids.filter((id) => incoming.get(id) === 0);
+  for (const id of queue) rank.set(id, 0);
+  for (let index = 0; index < queue.length; index++) {
+    const id = queue[index];
+    for (const target of forward.get(id)) {
+      const candidate = rank.get(id) + 1;
+      if (shortest) {
+        if (!rank.has(target)) rank.set(target, candidate);
+      } else rank.set(target, Math.max(rank.get(target) ?? 0, candidate));
+      incoming.set(target, incoming.get(target) - 1);
+      if (incoming.get(target) === 0) queue.push(target);
+    }
+  }
+  const result = [];
+  for (const id of ids) {
+    const level2 = rank.get(id) ?? 0;
+    (result[level2] ??= []).push(id);
+  }
+  return result.filter((layer) => layer.length);
+}
+function orderLayers(layered, graph) {
+  const result = layered.map((layer) => [...layer]);
+  const position = /* @__PURE__ */ new Map();
+  const index = () => result.forEach((layer) => layer.forEach((id, at2) => position.set(id, at2)));
+  index();
+  for (let sweep = 0; sweep < 4; sweep++) {
+    const down = sweep % 2 === 0;
+    const range = down ? result.map((_, at2) => at2).slice(1) : result.map((_, at2) => at2).slice(0, -1).reverse();
+    for (const at2 of range) {
+      const neighbour = new Set(result[down ? at2 - 1 : at2 + 1]);
+      const weight = (id) => {
+        const linked = [...graph.out.get(id), ...graph.into.get(id)].filter(
+          (other) => neighbour.has(other)
+        );
+        return linked.length ? linked.reduce((sum, other) => sum + position.get(other), 0) / linked.length : position.get(id);
+      };
+      const weights = new Map(result[at2].map((id) => [id, weight(id)]));
+      result[at2].sort(
+        (a2, b) => weights.get(a2) - weights.get(b) || position.get(a2) - position.get(b)
+      );
+      index();
+    }
+  }
+  return result;
+}
+function placeLayers(ordered2, size, horizontal, spacing3, layerSpacing) {
+  const placed = [];
+  const along = (node) => horizontal ? node.width : node.height;
+  const across = (node) => horizontal ? node.height : node.width;
+  let cursor = 0;
+  for (const layer of ordered2) {
+    const nodes = layer.map((id) => size.get(id));
+    const depth = Math.max(...nodes.map(along));
+    const span = nodes.reduce((sum, node) => sum + across(node), 0) + spacing3 * (nodes.length - 1);
+    let offset = -span / 2;
+    for (const node of nodes) {
+      const centre = offset + across(node) / 2;
+      const primary = cursor + depth / 2;
+      placed.push({
+        id: node.id,
+        x: horizontal ? primary : centre,
+        y: horizontal ? centre : primary,
+        width: node.width,
+        height: node.height
+      });
+      offset += across(node) + spacing3;
+    }
+    cursor += depth + layerSpacing;
+  }
+  return placed;
+}
+function placeCompactTree(ids, forward, graph, size, spacing3, layerSpacing) {
+  const placed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const indent = Math.max(...ids.map((id) => size.get(id).width)) / 2 + layerSpacing / 2;
+  let y = 0;
+  const visit = (start) => {
+    const stack = [{ id: start, depth: 0 }];
+    while (stack.length) {
+      const { id, depth } = stack.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const node = size.get(id);
+      placed.push({
+        id,
+        x: depth * indent + node.width / 2,
+        y: y + node.height / 2,
+        width: node.width,
+        height: node.height
+      });
+      y += node.height + spacing3;
+      const children2 = forward.get(id).filter((child3) => !seen.has(child3));
+      for (const child3 of children2.reverse()) stack.push({ id: child3, depth: depth + 1 });
+    }
+  };
+  for (const root of roots(ids, graph)) visit(root);
+  for (const id of ids) visit(id);
+  return placed;
+}
+function placeCircle(ids, forward, size, spacing3) {
+  const order = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const start of ids) {
+    const stack = [start];
+    while (stack.length) {
+      const id = stack.pop();
+      if (seen.has(id)) continue;
+      seen.add(id);
+      order.push(id);
+      stack.push(...[...forward.get(id)].reverse());
+    }
+  }
+  const extent = (id) => Math.hypot(size.get(id).width, size.get(id).height);
+  const circumference = order.reduce((sum, id) => sum + extent(id) + spacing3, 0);
+  const radius = Math.max(circumference / (2 * Math.PI), Math.max(...order.map(extent)));
+  return order.map((id, index) => {
+    const angle = -Math.PI / 2 + 2 * Math.PI * index / order.length;
+    const node = size.get(id);
+    return {
+      id,
+      x: radius * Math.cos(angle),
+      y: radius * Math.sin(angle),
+      width: node.width,
+      height: node.height
+    };
+  });
+}
+function bounds(placed) {
+  const left = Math.min(...placed.map((box) => box.x - box.width / 2));
+  const top = Math.min(...placed.map((box) => box.y - box.height / 2));
+  const right = Math.max(...placed.map((box) => box.x + box.width / 2));
+  const bottom = Math.max(...placed.map((box) => box.y + box.height / 2));
+  return { left, top, width: right - left, height: bottom - top };
+}
+function placeGrid(ids, size, spacing3) {
+  const columns = Math.ceil(Math.sqrt(ids.length));
+  const cellWidth = Math.max(...ids.map((id) => size.get(id).width));
+  const cellHeight = Math.max(...ids.map((id) => size.get(id).height));
+  return ids.map((id, index) => ({
+    id,
+    x: index % columns * (cellWidth + spacing3) + cellWidth / 2,
+    y: Math.floor(index / columns) * (cellHeight + spacing3) + cellHeight / 2,
+    width: size.get(id).width,
+    height: size.get(id).height
+  }));
+}
+function layoutGraph(nodes, edges, style, options = {}) {
+  if (!GRAPH_LAYOUT_STYLES.includes(style)) throw new Error("Unknown graph layout style.");
+  const spacing3 = options.spacing ?? 0.5;
+  const layerSpacing = options.layerSpacing ?? spacing3;
+  if (![spacing3, layerSpacing].every((value) => Number.isFinite(value) && value >= 0))
+    throw new Error("Layout spacing must be finite and not negative.");
+  const size = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (size.has(node.id)) throw new Error("Layout node IDs must be unique.");
+    if (![node.width, node.height].every((value) => Number.isFinite(value) && value >= 0))
+      throw new Error("Layout node sizes must be finite and not negative.");
+    size.set(node.id, node);
+  }
+  const graph = {
+    nodes,
+    out: new Map(nodes.map((node) => [node.id, []])),
+    into: new Map(nodes.map((node) => [node.id, []]))
+  };
+  for (const edge of edges) {
+    if (!size.has(edge.from) || !size.has(edge.to) || edge.from === edge.to) continue;
+    if (graph.out.get(edge.from).includes(edge.to)) continue;
+    graph.out.get(edge.from).push(edge.to);
+    graph.into.get(edge.to).push(edge.from);
+  }
+  const { connected, isolated } = components(graph);
+  const horizontal = style === "flowchart-lr";
+  const blocks = connected.map((ids) => {
+    const forward = forwardEdges(ids, graph);
+    if (style === "circular") return placeCircle(ids, forward, size, spacing3);
+    if (style === "compact-tree")
+      return placeCompactTree(ids, forward, graph, size, spacing3, layerSpacing);
+    const ordered2 = orderLayers(layers(ids, forward, style === "hierarchy"), graph);
+    return placeLayers(ordered2, size, horizontal, spacing3, layerSpacing);
+  });
+  const result = /* @__PURE__ */ new Map();
+  let cursor = 0;
+  let extent = 0;
+  for (const block of blocks) {
+    const box = bounds(block);
+    for (const item of block)
+      result.set(item.id, {
+        x: item.x - box.left + (horizontal ? 0 : cursor),
+        y: item.y - box.top + (horizontal ? cursor : 0)
+      });
+    cursor += (horizontal ? box.height : box.width) + spacing3 * 2;
+    extent = Math.max(extent, horizontal ? box.width : box.height);
+  }
+  if (isolated.length) {
+    const grid = placeGrid(isolated, size, spacing3);
+    const offset = blocks.length ? extent + layerSpacing * 2 : 0;
+    for (const item of grid)
+      result.set(item.id, {
+        x: item.x + (horizontal ? offset : 0),
+        y: item.y + (horizontal ? 0 : offset)
+      });
+  }
+  return result;
+}
+
+// geometry/auto-align.ts
+var median = (values) => {
+  const sorted = [...values].sort((a2, b) => a2 - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+};
+function clusters(boxes, centre, tolerance) {
+  const sorted = [...boxes].sort((a2, b) => centre(a2) - centre(b));
+  const result = [];
+  let mean = 0;
+  for (const box of sorted) {
+    const current = result.at(-1);
+    if (current && Math.abs(centre(box) - mean) <= tolerance) {
+      current.push(box);
+      mean += (centre(box) - mean) / current.length;
+    } else {
+      result.push([box]);
+      mean = centre(box);
+    }
+  }
+  return result;
+}
+function space2(groups, start, size, minimumGap) {
+  const extents = groups.map((group) => {
+    const centre = group.reduce((sum, box) => sum + start(box) + size(box) / 2, 0) / group.length;
+    const half = Math.max(...group.map((box) => size(box) / 2));
+    return { centre, half };
+  });
+  const gaps = extents.slice(1).map(
+    (extent, index) => extent.centre - extent.half - extents[index].centre - extents[index].half
+  );
+  const gap = Math.max(
+    minimumGap,
+    gaps.length ? gaps.reduce((sum, value) => sum + value, 0) / gaps.length : 0
+  );
+  const result = /* @__PURE__ */ new Map();
+  let cursor = extents[0] ? extents[0].centre - extents[0].half : 0;
+  groups.forEach((group, index) => {
+    const { half } = extents[index];
+    for (const box of group) result.set(box.id, cursor + half);
+    cursor += half * 2 + gap;
+  });
+  return result;
+}
+function autoAlignBoxes(boxes, options = {}) {
+  if (new Set(boxes.map((box) => box.id)).size !== boxes.length)
+    throw new Error("Auto align box IDs must be unique.");
+  if (!boxes.every(
+    (box) => [box.x, box.y, box.width, box.height].every((value) => Number.isFinite(value))
+  ))
+    throw new Error("Auto align boxes must be finite.");
+  const result = /* @__PURE__ */ new Map();
+  if (!boxes.length) return result;
+  const toleranceX = options.tolerance?.x ?? median(boxes.map((box) => box.width)) / 2;
+  const toleranceY = options.tolerance?.y ?? median(boxes.map((box) => box.height)) / 2;
+  const minimumGap = options.minimumGap ?? 0;
+  const rows = clusters(boxes, (box) => box.y + box.height / 2, toleranceY);
+  const columns = clusters(boxes, (box) => box.x + box.width / 2, toleranceX);
+  const ys = space2(
+    rows,
+    (box) => box.y,
+    (box) => box.height,
+    minimumGap
+  );
+  const xs = space2(
+    columns,
+    (box) => box.x,
+    (box) => box.width,
+    minimumGap
+  );
+  for (const box of boxes)
+    result.set(box.id, { x: xs.get(box.id) - box.width / 2, y: ys.get(box.id) - box.height / 2 });
+  return result;
+}
+
 // units/index.ts
 var units_exports = {};
 __export(units_exports, {
@@ -40634,9 +41136,9 @@ function convertOmmlToLatex(omml) {
     return "";
   }
   const para = omml["m:oMathPara"];
-  const roots = para ? ensureArr(para).flatMap((p) => ensureArr(p["m:oMath"])) : [];
-  if (roots.length > 0) {
-    return roots.map((root) => childrenToLatex(root)).join(" ");
+  const roots2 = para ? ensureArr(para).flatMap((p) => ensureArr(p["m:oMath"])) : [];
+  if (roots2.length > 0) {
+    return roots2.map((root) => childrenToLatex(root)).join(" ");
   }
   if (omml["m:oMath"]) {
     return ensureArr(omml["m:oMath"]).map((root) => childrenToLatex(root)).join(" ");