ooxml-core 1.5.0 → 1.6.1

package/dist/drawingml/index.mjs

@@ -838,7 +838,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 list = first(root, "gsLst", NS.a);
   if (!list) {
     list = doc.createElementNS(NS.a, "a:gsLst");
@@ -853,7 +853,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)) list.removeChild(stop);
   for (const node of elements(root))
@@ -903,6 +903,105 @@ function drawingFillXml(fill) {
   return buildXml(doc);
 }
 
+// drawingml/theme-model.ts
+var THEME_COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_THEME_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+
+// 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 extensionList(parent, extensions, namespaces) {
+  const entries = Object.entries(extensions ?? {});
+  if (!entries.length) return;
+  const doc = parent.ownerDocument;
+  const list = 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);
+    list.appendChild(ext);
+  }
+  parent.appendChild(list);
+}
+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 slot of THEME_COLOR_SLOTS) {
+    const color = theme.colorScheme.colors[slot];
+    if (!color) throw new Error(`The theme colour scheme has no ${slot} colour.`);
+    const node = doc.createElementNS(NS.a, `a:${slot}`);
+    for (const child of fragment(node, drawingColorXml(color), namespaces)) node.appendChild(child);
+    scheme.appendChild(node);
+  }
+  extensionList(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]);
+  extensionList(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 = [
   [
@@ -1357,28 +1456,6 @@ function buildRectPathGradientImage(stops, focalPoint, fillToRect) {
   return `url("data:image/svg+xml,${encodeURIComponent(markup)}")`;
 }
 
-// drawingml/theme-model.ts
-var THEME_COLOR_SLOTS = [
-  "dk1",
-  "lt1",
-  "dk2",
-  "lt2",
-  "accent1",
-  "accent2",
-  "accent3",
-  "accent4",
-  "accent5",
-  "accent6",
-  "hlink",
-  "folHlink"
-];
-var DEFAULT_THEME_COLOR_MAP = {
-  bg1: "lt1",
-  tx1: "dk1",
-  bg2: "lt2",
-  tx2: "dk2"
-};
-
 // drawingml/theme.ts
 var MAP_KEYS = [
   "bg1",
@@ -1494,4 +1571,4 @@ function themeDrawingColorTheme(scheme, colorMap) {
   };
 }
 
-export { DEFAULT_THEME_COLOR_MAP, OFFICE_GRADIENT_PRESETS, RECT_GRADIENT_DIRECTIONS, THEME_COLOR_SLOTS, attributeReader, booleanAttribute, buildRectPathGradientImage, buildRectPathGradientSvg, descendants, drawingColorBrightness, drawingColorCss, drawingColorXml, drawingFillXml, fillElementOf, integerAttribute, isThemeColorSlot, officeGradientPresetFill, officeGradientPresetId, orderedColorTransforms, parseDrawingColor, parseDrawingColorIn, parseDrawingColorList, parseDrawingFill, parseDrawingGeometry, parseDrawingLine, parseDrawingTextBody, parseFrame, parseTheme, parseThemeColorMap, parseThemeColorScheme, parseThemeFontScheme, parseThemeXml, parseTransform, rectGradientDirection, rectGradientFocus, resolveDrawingColor, resolveDrawingShadow, resolveDrawingShadowXml, resolveSchemeColor, setDrawingFillXml, stringAttribute, svgDropShadowElement, themeColorSlotFor, themeDrawingColorTheme, themeSlotHex, withDrawingColorBrightness, withDrawingGradientGeometry };
+export { DEFAULT_THEME_COLOR_MAP, OFFICE_GRADIENT_PRESETS, RECT_GRADIENT_DIRECTIONS, THEME_COLOR_SLOTS, attributeReader, booleanAttribute, buildRectPathGradientImage, buildRectPathGradientSvg, descendants, drawingColorBrightness, drawingColorCss, drawingColorXml, drawingFillXml, drawingThemeXml, fillElementOf, integerAttribute, isThemeColorSlot, officeGradientPresetFill, officeGradientPresetId, orderedColorTransforms, parseDrawingColor, parseDrawingColorIn, parseDrawingColorList, parseDrawingFill, parseDrawingGeometry, parseDrawingLine, parseDrawingTextBody, parseFrame, parseTheme, parseThemeColorMap, parseThemeColorScheme, parseThemeFontScheme, parseThemeXml, parseTransform, rectGradientDirection, rectGradientFocus, resolveDrawingColor, resolveDrawingShadow, resolveDrawingShadowXml, resolveSchemeColor, setDrawingFillXml, stringAttribute, svgDropShadowElement, themeColorSlotFor, themeDrawingColorTheme, themeSlotHex, withDrawingColorBrightness, withDrawingGradientGeometry };

package/dist/drawingml/write-theme.d.ts

@@ -0,0 +1,17 @@
+import { type DrawingTheme } from './theme-model.js';
+export interface DrawingThemeXmlParts {
+    /** The `a:fmtScheme` element (required by the schema), as one `a:` fragment. */
+    formatScheme: string;
+    /** Children of an `a:ext` appended to `a:clrScheme`, keyed by extension URI. */
+    colorSchemeExtensions?: Readonly<Record<string, string>>;
+    /** Children of an `a:ext` appended to `a:themeElements`, keyed by extension URI. */
+    themeElementsExtensions?: Readonly<Record<string, string>>;
+    /** Extra namespace prefixes the fragments use (the `a` prefix is always declared). */
+    namespaces?: Readonly<Record<string, string>>;
+}
+/**
+ * A complete `a:theme` part. Every one of the twelve colour slots must be present in the model;
+ * the format scheme and extensions are product data and are copied as given.
+ */
+export declare function drawingThemeXml(theme: DrawingTheme, parts: DrawingThemeXmlParts): string;
+//# sourceMappingURL=write-theme.d.ts.map

package/dist/drawingml/write-theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-theme.d.ts","sourceRoot":"","sources":["../../drawingml/write-theme.ts"],"names":[],"mappings":"AAKA,OAAO,EAAqB,KAAK,YAAY,EAA4B,MAAM,eAAe,CAAC;AAE/F,MAAM,WAAW,oBAAoB;IACpC,gFAAgF;IAChF,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,qBAAqB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACzD,oFAAoF;IACpF,uBAAuB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC3D,sFAAsF;IACtF,UAAU,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAC9C;AAuDD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAuCxF"}

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

@@ -0,0 +1,32 @@
+/**
+ * Format-neutral "Auto Align & Space": boxes whose centres nearly line up are snapped into
+ * shared rows and columns, then the rows and columns are spaced evenly.
+ *
+ * Boxes use `{ x, y }` as the top-left corner with y growing downward. Clustering compares
+ * centres: a centre joins the current row (column) while it stays within `tolerance` of that
+ * row's mean centre; the default tolerance is half the median box height (width). Rows keep the
+ * top of the first row and columns the left of the first column; the gap between neighbouring
+ * rows (columns) becomes their current average gap, clamped to at least `minimumGap`.
+ */
+export interface AutoAlignBox {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface AutoAlignOptions {
+    /** Centre distance that still counts as the same row or column. */
+    tolerance?: {
+        x?: number;
+        y?: number;
+    };
+    /** Smallest gap kept between rows and between columns. */
+    minimumGap?: number;
+}
+/** New top-left corners for every box. Boxes need not overlap-free input; ids must be unique. */
+export declare function autoAlignBoxes(boxes: readonly AutoAlignBox[], options?: AutoAlignOptions): Map<string, {
+    x: number;
+    y: number;
+}>;
+//# sourceMappingURL=auto-align.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"auto-align.d.ts","sourceRoot":"","sources":["../../geometry/auto-align.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,YAAY;IAC5B,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;AACD,MAAM,WAAW,gBAAgB;IAChC,mEAAmE;IACnE,SAAS,CAAC,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACvC,0DAA0D;IAC1D,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AA8DD,iGAAiG;AACjG,wBAAgB,cAAc,CAC7B,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,OAAO,GAAE,gBAAqB,GAC5B,GAAG,CAAC,MAAM,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA+BvC"}

package/dist/geometry/graph-layout.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Format-neutral automatic layout of a directed graph of boxes: layered (a small Sugiyama
+ * variant for flowcharts and hierarchies), an indented compact tree and a circle per connected
+ * component. Unconnected boxes are placed in a grid after the connected ones.
+ *
+ * Coordinates are abstract units with y growing downward; results are box centres relative to
+ * the top-left corner of the whole layout. No DOM and no format semantics: callers map their
+ * own shapes and connections in and apply the positions themselves.
+ */
+export interface GraphLayoutNode {
+    id: string;
+    width: number;
+    height: number;
+}
+/** A directed connection; edges naming unknown nodes, self loops and duplicates are ignored. */
+export interface GraphLayoutEdge {
+    from: string;
+    to: string;
+}
+export type GraphLayoutStyle = 'flowchart-tb' | 'flowchart-lr' | 'hierarchy' | 'compact-tree' | 'circular';
+export declare const GRAPH_LAYOUT_STYLES: readonly GraphLayoutStyle[];
+export interface GraphLayoutOptions {
+    /** Gap between neighbouring boxes in the same layer, row or circle. */
+    spacing?: number;
+    /** Gap between layers (or tree levels). Defaults to `spacing`. */
+    layerSpacing?: number;
+}
+export interface GraphLayoutPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Lay out every node. Components are packed side by side (stacked for left-to-right flowcharts),
+ * then unconnected nodes follow in a grid. Returns centres relative to the layout's top left.
+ */
+export declare function layoutGraph(nodes: readonly GraphLayoutNode[], edges: readonly GraphLayoutEdge[], style: GraphLayoutStyle, options?: GraphLayoutOptions): Map<string, GraphLayoutPoint>;
+//# sourceMappingURL=graph-layout.d.ts.map

package/dist/geometry/graph-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-layout.d.ts","sourceRoot":"","sources":["../../geometry/graph-layout.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AACD,gGAAgG;AAChG,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACX;AACD,MAAM,MAAM,gBAAgB,GACzB,cAAc,GACd,cAAc,GACd,WAAW,GACX,cAAc,GACd,UAAU,CAAC;AACd,eAAO,MAAM,mBAAmB,EAAE,SAAS,gBAAgB,EAM1D,CAAC;AACF,MAAM,WAAW,kBAAkB;IAClC,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AACD,MAAM,WAAW,gBAAgB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AA+QD;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,KAAK,EAAE,SAAS,eAAe,EAAE,EACjC,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,kBAAuB,GAC9B,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAyD/B"}

package/dist/geometry/index.cjs

@@ -15478,11 +15478,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) {
@@ -15496,7 +15496,7 @@ function resolveRotateHandlePlacement(input) {
   };
   const fits = ({ x, y }) => {
     const rect2 = { left: x - halfX, right: x + halfX, top: y - halfY, bottom: y + halfY };
-    return rect2.left >= bounds.left + 1 && rect2.right <= bounds.right - 1 && rect2.top >= bounds.top + 1 && rect2.bottom <= bounds.bottom - 1 && // A target over the rotation center has no usable initial bearing.
+    return rect2.left >= bounds2.left + 1 && rect2.right <= bounds2.right - 1 && rect2.top >= bounds2.top + 1 && rect2.bottom <= bounds2.bottom - 1 && // A target over the rotation center has no usable initial bearing.
     !(center.x >= rect2.left && center.x <= rect2.right && center.y >= rect2.top && center.y <= rect2.bottom) && !obstacles.some(
       (other) => rect2.left < other.right + 2 && rect2.right > other.left - 2 && rect2.top < other.bottom + 2 && rect2.bottom > other.top - 2
     );
@@ -15524,10 +15524,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;
@@ -15541,6 +15541,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((entry, index) => [entry.id, index]));
+      connected.push(ids.sort((a, b) => order.get(a) - 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 level = rank.get(id) ?? 0;
+    (result[level] ??= []).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(
+        (a, b) => weights.get(a) - weights.get(b) || position.get(a) - position.get(b)
+      );
+      index();
+    }
+  }
+  return result;
+}
+function placeLayers(ordered, size, horizontal, spacing, 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 ordered) {
+    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) + spacing * (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) + spacing;
+    }
+    cursor += depth + layerSpacing;
+  }
+  return placed;
+}
+function placeCompactTree(ids, forward, graph, size, spacing, 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 + spacing;
+      const children = forward.get(id).filter((child) => !seen.has(child));
+      for (const child of children.reverse()) stack.push({ id: child, 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, spacing) {
+  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) + spacing, 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, spacing) {
+  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 + spacing) + cellWidth / 2,
+    y: Math.floor(index / columns) * (cellHeight + spacing) + 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 spacing = options.spacing ?? 0.5;
+  const layerSpacing = options.layerSpacing ?? spacing;
+  if (![spacing, 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, spacing);
+    if (style === "compact-tree")
+      return placeCompactTree(ids, forward, graph, size, spacing, layerSpacing);
+    const ordered = orderLayers(layers(ids, forward, style === "hierarchy"), graph);
+    return placeLayers(ordered, size, horizontal, spacing, 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) + spacing * 2;
+    extent = Math.max(extent, horizontal ? box.width : box.height);
+  }
+  if (isolated.length) {
+    const grid = placeGrid(isolated, size, spacing);
+    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((a, b) => a - 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((a, b) => centre(a) - 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 space(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 = space(
+    rows,
+    (box) => box.y,
+    (box) => box.height,
+    minimumGap
+  );
+  const xs = space(
+    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;
+}
+
 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;
@@ -15576,6 +15927,7 @@ exports.FLOWCHART_CONNECTION_SITES = FLOWCHART_CONNECTION_SITES;
 exports.FLOWCHART_PRESET_DEFINITIONS = FLOWCHART_PRESET_DEFINITIONS;
 exports.FLOWCHART_TEXT_RECTS = FLOWCHART_TEXT_RECTS;
 exports.GEAR9_CONNECTION_SITES = GEAR9_CONNECTION_SITES;
+exports.GRAPH_LAYOUT_STYLES = GRAPH_LAYOUT_STYLES;
 exports.IDENTITY_AFFINE = IDENTITY_AFFINE;
 exports.LEFT_CIRCULAR_ARROW_CONNECTION_SITES = LEFT_CIRCULAR_ARROW_CONNECTION_SITES;
 exports.LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES = LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES;
@@ -15612,6 +15964,7 @@ exports._internalForTests = _internalForTests;
 exports.alignElements = alignElements;
 exports.angleToRadians = angleToRadians;
 exports.at = at;
+exports.autoAlignBoxes = autoAlignBoxes;
 exports.buildCalloutLeaderLineSvgPath = buildCalloutLeaderLineSvgPath;
 exports.clipPolygons = clipPolygons;
 exports.combineShapes = combineShapes;
@@ -15661,6 +16014,7 @@ exports.isCalloutShape = isCalloutShape;
 exports.isConvex = isConvex;
 exports.isHorizontalPrimaryAxis = isHorizontalPrimaryAxis;
 exports.isStShapeType = isStShapeType;
+exports.layoutGraph = layoutGraph;
 exports.lineIntersection = lineIntersection;
 exports.lookupPresetConnectionSites = lookupPresetConnectionSites;
 exports.lookupPresetTextRectOverride = lookupPresetTextRectOverride;