ooxml-core 1.6.2 → 1.8.0

package/dist/index.mjs

@@ -10,26 +10,36 @@ var __export = (target, all) => {
 // color/index.ts
 var color_exports = {};
 __export(color_exports, {
+  OFFICE_STANDARD_COLORS: () => OFFICE_STANDARD_COLORS,
+  OFFICE_THEME_PALETTE_COLORS: () => OFFICE_THEME_PALETTE_COLORS,
+  THEME_PALETTE_COLUMN_NAMES: () => THEME_PALETTE_COLUMN_NAMES,
+  applyThemePaletteVariant: () => applyThemePaletteVariant,
   blendColorOntoWhite: () => blendColorOntoWhite,
+  buildThemePalette: () => buildThemePalette,
   clampUnitInterval: () => clampUnitInterval,
   colorWithOpacity: () => colorWithOpacity,
   contrastTextColor: () => contrastTextColor,
+  describeThemePaletteSwatch: () => describeThemePaletteSwatch,
   hexToRgbChannels: () => hexToRgbChannels,
   hexToRgbUnit: () => hexToRgbUnit,
   hslToRgb: () => hslToRgb,
   linearToSrgb255: () => linearToSrgb255,
   normalizeHexColor: () => normalizeHexColor,
+  normalizePaletteHex: () => normalizePaletteHex,
   parseArgbHex: () => parseArgbHex,
   parseDrawingFraction: () => parseDrawingFraction,
   parseDrawingHueDegrees: () => parseDrawingHueDegrees,
   parseDrawingPercent: () => parseDrawingPercent,
   parseHex: () => parseHex,
   parseOoxmlPercent: () => parseOoxmlPercent,
+  pushRecentColor: () => pushRecentColor,
   rgbToHsl: () => rgbToHsl,
   rgbToUpperHex: () => rgbToUpperHex,
   scrgbLinearToSrgb8: () => scrgbLinearToSrgb8,
   sigmaGradientStops: () => sigmaGradientStops,
   srgb255ToLinear: () => srgb255ToLinear,
+  themePaletteVariantLuminance: () => themePaletteVariantLuminance,
+  themePaletteVariantsForLuminance: () => themePaletteVariantsForLuminance,
   toHex: () => toHex
 });
 
@@ -511,6 +521,99 @@ function parseArgbHex(hex) {
 var clamp255 = (v) => Math.max(0, Math.min(255, v));
 var rgbToUpperHex = (rgb) => `#${rgb.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
 
+// color/theme-palette.ts
+var THEME_PALETTE_COLUMN_NAMES = [
+  "Background 1",
+  "Text 1",
+  "Background 2",
+  "Text 2",
+  "Accent 1",
+  "Accent 2",
+  "Accent 3",
+  "Accent 4",
+  "Accent 5",
+  "Accent 6"
+];
+var OFFICE_THEME_PALETTE_COLORS = [
+  "#ffffff",
+  "#000000",
+  "#e7e6e6",
+  "#44546a",
+  "#4472c4",
+  "#ed7d31",
+  "#a5a5a5",
+  "#ffc000",
+  "#5b9bd5",
+  "#70ad47"
+];
+var OFFICE_STANDARD_COLORS = [
+  { hex: "#c00000", label: "Dark Red" },
+  { hex: "#ff0000", label: "Red" },
+  { hex: "#ffc000", label: "Orange" },
+  { hex: "#ffff00", label: "Yellow" },
+  { hex: "#92d050", label: "Light Green" },
+  { hex: "#00b050", label: "Green" },
+  { hex: "#00b0f0", label: "Light Blue" },
+  { hex: "#0070c0", label: "Blue" },
+  { hex: "#002060", label: "Dark Blue" },
+  { hex: "#7030a0", label: "Purple" }
+];
+var lighter = (percent) => ({ kind: "lighter", percent });
+var darker = (percent) => ({ kind: "darker", percent });
+function themePaletteVariantsForLuminance(l) {
+  if (l < 0.05) return [lighter(50), lighter(35), lighter(25), lighter(15), lighter(5)];
+  if (l < 0.25) return [lighter(90), lighter(75), lighter(50), lighter(25), lighter(10)];
+  if (l < 0.75) return [lighter(80), lighter(60), lighter(40), darker(25), darker(50)];
+  if (l < 0.95) return [darker(10), darker(25), darker(50), darker(75), darker(90)];
+  return [darker(5), darker(15), darker(25), darker(35), darker(50)];
+}
+function themePaletteVariantLuminance(variant) {
+  const fraction = variant.percent / 100;
+  const lumMod = Math.round((1 - fraction) * 1e5) / 1e5;
+  return variant.kind === "lighter" ? { lumMod, lumOff: fraction } : { lumMod };
+}
+function normalizePaletteHex(value) {
+  const digits = value.trim().replace(/^#/, "");
+  const rgb = hexToRgbChannels(
+    /^[0-9a-f]{3}$/i.test(digits) ? digits.replace(/./g, "$&$&") : digits
+  );
+  return rgb ? `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`.toLowerCase() : void 0;
+}
+function applyThemePaletteVariant(hex, variant) {
+  const rgb = hexToRgbChannels(hex);
+  if (!rgb) return hex;
+  const { h: h2, s, l } = rgbToHsl(rgb.r, rgb.g, rgb.b);
+  const { lumMod, lumOff } = themePaletteVariantLuminance(variant);
+  const next = hslToRgb(h2, s, l * lumMod + (lumOff ?? 0), (value) => Math.floor(value + 1e-6));
+  return `#${toHex(next.r)}${toHex(next.g)}${toHex(next.b)}`.toLowerCase();
+}
+function describeThemePaletteSwatch(name, variant) {
+  if (!variant) return name;
+  return `${name}, ${variant.kind === "lighter" ? "Lighter" : "Darker"} ${variant.percent}%`;
+}
+function buildThemePalette(colors = OFFICE_THEME_PALETTE_COLORS, names = THEME_PALETTE_COLUMN_NAMES) {
+  return THEME_PALETTE_COLUMN_NAMES.map((fallback, index) => {
+    const name = names[index] ?? fallback;
+    const hex = (colors[index] === void 0 ? void 0 : normalizePaletteHex(colors[index])) ?? OFFICE_THEME_PALETTE_COLORS[index];
+    const rgb = hexToRgbChannels(hex);
+    const { l } = rgbToHsl(rgb.r, rgb.g, rgb.b);
+    return {
+      name,
+      base: { hex, label: name },
+      variants: themePaletteVariantsForLuminance(l).map((variant) => ({
+        hex: applyThemePaletteVariant(hex, variant),
+        label: describeThemePaletteSwatch(name, variant),
+        variant
+      }))
+    };
+  });
+}
+function pushRecentColor(recent, hex, limit = 10) {
+  const color = normalizePaletteHex(hex);
+  if (!color) return [...recent];
+  return [color, ...recent.filter((item) => item.toLowerCase() !== color)].slice(0, limit);
+}
+
 // chart/index.ts
 var chart_exports = {};
 __export(chart_exports, {
@@ -5890,9 +5993,11 @@ __export(text_exports, {
   changeTextCaseRanges: () => changeTextCaseRanges,
   decimalAnchorIndex: () => decimalAnchorIndex,
   decimalSeparatorForLanguage: () => decimalSeparatorForLanguage,
+  designTextWidthEm: () => designTextWidthEm,
   detectFontScript: () => detectFontScript,
   getLeaderCharacter: () => getLeaderCharacter,
   getLeaderStyles: () => getLeaderStyles,
+  hasDesignAdvances: () => hasDesignAdvances,
   hasDistinctScriptFonts: () => hasDistinctScriptFonts,
   resolveFontForScript: () => resolveFontForScript,
   segmentByScript: () => segmentByScript,
@@ -6149,6 +6254,57 @@ function changeTextCaseRanges(text3, mode, boundaries = []) {
   return ranges;
 }
 
+// text/font-metrics/design-advances.generated.ts
+var DESIGN_ADVANCES = {
+  arial: {
+    regular: "277.83 277.83 354.98 556.15 556.15 889.16 666.99 190.92 333.01 333.01 389.16 583.98 277.83 333.01 277.83 277.83 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 277.83 277.83 583.98 583.98 583.98 556.15 1015.14 666.99 666.99 722.17 722.17 666.99 610.84 777.83 722.17 277.83 500 666.99 556.15 833.01 722.17 777.83 666.99 777.83 722.17 666.99 610.84 722.17 666.99 943.85 666.99 666.99 610.84 277.83 277.83 277.83 469.24 556.15 333.01 556.15 556.15 500 556.15 556.15 277.83 556.15 556.15 222.17 222.17 500 222.17 833.01 556.15 556.15 556.15 556.15 333.01 500 277.83 556.15 500 722.17 500 500 500 333.98 259.77 333.98 583.98",
+    bold: "277.83 333.01 474.12 556.15 556.15 889.16 722.17 237.79 333.01 333.01 389.16 583.98 277.83 333.01 277.83 277.83 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 556.15 333.01 333.01 583.98 583.98 583.98 610.84 975.1 722.17 722.17 722.17 722.17 666.99 610.84 777.83 722.17 277.83 556.15 722.17 610.84 833.01 722.17 777.83 666.99 777.83 722.17 666.99 610.84 722.17 666.99 943.85 666.99 666.99 610.84 333.01 277.83 333.01 583.98 556.15 333.01 556.15 610.84 556.15 610.84 556.15 333.01 610.84 610.84 277.83 277.83 556.15 277.83 889.16 610.84 610.84 610.84 610.84 389.16 556.15 333.01 610.84 556.15 777.83 556.15 556.15 500 389.16 279.79 389.16 583.98"
+  },
+  calibri: {
+    regular: "226.07 325.68 400.88 498.05 506.83 714.85 682.13 220.7 303.22 303.22 498.05 498.05 249.51 306.15 252.44 386.23 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 267.58 267.58 498.05 498.05 498.05 463.38 894.04 578.61 543.95 533.2 615.23 488.28 459.47 630.86 623.05 251.95 318.85 519.53 420.41 854.98 645.51 662.11 516.6 672.85 542.97 459.47 487.3 641.6 567.38 889.65 519.04 487.3 468.26 306.64 386.23 306.64 498.05 498.05 291.02 479 525.39 422.85 525.39 497.56 305.18 470.7 525.39 229.49 239.26 454.59 229.49 798.83 525.39 527.34 525.39 525.39 348.63 391.11 334.96 525.39 451.66 714.85 433.11 452.64 395.02 314.45 460.45 314.45 498.05",
+    bold: "226.07 325.68 438.48 498.05 506.83 729 704.59 233.4 311.52 311.52 498.05 498.05 257.81 306.15 267.09 429.69 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 275.88 275.88 498.05 498.05 498.05 463.38 898.44 605.96 560.55 529.3 630.37 487.79 458.98 637.21 630.86 266.6 331.05 546.88 422.85 874.02 658.69 676.27 532.23 686.04 562.99 472.66 495.12 652.83 591.31 906.25 550.78 519.53 478.03 324.71 429.69 324.71 498.05 498.05 300.29 493.65 536.62 418.46 536.62 503.42 316.41 474.12 536.62 245.6 255.37 479.98 245.6 813.48 536.62 537.6 536.62 536.62 355.47 398.93 346.68 536.62 473.14 745.12 459.47 473.63 397.46 343.75 475.1 343.75 498.05"
+  },
+  "calibri light": {
+    regular: "226.07 325.68 380.37 498.05 506.83 707.03 669.92 213.87 298.83 298.83 498.05 498.05 244.63 306.15 244.63 362.3 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 506.83 262.69 262.69 498.05 498.05 498.05 463.38 891.6 563.48 535.16 535.16 606.93 488.77 459.96 627.44 619.14 244.14 312.5 504.4 418.94 844.73 638.18 654.3 507.81 666.02 532.23 452.64 483.4 635.74 554.2 880.86 501.46 469.24 463.38 296.88 362.3 296.88 498.05 498.05 286.13 470.7 519.53 425.29 519.53 494.14 298.83 468.75 519.53 220.7 229.98 440.92 220.7 791.02 519.53 521.49 519.53 519.53 344.73 386.72 328.61 519.53 439.94 698.73 418.46 440.92 393.56 298.83 452.64 298.83 498.05",
+    bold: "222.17 319.82 373.54 488.77 497.56 693.85 657.23 209.96 293.46 293.46 488.77 488.77 240.24 300.78 240.24 355.96 497.56 497.56 497.56 497.56 497.56 497.56 497.56 497.56 497.56 497.56 258.3 258.3 488.77 488.77 488.77 454.59 874.51 552.74 525.39 525.39 595.7 479.49 451.66 615.72 607.42 239.75 307.13 495.12 411.13 828.61 625.98 642.09 498.54 653.32 522.46 444.34 474.61 624.02 543.95 864.26 492.19 460.45 454.59 291.5 355.96 291.5 488.77 488.77 281.25 461.92 509.77 417.48 509.77 484.86 293.46 459.96 509.77 216.8 226.07 432.62 216.8 775.88 509.77 511.72 509.77 509.77 338.38 379.88 322.75 509.77 431.64 685.55 410.64 432.62 386.23 293.46 444.34 293.46 488.77"
+  },
+  "segoe ui": {
+    regular: "273.93 284.18 392.09 590.82 539.06 818.36 800.29 229.98 301.76 301.76 416.99 684.08 216.8 399.9 216.8 389.65 539.06 539.06 539.06 539.06 539.06 539.06 539.06 539.06 539.06 539.06 216.8 216.8 684.08 684.08 684.08 448.24 955.08 645.02 573.24 619.14 701.17 505.86 488.28 686.04 709.96 266.11 356.94 580.08 470.7 897.95 748.05 753.91 560.06 753.91 598.14 531.25 523.93 687.01 621.09 934.08 589.85 552.74 570.31 301.76 378.91 301.76 684.08 415.04 268.07 508.79 587.89 461.92 588.87 522.95 312.99 588.87 565.92 242.19 242.19 497.07 242.19 861.33 565.92 585.94 587.89 588.87 347.66 424.32 338.87 565.92 479 722.66 458.98 483.89 452.15 301.76 239.26 301.76 684.08",
+    bold: "275.88 327.15 493.17 592.29 575.2 867.19 849.61 292.97 369.14 369.14 455.08 707.03 271 404.3 271 443.36 575.2 575.2 575.2 575.2 575.2 575.2 575.2 575.2 575.2 575.2 271 271 707.03 707.03 707.03 437.99 954.1 703.12 641.11 624.02 737.31 532.23 520.02 710.94 766.11 316.89 445.31 648.93 511.23 957.03 790.04 758.3 614.26 758.3 652.83 560.55 585.94 723.14 666.99 1004.88 655.27 606.93 606.93 369.14 436.04 369.14 707.03 415.04 313.96 538.09 620.12 479.98 619.14 541.02 383.3 619.14 602.05 284.18 284.18 559.08 284.18 916.01 604.98 611.33 620.12 619.14 397.95 439.94 389.16 604.98 541.99 797.36 552.25 538.09 479 369.14 326.17 369.14 707.03"
+  },
+  "times new roman": {
+    regular: "250 333.01 408.2 500 500 833.01 777.83 180.18 333.01 333.01 500 563.96 250 333.01 250 277.83 500 500 500 500 500 500 500 500 500 500 277.83 277.83 563.96 563.96 563.96 443.85 920.9 722.17 666.99 666.99 722.17 610.84 556.15 722.17 722.17 333.01 389.16 722.17 610.84 889.16 722.17 722.17 556.15 722.17 666.99 556.15 610.84 722.17 722.17 943.85 722.17 722.17 610.84 333.01 277.83 333.01 469.24 500 333.01 443.85 500 443.85 500 443.85 333.01 500 500 277.83 277.83 500 277.83 777.83 500 500 500 500 333.01 389.16 277.83 500 500 722.17 500 500 443.85 479.98 200.2 479.98 541.02",
+    bold: "250 333.01 555.17 500 500 1000 833.01 277.83 333.01 333.01 500 569.83 250 333.01 250 277.83 500 500 500 500 500 500 500 500 500 500 333.01 333.01 569.83 569.83 569.83 500 930.18 722.17 666.99 722.17 722.17 666.99 610.84 777.83 777.83 389.16 500 777.83 666.99 943.85 722.17 777.83 610.84 777.83 722.17 556.15 666.99 722.17 722.17 1000 722.17 722.17 666.99 333.01 277.83 333.01 581.06 500 333.01 500 556.15 443.85 556.15 443.85 333.01 500 556.15 277.83 333.01 556.15 277.83 833.01 556.15 500 556.15 556.15 443.85 389.16 333.01 556.15 500 722.17 500 500 443.85 394.04 220.22 394.04 520.02"
+  }
+};
+
+// text/font-metrics/advance-width.ts
+var FIRST = 32;
+var decoded = /* @__PURE__ */ new Map();
+function advances(family, bold) {
+  const name = family.trim().toLowerCase();
+  const key = `${name}|${bold ? "b" : "r"}`;
+  const known = decoded.get(key);
+  if (known) return known;
+  const table = Object.hasOwn(DESIGN_ADVANCES, name) ? DESIGN_ADVANCES[name] : void 0;
+  if (!table) return void 0;
+  const values = (bold ? table.bold : table.regular).split(" ").map(Number);
+  decoded.set(key, values);
+  return values;
+}
+var hasDesignAdvances = (family) => !!advances(family, false);
+function designTextWidthEm(text3, family, bold = false) {
+  const table = advances(family, bold);
+  if (!table) return void 0;
+  let units2 = 0;
+  for (let index = 0; index < text3.length; ++index) {
+    const advance = table[text3.charCodeAt(index) - FIRST];
+    if (advance === void 0 || Number.isNaN(advance)) return void 0;
+    units2 += advance;
+  }
+  return units2 / 1e3;
+}
+
 // i18n/index.ts
 var i18n_exports = {};
 __export(i18n_exports, {
@@ -6220,6 +6376,37 @@ function createTranslator(messages, fallbacks = [], options = {}) {
   };
 }
 
+// ribbon/index.ts
+var ribbon_exports = {};
+__export(ribbon_exports, {
+  RIBBON_ADD_IN_EVENT: () => RIBBON_ADD_IN_EVENT,
+  acceptedRibbonAddIns: () => acceptedRibbonAddIns,
+  findRibbonAddInCommand: () => findRibbonAddInCommand,
+  ribbonAddInCommands: () => ribbonAddInCommands
+});
+
+// ribbon/add-in.ts
+var RIBBON_ADD_IN_EVENT = "office-ribbon-add-in";
+function acceptedRibbonAddIns(tabs, reserved = []) {
+  const taken = new Set(reserved);
+  const accepted = [];
+  for (const tab of tabs ?? []) {
+    if (!tab || typeof tab.id !== "string" || !tab.id || taken.has(tab.id)) continue;
+    taken.add(tab.id);
+    accepted.push(tab);
+  }
+  return accepted;
+}
+function ribbonAddInCommands(tab) {
+  const flatten = (commands) => commands.flatMap((command) => [command, ...flatten(command.items ?? [])]);
+  return flatten(tab.groups.flatMap((group) => group.commands));
+}
+function findRibbonAddInCommand(tab, id) {
+  if (id === void 0) return void 0;
+  const command = ribbonAddInCommands(tab).find((candidate) => candidate.id === id);
+  return command && !command.disabled ? command : void 0;
+}
+
 // drawingml/index.ts
 var drawingml_exports = {};
 __export(drawingml_exports, {
@@ -30642,8 +30829,8 @@ function resolveReferenceUriToPart(uri) {
   if (trimmed.length === 0 || trimmed.startsWith("#")) {
     return void 0;
   }
-  const decoded = decodeURIComponent(trimmed);
-  return normalizePartPath(decoded.startsWith("/") ? decoded.slice(1) : decoded);
+  const decoded2 = decodeURIComponent(trimmed);
+  return normalizePartPath(decoded2.startsWith("/") ? decoded2.slice(1) : decoded2);
 }
 
 // opc/signature/digest.ts
@@ -33022,6 +33209,7 @@ __export(geometry_exports, {
   BRACE_TEXT_RECTS: () => BRACE_TEXT_RECTS,
   CALLOUT_CONNECTION_SITES: () => CALLOUT_CONNECTION_SITES,
   CALLOUT_TEXT_RECTS: () => CALLOUT_TEXT_RECTS,
+  CANVAS_SENTINEL: () => CANVAS_SENTINEL,
   CARDINAL_SITES: () => CARDINAL_SITES,
   CHART_MARK_PRESET_DEFINITIONS: () => CHART_MARK_PRESET_DEFINITIONS,
   CIRCULAR_ARROW_CONNECTION_SITES: () => CIRCULAR_ARROW_CONNECTION_SITES,
@@ -33052,6 +33240,7 @@ __export(geometry_exports, {
   MISC_SHAPE_CONNECTION_SITES: () => MISC_SHAPE_CONNECTION_SITES,
   MISC_TEXT_RECTS_A: () => MISC_TEXT_RECTS_A,
   MISC_TEXT_RECTS_B: () => MISC_TEXT_RECTS_B,
+  PADDING_DEFAULT: () => PADDING_DEFAULT,
   POLYGON_CONNECTION_SITES: () => POLYGON_CONNECTION_SITES,
   POLYGON_TEXT_RECTS: () => POLYGON_TEXT_RECTS,
   PRESET_GEOMETRY_ALIASES: () => PRESET_GEOMETRY_ALIASES,
@@ -33067,6 +33256,7 @@ __export(geometry_exports, {
   REFINED_ARROW_PRESET_DEFINITIONS: () => REFINED_ARROW_PRESET_DEFINITIONS,
   RIBBON_CONNECTION_SITES: () => RIBBON_CONNECTION_SITES,
   RIBBON_TEXT_RECTS: () => RIBBON_TEXT_RECTS,
+  ROUTING_PADDING_DEFAULT: () => ROUTING_PADDING_DEFAULT,
   SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS: () => SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS,
   SNAP_THRESHOLD: () => SNAP_THRESHOLD,
   STAR_CONNECTION_SITES: () => STAR_CONNECTION_SITES,
@@ -33076,11 +33266,14 @@ __export(geometry_exports, {
   TAB_CONNECTION_SITES: () => TAB_CONNECTION_SITES,
   TAB_TEXT_RECTS: () => TAB_TEXT_RECTS,
   _internalForTests: () => _internalForTests,
+  aStarOrthogonal: () => aStarOrthogonal,
   alignElements: () => alignElements,
   angleToRadians: () => angleToRadians,
+  arrowKeyDelta: () => arrowKeyDelta,
   at: () => at,
   autoAlignBoxes: () => autoAlignBoxes,
   buildCalloutLeaderLineSvgPath: () => buildCalloutLeaderLineSvgPath,
+  buildGraphNodes: () => buildGraphNodes,
   clipPolygons: () => clipPolygons,
   combineShapes: () => combineShapes,
   composeAffine: () => composeAffine,
@@ -33097,6 +33290,7 @@ __export(geometry_exports, {
   curvedElbowPathD: () => curvedElbowPathD,
   cxn: () => cxn,
   dedupPoly: () => dedupPoly,
+  directPathClear: () => directPathClear,
   distributeElements: () => distributeElements,
   elbowCurveSegments: () => elbowCurveSegments,
   elbowSegmentCount: () => elbowSegmentCount,
@@ -33121,6 +33315,8 @@ __export(geometry_exports, {
   getPresetConnectionSites: () => getPresetConnectionSites,
   getPresetShapeClipPath: () => getPresetShapeClipPath,
   getPresetTextRect: () => getPresetTextRect,
+  heuristic: () => heuristic,
+  inflateRect: () => inflateRect,
   insertIntersections: () => insertIntersections,
   intersectPolygons: () => intersectPolygons,
   intersectShapes: () => intersectShapes,
@@ -33140,15 +33336,22 @@ __export(geometry_exports, {
   parseFormula: () => parseFormula,
   parseGuideDefinitions: () => parseGuideDefinitions,
   pointInPolygon: () => pointInPolygon,
+  pointInRect: () => pointInRect,
   pointInTriangle: () => pointInTriangle,
+  pointKey: () => pointKey,
   polygonArea: () => polygonArea,
   polygonsToSvgPath: () => polygonsToSvgPath,
   resolveAlignReferenceBox: () => resolveAlignReferenceBox,
   resolveCoordinate: () => resolveCoordinate,
   resolveOperand: () => resolveOperand,
   resolveRotateHandlePlacement: () => resolveRotateHandlePlacement,
+  routeConnector: () => routeConnector,
+  routeOrthogonalConnector: () => routeOrthogonalConnector,
   segmentIntersection: () => segmentIntersection,
+  segmentIntersectsRect: () => segmentIntersectsRect,
   signedArea: () => signedArea,
+  simplifyPath: () => simplifyPath,
+  snapAngle: () => snapAngle,
   snapBox: () => snapBox,
   snapToGridStep: () => snapToGridStep,
   snapValue: () => snapValue,
@@ -33162,7 +33365,9 @@ __export(geometry_exports, {
   unionShapes: () => unionShapes,
   unionSvgPaths: () => unionSvgPaths,
   usesSlideReference: () => usesSlideReference,
-  vec2Eq: () => vec2Eq
+  vec2Eq: () => vec2Eq,
+  waypointsToPathD: () => waypointsToPathD,
+  waypointsToPathData: () => waypointsToPathData
 });
 
 // geometry/adjustment-aware-shapes.ts
@@ -34103,6 +34308,309 @@ function curvedElbowPathD(startX, startY, endX, endY, segments, adj1, adj2, adj3
   ].join(" ");
 }
 
+// geometry/connector-router-types.ts
+var PADDING_DEFAULT = 12;
+var ROUTING_PADDING_DEFAULT = PADDING_DEFAULT;
+var CANVAS_SENTINEL = 1e5;
+
+// geometry/connector-router-graph.ts
+function inflateRect(r, pad2) {
+  return {
+    x: r.x - pad2,
+    y: r.y - pad2,
+    width: r.width + pad2 * 2,
+    height: r.height + pad2 * 2
+  };
+}
+function pointInRect(p, r) {
+  return p.x >= r.x && p.x <= r.x + r.width && p.y >= r.y && p.y <= r.y + r.height;
+}
+function segmentIntersectsRect(a2, b, r) {
+  const minX = Math.min(a2.x, b.x);
+  const maxX = Math.max(a2.x, b.x);
+  const minY = Math.min(a2.y, b.y);
+  const maxY = Math.max(a2.y, b.y);
+  const rRight = r.x + r.width;
+  const rBottom = r.y + r.height;
+  if (maxX < r.x || minX > rRight || maxY < r.y || minY > rBottom) {
+    return false;
+  }
+  if (Math.abs(a2.y - b.y) < 0.5) {
+    return a2.y >= r.y && a2.y <= rBottom && maxX >= r.x && minX <= rRight;
+  }
+  if (Math.abs(a2.x - b.x) < 0.5) {
+    return a2.x >= r.x && a2.x <= rRight && maxY >= r.y && minY <= rBottom;
+  }
+  return true;
+}
+function directPathClear(start, end, inflated) {
+  for (const rect3 of inflated) {
+    if (segmentIntersectsRect(start, end, rect3)) {
+      return false;
+    }
+  }
+  return true;
+}
+function heuristic(a2, b) {
+  return Math.abs(a2.x - b.x) + Math.abs(a2.y - b.y);
+}
+function pointKey(p) {
+  return `${Math.round(p.x)},${Math.round(p.y)}`;
+}
+function buildGraphNodes(start, end, inflated, canvasWidth, canvasHeight) {
+  const margin = 4;
+  const nodes = [start, end];
+  for (const r of inflated) {
+    const corners = [
+      { x: r.x - margin, y: r.y - margin },
+      { x: r.x + r.width + margin, y: r.y - margin },
+      { x: r.x - margin, y: r.y + r.height + margin },
+      { x: r.x + r.width + margin, y: r.y + r.height + margin }
+    ];
+    for (const c2 of corners) {
+      if (c2.x >= 0 && c2.x <= canvasWidth && c2.y >= 0 && c2.y <= canvasHeight) {
+        let blocked = false;
+        for (const rect3 of inflated) {
+          if (pointInRect(c2, rect3)) {
+            blocked = true;
+            break;
+          }
+        }
+        if (!blocked) {
+          nodes.push(c2);
+        }
+      }
+    }
+  }
+  const projections = [];
+  for (const node of nodes) {
+    projections.push({ x: start.x, y: node.y });
+    projections.push({ x: node.x, y: start.y });
+    projections.push({ x: end.x, y: node.y });
+    projections.push({ x: node.x, y: end.y });
+  }
+  for (const p of projections) {
+    if (p.x >= 0 && p.x <= canvasWidth && p.y >= 0 && p.y <= canvasHeight) {
+      let blocked = false;
+      for (const rect3 of inflated) {
+        if (pointInRect(p, rect3)) {
+          blocked = true;
+          break;
+        }
+      }
+      if (!blocked) {
+        nodes.push(p);
+      }
+    }
+  }
+  return nodes;
+}
+
+// geometry/connector-router-astar.ts
+var MAX_ASTAR_ITERATIONS = 2e3;
+function aStarOrthogonal(nodes, start, end, inflated) {
+  const startKey = pointKey(start);
+  const endKey = pointKey(end);
+  const canConnect = (a2, b) => {
+    const isHoriz = Math.abs(a2.y - b.y) < 1;
+    const isVert = Math.abs(a2.x - b.x) < 1;
+    if (isHoriz || isVert) {
+      for (const rect3 of inflated) {
+        if (segmentIntersectsRect(a2, b, rect3)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const bend1 = { x: b.x, y: a2.y };
+    const bend2 = { x: a2.x, y: b.y };
+    let path1Clear = true;
+    let path2Clear = true;
+    for (const rect3 of inflated) {
+      if (path1Clear && (segmentIntersectsRect(a2, bend1, rect3) || segmentIntersectsRect(bend1, b, rect3))) {
+        path1Clear = false;
+      }
+      if (path2Clear && (segmentIntersectsRect(a2, bend2, rect3) || segmentIntersectsRect(bend2, b, rect3))) {
+        path2Clear = false;
+      }
+      if (!path1Clear && !path2Clear) {
+        break;
+      }
+    }
+    return path1Clear || path2Clear;
+  };
+  const gScore = /* @__PURE__ */ new Map();
+  const fScore = /* @__PURE__ */ new Map();
+  const cameFrom = /* @__PURE__ */ new Map();
+  const bendPoint = /* @__PURE__ */ new Map();
+  gScore.set(startKey, 0);
+  fScore.set(startKey, heuristic(start, end));
+  const openSet = /* @__PURE__ */ new Set([startKey]);
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const n2 of nodes) {
+    nodeMap.set(pointKey(n2), n2);
+  }
+  const getLowest = () => {
+    let best;
+    let bestScore = Infinity;
+    for (const key of openSet) {
+      const score = fScore.get(key) ?? Infinity;
+      if (score < bestScore) {
+        bestScore = score;
+        best = key;
+      }
+    }
+    return best;
+  };
+  let iterations = 0;
+  while (openSet.size > 0 && iterations < MAX_ASTAR_ITERATIONS) {
+    iterations++;
+    const currentKey = getLowest();
+    if (currentKey === void 0) {
+      break;
+    }
+    if (currentKey === endKey) {
+      const path2 = [];
+      let key = endKey;
+      while (key !== void 0) {
+        const node = nodeMap.get(key);
+        if (node !== void 0) {
+          const bp = bendPoint.get(key);
+          if (bp !== void 0 && bp !== null) {
+            path2.unshift(node);
+            path2.unshift(bp);
+          } else {
+            path2.unshift(node);
+          }
+        }
+        key = cameFrom.get(key);
+      }
+      return path2;
+    }
+    openSet.delete(currentKey);
+    const current = nodeMap.get(currentKey);
+    if (current === void 0) {
+      continue;
+    }
+    for (const neighbor of nodes) {
+      const neighborKey = pointKey(neighbor);
+      if (neighborKey === currentKey) {
+        continue;
+      }
+      if (!canConnect(current, neighbor)) {
+        continue;
+      }
+      const isHoriz = Math.abs(current.y - neighbor.y) < 1;
+      const isVert = Math.abs(current.x - neighbor.x) < 1;
+      let dist;
+      let bp = null;
+      if (isHoriz || isVert) {
+        dist = heuristic(current, neighbor);
+      } else {
+        const bend1 = { x: neighbor.x, y: current.y };
+        const bend2 = { x: current.x, y: neighbor.y };
+        let use1 = true;
+        for (const rect3 of inflated) {
+          if (segmentIntersectsRect(current, bend1, rect3) || segmentIntersectsRect(bend1, neighbor, rect3)) {
+            use1 = false;
+            break;
+          }
+        }
+        bp = use1 ? bend1 : bend2;
+        dist = Math.abs(current.x - bp.x) + Math.abs(current.y - bp.y) + Math.abs(bp.x - neighbor.x) + Math.abs(bp.y - neighbor.y);
+      }
+      const tentativeG = (gScore.get(currentKey) ?? Infinity) + dist;
+      if (tentativeG < (gScore.get(neighborKey) ?? Infinity)) {
+        cameFrom.set(neighborKey, currentKey);
+        bendPoint.set(neighborKey, bp);
+        gScore.set(neighborKey, tentativeG);
+        fScore.set(neighborKey, tentativeG + heuristic(neighbor, end));
+        openSet.add(neighborKey);
+      }
+    }
+  }
+  return [start, end];
+}
+function simplifyPath(points) {
+  if (points.length <= 2) {
+    return [...points];
+  }
+  const result = [points[0]];
+  for (let i2 = 1; i2 < points.length - 1; i2++) {
+    const prev = result[result.length - 1];
+    const curr = points[i2];
+    const next = points[i2 + 1];
+    const sameX = Math.abs(prev.x - curr.x) < 1 && Math.abs(curr.x - next.x) < 1;
+    const sameY = Math.abs(prev.y - curr.y) < 1 && Math.abs(curr.y - next.y) < 1;
+    if (!sameX && !sameY) {
+      result.push(curr);
+    } else if (!sameX || !sameY) {
+      if (!(sameX || sameY)) {
+        result.push(curr);
+      }
+    }
+  }
+  result.push(points[points.length - 1]);
+  return result;
+}
+
+// geometry/connector-router.ts
+function routeCore(start, end, obstacles, padding, canvasWidth, canvasHeight) {
+  if (obstacles.length === 0) {
+    return [start, end];
+  }
+  const inflated = obstacles.map((r) => inflateRect(r, padding));
+  if (directPathClear(start, end, inflated)) {
+    return [start, end];
+  }
+  const midH = { x: end.x, y: start.y };
+  const midV = { x: start.x, y: end.y };
+  let elbowHClear = true;
+  let elbowVClear = true;
+  for (const rect3 of inflated) {
+    if (elbowHClear && (segmentIntersectsRect(start, midH, rect3) || segmentIntersectsRect(midH, end, rect3))) {
+      elbowHClear = false;
+    }
+    if (elbowVClear && (segmentIntersectsRect(start, midV, rect3) || segmentIntersectsRect(midV, end, rect3))) {
+      elbowVClear = false;
+    }
+    if (!elbowHClear && !elbowVClear) {
+      break;
+    }
+  }
+  if (elbowHClear) {
+    return [start, midH, end];
+  }
+  if (elbowVClear) {
+    return [start, midV, end];
+  }
+  const nodes = buildGraphNodes(start, end, inflated, canvasWidth, canvasHeight);
+  const path2 = aStarOrthogonal(nodes, start, end, inflated);
+  return simplifyPath(path2);
+}
+function routeConnector(options) {
+  const { start, end, obstacles, canvasWidth, canvasHeight, padding = PADDING_DEFAULT } = options;
+  return routeCore(start, end, obstacles, padding, canvasWidth, canvasHeight);
+}
+function waypointsToPathData(waypoints) {
+  if (waypoints.length === 0) {
+    return "";
+  }
+  return waypoints.map((point, index) => `${index === 0 ? "M" : "L"} ${point.x} ${point.y}`).join(" ");
+}
+function routeOrthogonalConnector(start, end, obstacles, opts) {
+  const padding = opts?.padding ?? PADDING_DEFAULT;
+  const canvasWidth = opts?.canvasWidth ?? CANVAS_SENTINEL;
+  const canvasHeight = opts?.canvasHeight ?? CANVAS_SENTINEL;
+  return routeCore(start, end, obstacles, padding, canvasWidth, canvasHeight);
+}
+function waypointsToPathD(waypoints) {
+  if (waypoints.length === 0) {
+    return "";
+  }
+  return waypoints.map((point, index) => `${index === 0 ? "M" : "L"}${point.x},${point.y}`).join(" ");
+}
+
 // geometry/preset-clip-paths-core.ts
 var CLIP_PATHS_CORE = {
   // ── Lines ─────────────────────────────────────────────────────────────
@@ -39369,6 +39877,13 @@ function createRotationDrag(center, startPointer, startRotation, options = {}) {
     return rotation;
   };
 }
+function snapAngle(angleDeg, step = 15, tolerance = step / 2) {
+  const nearest = Math.round(angleDeg / step) * step;
+  if (Math.abs(angleDeg - nearest) <= tolerance) {
+    return (nearest % 360 + 360) % 360;
+  }
+  return angleDeg;
+}
 
 // geometry/rotate-handle-placement.ts
 function resolveRotateHandlePlacement(input) {
@@ -39786,6 +40301,22 @@ function autoAlignBoxes(boxes, options = {}) {
   return result;
 }
 
+// geometry/nudge.ts
+function arrowKeyDelta(key, step) {
+  switch (key) {
+    case "ArrowLeft":
+      return { dx: -step, dy: 0 };
+    case "ArrowRight":
+      return { dx: step, dy: 0 };
+    case "ArrowUp":
+      return { dx: 0, dy: -step };
+    case "ArrowDown":
+      return { dx: 0, dy: step };
+    default:
+      return null;
+  }
+}
+
 // units/index.ts
 var units_exports = {};
 __export(units_exports, {
@@ -41885,4 +42416,4 @@ function parseOmml(xml) {
   return ommlFromElement(parseXml(xml, { label: "OMML" }).documentElement);
 }
 
-export { chart_exports as chart, color_exports as color, diagram_exports as diagram, digest_exports as digest, drawingml_exports as drawingml, geometry_exports as geometry, i18n_exports as i18n, math_exports as math, opc_exports as opc, text_exports as text, units_exports as units, xml_exports as xml };
+export { chart_exports as chart, color_exports as color, diagram_exports as diagram, digest_exports as digest, drawingml_exports as drawingml, geometry_exports as geometry, i18n_exports as i18n, math_exports as math, opc_exports as opc, ribbon_exports as ribbon, text_exports as text, units_exports as units, xml_exports as xml };