ooxml-core 1.6.2 → 1.8.0

package/dist/geometry/index.mjs

@@ -945,6 +945,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, pad) {
+  return {
+    x: r.x - pad,
+    y: r.y - pad,
+    width: r.width + pad * 2,
+    height: r.height + pad * 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(a, b, r) {
+  const minX = Math.min(a.x, b.x);
+  const maxX = Math.max(a.x, b.x);
+  const minY = Math.min(a.y, b.y);
+  const maxY = Math.max(a.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(a.y - b.y) < 0.5) {
+    return a.y >= r.y && a.y <= rBottom && maxX >= r.x && minX <= rRight;
+  }
+  if (Math.abs(a.x - b.x) < 0.5) {
+    return a.x >= r.x && a.x <= rRight && maxY >= r.y && minY <= rBottom;
+  }
+  return true;
+}
+function directPathClear(start, end, inflated) {
+  for (const rect2 of inflated) {
+    if (segmentIntersectsRect(start, end, rect2)) {
+      return false;
+    }
+  }
+  return true;
+}
+function heuristic(a, b) {
+  return Math.abs(a.x - b.x) + Math.abs(a.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 c of corners) {
+      if (c.x >= 0 && c.x <= canvasWidth && c.y >= 0 && c.y <= canvasHeight) {
+        let blocked = false;
+        for (const rect2 of inflated) {
+          if (pointInRect(c, rect2)) {
+            blocked = true;
+            break;
+          }
+        }
+        if (!blocked) {
+          nodes.push(c);
+        }
+      }
+    }
+  }
+  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 rect2 of inflated) {
+        if (pointInRect(p, rect2)) {
+          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 = (a, b) => {
+    const isHoriz = Math.abs(a.y - b.y) < 1;
+    const isVert = Math.abs(a.x - b.x) < 1;
+    if (isHoriz || isVert) {
+      for (const rect2 of inflated) {
+        if (segmentIntersectsRect(a, b, rect2)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    const bend1 = { x: b.x, y: a.y };
+    const bend2 = { x: a.x, y: b.y };
+    let path1Clear = true;
+    let path2Clear = true;
+    for (const rect2 of inflated) {
+      if (path1Clear && (segmentIntersectsRect(a, bend1, rect2) || segmentIntersectsRect(bend1, b, rect2))) {
+        path1Clear = false;
+      }
+      if (path2Clear && (segmentIntersectsRect(a, bend2, rect2) || segmentIntersectsRect(bend2, b, rect2))) {
+        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 n of nodes) {
+    nodeMap.set(pointKey(n), n);
+  }
+  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 path = [];
+      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) {
+            path.unshift(node);
+            path.unshift(bp);
+          } else {
+            path.unshift(node);
+          }
+        }
+        key = cameFrom.get(key);
+      }
+      return path;
+    }
+    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 rect2 of inflated) {
+          if (segmentIntersectsRect(current, bend1, rect2) || segmentIntersectsRect(bend1, neighbor, rect2)) {
+            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 i = 1; i < points.length - 1; i++) {
+    const prev = result[result.length - 1];
+    const curr = points[i];
+    const next = points[i + 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 rect2 of inflated) {
+    if (elbowHClear && (segmentIntersectsRect(start, midH, rect2) || segmentIntersectsRect(midH, end, rect2))) {
+      elbowHClear = false;
+    }
+    if (elbowVClear && (segmentIntersectsRect(start, midV, rect2) || segmentIntersectsRect(midV, end, rect2))) {
+      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 path = aStarOrthogonal(nodes, start, end, inflated);
+  return simplifyPath(path);
+}
+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/guide-formula-eval.ts
 var ANGLE_SCALE = 6e4;
 function angleToRadians(ooxmlAngle) {
@@ -15473,6 +15776,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) {
@@ -15890,4 +16200,20 @@ function autoAlignBoxes(boxes, options = {}) {
   return result;
 }
 
-export { ACTION_BUTTON_CONNECTION_SITES, ACTION_BUTTON_PRESET_DEFINITIONS, ACTION_BUTTON_TEXT_RECTS, ANGLE_SCALE, ARROW_CALLOUT_CONNECTION_SITES, ARROW_CALLOUT_PRESET_DEFINITIONS, ARROW_CONNECTION_SITES, ARROW_PRESET_DEFINITIONS, ARROW_TEXT_RECTS, BASIC_SHAPE_CONNECTION_SITES_A, BASIC_SHAPE_CONNECTION_SITES_B, BRACE_CONNECTION_SITES, BRACE_TEXT_RECTS, CALLOUT_CONNECTION_SITES, CALLOUT_TEXT_RECTS, CARDINAL_SITES, CHART_MARK_PRESET_DEFINITIONS, CIRCULAR_ARROW_CONNECTION_SITES, CIRCULAR_ARROW_TEXT_RECTS, CLIP_PATHS_CORE, CLIP_PATHS_EXTENDED, CLOUD_CALLOUT_PRESET_DEFINITIONS, CLOUD_CALLOUT_TAIL_COUNT, CLOUD_LOBE_COUNT, COM_AVLST_GROUND_TRUTH, CONNECTORS_BRACKETS_PRESET_DEFINITIONS, CURVED_ARROWS_CONNECTORS_PRESET_DEFINITIONS, CURVED_ARROW_CONNECTION_SITES, EPSILON, EXACT_CURVED_ARROW_PRESET_DEFINITIONS, EXTENDED_SHAPE_DEFINITIONS, FLOWCHART_CONNECTION_SITES, FLOWCHART_PRESET_DEFINITIONS, FLOWCHART_TEXT_RECTS, GEAR9_CONNECTION_SITES, GRAPH_LAYOUT_STYLES, IDENTITY_AFFINE, LEFT_CIRCULAR_ARROW_CONNECTION_SITES, LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES, MATH_SYMBOL_CONNECTION_SITES, MISC_ARROW_CONNECTION_SITES, MISC_PRESET_DEFINITIONS, MISC_SHAPE_CONNECTION_SITES, MISC_TEXT_RECTS_A, MISC_TEXT_RECTS_B, POLYGON_CONNECTION_SITES, POLYGON_TEXT_RECTS, PRESET_GEOMETRY_ALIASES, PRESET_SHAPE_CATEGORY_LABELS, PRESET_SHAPE_CLIP_PATHS, PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_GEOMETRY_TABLE, PRIMARY_SHAPE_DEFINITIONS, QUAD_CONNECTION_SITES, QUAD_TEXT_RECTS, RECTS_SNIPS_PRESET_DEFINITIONS, RECT_VARIANT_CONNECTION_SITES, REFINED_ARROW_PRESET_DEFINITIONS, RIBBON_CONNECTION_SITES, RIBBON_TEXT_RECTS, SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS, SNAP_THRESHOLD, STAR_CONNECTION_SITES, STAR_TEXT_RECTS, ST_SHAPE_TYPE_VALUES, TABS_DECORATIONS_PRESET_DEFINITIONS, TAB_CONNECTION_SITES, TAB_TEXT_RECTS, _internalForTests, alignElements, angleToRadians, at, autoAlignBoxes, buildCalloutLeaderLineSvgPath, clipPolygons, combineShapes, composeAffine, computeAlign, computeDistribute, computeRotation, computeSnap, computeSnapToShape, computeUnionWalk, convexHull, createBuiltinVariables, createRotationDrag, cross2, curvedElbowPathD, cxn, dedupPoly, distributeElements, elbowCurveSegments, elbowSegmentCount, elbowWaypoints, ensureCCW, ensureCW, evaluateFormula, evaluateGuides, findAllIntersections, flattenSvgPath, fmtNum, fragmentShapes, gd, gear6, gear9, getAdjustmentAwareClipPath, getCalloutLeaderLineGeometry, getCalloutTier, getCalloutViewBoxBounds, getCloudCalloutClipPath, getCloudClipPath, getPresetConnectionSites, getPresetShapeClipPath, getPresetTextRect, insertIntersections, intersectPolygons, intersectShapes, intersectSvgPaths, isCalloutShape, isConvex, isHorizontalPrimaryAxis, isStShapeType, layoutGraph, lineIntersection, lookupPresetConnectionSites, lookupPresetTextRectOverride, mergeOverlappingPolygons, mergeShapes, normalizeStShapeType, parseAdjustmentValues, parseFormula, parseGuideDefinitions, pointInPolygon, pointInTriangle, polygonArea, polygonsToSvgPath, resolveAlignReferenceBox, resolveCoordinate, resolveOperand, resolveRotateHandlePlacement, segmentIntersection, signedArea, snapBox, snapToGridStep, snapValue, subtractPolygons, subtractShapes, subtractSvgPaths, sutherlandHodgman, svgPathToPolygons, triangulate, unionPolygons, unionShapes, unionSvgPaths, usesSlideReference, vec2Eq };
+// 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;
+  }
+}
+
+export { ACTION_BUTTON_CONNECTION_SITES, ACTION_BUTTON_PRESET_DEFINITIONS, ACTION_BUTTON_TEXT_RECTS, ANGLE_SCALE, ARROW_CALLOUT_CONNECTION_SITES, ARROW_CALLOUT_PRESET_DEFINITIONS, ARROW_CONNECTION_SITES, ARROW_PRESET_DEFINITIONS, ARROW_TEXT_RECTS, BASIC_SHAPE_CONNECTION_SITES_A, BASIC_SHAPE_CONNECTION_SITES_B, BRACE_CONNECTION_SITES, BRACE_TEXT_RECTS, CALLOUT_CONNECTION_SITES, CALLOUT_TEXT_RECTS, CANVAS_SENTINEL, CARDINAL_SITES, CHART_MARK_PRESET_DEFINITIONS, CIRCULAR_ARROW_CONNECTION_SITES, CIRCULAR_ARROW_TEXT_RECTS, CLIP_PATHS_CORE, CLIP_PATHS_EXTENDED, CLOUD_CALLOUT_PRESET_DEFINITIONS, CLOUD_CALLOUT_TAIL_COUNT, CLOUD_LOBE_COUNT, COM_AVLST_GROUND_TRUTH, CONNECTORS_BRACKETS_PRESET_DEFINITIONS, CURVED_ARROWS_CONNECTORS_PRESET_DEFINITIONS, CURVED_ARROW_CONNECTION_SITES, EPSILON, EXACT_CURVED_ARROW_PRESET_DEFINITIONS, EXTENDED_SHAPE_DEFINITIONS, FLOWCHART_CONNECTION_SITES, FLOWCHART_PRESET_DEFINITIONS, FLOWCHART_TEXT_RECTS, GEAR9_CONNECTION_SITES, GRAPH_LAYOUT_STYLES, IDENTITY_AFFINE, LEFT_CIRCULAR_ARROW_CONNECTION_SITES, LEFT_RIGHT_CIRCULAR_ARROW_CONNECTION_SITES, MATH_SYMBOL_CONNECTION_SITES, MISC_ARROW_CONNECTION_SITES, MISC_PRESET_DEFINITIONS, MISC_SHAPE_CONNECTION_SITES, MISC_TEXT_RECTS_A, MISC_TEXT_RECTS_B, PADDING_DEFAULT, POLYGON_CONNECTION_SITES, POLYGON_TEXT_RECTS, PRESET_GEOMETRY_ALIASES, PRESET_SHAPE_CATEGORY_LABELS, PRESET_SHAPE_CLIP_PATHS, PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_GEOMETRY_TABLE, PRIMARY_SHAPE_DEFINITIONS, QUAD_CONNECTION_SITES, QUAD_TEXT_RECTS, RECTS_SNIPS_PRESET_DEFINITIONS, RECT_VARIANT_CONNECTION_SITES, REFINED_ARROW_PRESET_DEFINITIONS, RIBBON_CONNECTION_SITES, RIBBON_TEXT_RECTS, ROUTING_PADDING_DEFAULT, SCROLLS_ACCENT_CALLOUTS_PRESET_DEFINITIONS, SNAP_THRESHOLD, STAR_CONNECTION_SITES, STAR_TEXT_RECTS, ST_SHAPE_TYPE_VALUES, TABS_DECORATIONS_PRESET_DEFINITIONS, TAB_CONNECTION_SITES, TAB_TEXT_RECTS, _internalForTests, aStarOrthogonal, alignElements, angleToRadians, arrowKeyDelta, at, autoAlignBoxes, buildCalloutLeaderLineSvgPath, buildGraphNodes, clipPolygons, combineShapes, composeAffine, computeAlign, computeDistribute, computeRotation, computeSnap, computeSnapToShape, computeUnionWalk, convexHull, createBuiltinVariables, createRotationDrag, cross2, curvedElbowPathD, cxn, dedupPoly, directPathClear, distributeElements, elbowCurveSegments, elbowSegmentCount, elbowWaypoints, ensureCCW, ensureCW, evaluateFormula, evaluateGuides, findAllIntersections, flattenSvgPath, fmtNum, fragmentShapes, gd, gear6, gear9, getAdjustmentAwareClipPath, getCalloutLeaderLineGeometry, getCalloutTier, getCalloutViewBoxBounds, getCloudCalloutClipPath, getCloudClipPath, getPresetConnectionSites, getPresetShapeClipPath, getPresetTextRect, heuristic, inflateRect, insertIntersections, intersectPolygons, intersectShapes, intersectSvgPaths, isCalloutShape, isConvex, isHorizontalPrimaryAxis, isStShapeType, layoutGraph, lineIntersection, lookupPresetConnectionSites, lookupPresetTextRectOverride, mergeOverlappingPolygons, mergeShapes, normalizeStShapeType, parseAdjustmentValues, parseFormula, parseGuideDefinitions, pointInPolygon, pointInRect, pointInTriangle, pointKey, polygonArea, polygonsToSvgPath, resolveAlignReferenceBox, resolveCoordinate, resolveOperand, resolveRotateHandlePlacement, routeConnector, routeOrthogonalConnector, segmentIntersection, segmentIntersectsRect, signedArea, simplifyPath, snapAngle, snapBox, snapToGridStep, snapValue, subtractPolygons, subtractShapes, subtractSvgPaths, sutherlandHodgman, svgPathToPolygons, triangulate, unionPolygons, unionShapes, unionSvgPaths, usesSlideReference, vec2Eq, waypointsToPathD, waypointsToPathData };

package/dist/geometry/nudge.d.ts

@@ -0,0 +1,12 @@
+/** A selection move, in screen directions: x grows right and y grows down. */
+export interface NudgeDelta {
+    dx: number;
+    dy: number;
+}
+/**
+ * The move an arrow key nudges a selection by, `step` units in the arrow's screen direction, or
+ * `null` for any other key. Each product picks its own units and steps (slide pixels in
+ * PowerPoint, page inches in Visio); a y-up product negates `dy`.
+ */
+export declare function arrowKeyDelta(key: string, step: number): NudgeDelta | null;
+//# sourceMappingURL=nudge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nudge.d.ts","sourceRoot":"","sources":["../../geometry/nudge.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAa1E"}

package/dist/geometry/preset-shape-definitions-chart-marks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset-shape-definitions-chart-marks.d.ts","sourceRoot":"","sources":["../../geometry/preset-shape-definitions-chart-marks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAEX,6BAA6B,EAC7B,MAAM,kCAAkC,CAAC;AAsF1C,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,6BAA6B,CAIvF,CAAC"}
+{"version":3,"file":"preset-shape-definitions-chart-marks.d.ts","sourceRoot":"","sources":["../../geometry/preset-shape-definitions-chart-marks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAc,6BAA6B,EAAE,MAAM,kCAAkC,CAAC;AAsFlG,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,6BAA6B,CAIvF,CAAC"}

package/dist/geometry/preset-shape-paths.d.ts

@@ -9,5 +9,5 @@
  */
 export { type PresetShapeDefinition, type PresetShapeCategory } from './preset-shape-types.js';
 export { PRESET_SHAPE_CLIP_PATHS, getPresetShapeClipPath } from './preset-shape-clip-paths.js';
-export { PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_CATEGORY_LABELS, } from './preset-shape-definitions.js';
+export { PRESET_SHAPE_DEFINITIONS, PRESET_SHAPE_CATEGORY_LABELS } from './preset-shape-definitions.js';
 //# sourceMappingURL=preset-shape-paths.d.ts.map

package/dist/geometry/preset-shape-paths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preset-shape-paths.d.ts","sourceRoot":"","sources":["../../geometry/preset-shape-paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EACN,wBAAwB,EACxB,4BAA4B,GAC5B,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"preset-shape-paths.d.ts","sourceRoot":"","sources":["../../geometry/preset-shape-paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC5F,OAAO,EAAE,uBAAuB,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAC5F,OAAO,EAAE,wBAAwB,EAAE,4BAA4B,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/geometry/rotation-drag.d.ts

@@ -12,4 +12,10 @@ export declare function computeRotation(center: RotationPoint, pointer: Rotation
 export declare function createRotationDrag(center: RotationPoint, startPointer: RotationPoint, startRotation: number, options?: {
     unwrapped?: boolean;
 }): (pointer: RotationPoint) => number;
+/**
+ * Snap an angle to the nearest `step` degrees when within `tolerance`, normalised to [0, 360).
+ * Office editors use it for Shift-drag rotation (step 15). Returns the original angle when no
+ * snap target is close enough.
+ */
+export declare function snapAngle(angleDeg: number, step?: number, tolerance?: number): number;
 //# sourceMappingURL=rotation-drag.d.ts.map

package/dist/geometry/rotation-drag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rotation-drag.d.ts","sourceRoot":"","sources":["../../geometry/rotation-drag.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AACD,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAGrF;AACD;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,aAAa,EAC3B,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,CAAC,OAAO,EAAE,aAAa,KAAK,MAAM,CAyBpC"}
+{"version":3,"file":"rotation-drag.d.ts","sourceRoot":"","sources":["../../geometry/rotation-drag.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AACD,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,GAAG,MAAM,CAGrF;AACD;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,aAAa,EACrB,YAAY,EAAE,aAAa,EAC3B,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,CAAC,OAAO,EAAE,aAAa,KAAK,MAAM,CAyBpC;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,SAAK,EAAE,SAAS,SAAW,GAAG,MAAM,CAMnF"}