ooxml-core 0.2.0

package/dist/geometry/shape-boolean-ops.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Public API for shape boolean operations on SVG path strings and polygon
+ * arrays.
+ *
+ * Provides {@link unionShapes}, {@link intersectShapes},
+ * {@link subtractShapes}, {@link fragmentShapes}, {@link combineShapes},
+ * and the dispatcher {@link mergeShapes}, plus their polygon-array and
+ * SVG-path alias counterparts.
+ *
+ * @module geometry/shape-boolean-ops
+ */
+/**
+ * Compute the union of two SVG path shapes.
+ *
+ * Merges the outer boundaries of both shapes into a single path.
+ * For non-overlapping shapes, returns a multi-sub-path result.
+ *
+ * @param paths1 - First SVG path data string.
+ * @param paths2 - Second SVG path data string.
+ * @returns SVG path data string of the union.
+ */
+export declare function unionShapes(paths1: string, paths2: string): string;
+/**
+ * Compute the intersection of two SVG path shapes.
+ *
+ * Keeps only the overlapping region of both shapes.
+ *
+ * @param paths1 - First SVG path data string.
+ * @param paths2 - Second SVG path data string.
+ * @returns SVG path data string of the intersection.
+ */
+export declare function intersectShapes(paths1: string, paths2: string): string;
+/**
+ * Compute the subtraction of two SVG path shapes (paths1 - paths2).
+ *
+ * Removes the overlapping region of paths2 from paths1.
+ *
+ * @param paths1 - Subject SVG path data string.
+ * @param paths2 - Clip SVG path data string to subtract.
+ * @returns SVG path data string of the difference.
+ */
+export declare function subtractShapes(paths1: string, paths2: string): string;
+/**
+ * Fragment two SVG path shapes into non-overlapping pieces.
+ *
+ * Splits the shapes into up to 3 regions:
+ * - Parts of paths1 not overlapping paths2
+ * - Parts of paths2 not overlapping paths1
+ * - The overlapping region
+ *
+ * @param paths1 - First SVG path data string.
+ * @param paths2 - Second SVG path data string.
+ * @returns Array of SVG path data strings, one per fragment.
+ */
+export declare function fragmentShapes(paths1: string, paths2: string): string[];
+/**
+ * Compute the symmetric difference (XOR / Combine) of two SVG path shapes.
+ *
+ * Returns the regions that belong to exactly one of the two shapes,
+ * excluding the overlap. This is the PowerPoint "Combine" operation.
+ *
+ * @param paths1 - First SVG path data string.
+ * @param paths2 - Second SVG path data string.
+ * @returns SVG path data string of the combined (XOR) result.
+ */
+export declare function combineShapes(paths1: string, paths2: string): string;
+/** Supported merge shape operations (matching PowerPoint's Merge Shapes menu). */
+export type MergeShapeOperation = 'union' | 'intersect' | 'subtract' | 'fragment' | 'combine';
+/**
+ * Apply a merge shape operation to two SVG path strings.
+ *
+ * @param operation - The boolean operation to perform.
+ * @param paths1 - First SVG path data string.
+ * @param paths2 - Second SVG path data string.
+ * @returns Result SVG path string(s). Fragment returns multiple strings; others return one.
+ */
+export declare function mergeShapes(operation: MergeShapeOperation, paths1: string, paths2: string): string | string[];
+/**
+ * Compute the union of two polygons.
+ *
+ * Merges the outer boundaries of both polygons. For non-overlapping polygons,
+ * returns the concatenation of both polygon point arrays.
+ *
+ * @param poly1 - First polygon as array of [x, y] points.
+ * @param poly2 - Second polygon as array of [x, y] points.
+ * @returns Union polygon(s) as array of [x, y] points. When the union is a
+ *   single polygon it is the first (and only) element; disjoint polygons
+ *   produce multiple elements which are concatenated into a single flat array.
+ */
+export declare function unionPolygons(poly1: number[][], poly2: number[][]): number[][];
+/**
+ * Compute the intersection of two polygons.
+ *
+ * Keeps only the overlapping region of both polygons using
+ * Sutherland-Hodgman clipping.
+ *
+ * @param poly1 - First polygon as array of [x, y] points.
+ * @param poly2 - Second polygon as array of [x, y] points.
+ * @returns Intersection polygon as array of [x, y] points, or empty array
+ *   if no overlap.
+ */
+export declare function intersectPolygons(poly1: number[][], poly2: number[][]): number[][];
+/**
+ * Compute the subtraction of two polygons (poly1 - poly2).
+ *
+ * Removes the overlapping region of poly2 from poly1 using
+ * Sutherland-Hodgman clipping.
+ *
+ * @param poly1 - Subject polygon as array of [x, y] points.
+ * @param poly2 - Clip polygon to subtract as array of [x, y] points.
+ * @returns Difference polygon(s) as array of [x, y] points, or empty array
+ *   if nothing remains.
+ */
+export declare function subtractPolygons(poly1: number[][], poly2: number[][]): number[][];
+/**
+ * Compute the union of two SVG path strings.
+ * Alias for {@link unionShapes}.
+ *
+ * @param path1 - First SVG path data string.
+ * @param path2 - Second SVG path data string.
+ * @returns SVG path data string of the union.
+ */
+export declare function unionSvgPaths(path1: string, path2: string): string;
+/**
+ * Compute the intersection of two SVG path strings.
+ * Alias for {@link intersectShapes}.
+ *
+ * @param path1 - First SVG path data string.
+ * @param path2 - Second SVG path data string.
+ * @returns SVG path data string of the intersection.
+ */
+export declare function intersectSvgPaths(path1: string, path2: string): string;
+/**
+ * Compute the subtraction of two SVG path strings (path1 - path2).
+ * Alias for {@link subtractShapes}.
+ *
+ * @param path1 - First SVG path data string.
+ * @param path2 - Second SVG path data string.
+ * @returns SVG path data string of the difference.
+ */
+export declare function subtractSvgPaths(path1: string, path2: string): string;
+//# sourceMappingURL=shape-boolean-ops.d.ts.map

package/dist/geometry/shape-boolean-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-boolean-ops.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-boolean-ops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAoEH;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAiDlE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAqBtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgCrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqCvE;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAgBpE;AAMD,kFAAkF;AAClF,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC;AAE9F;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAC1B,SAAS,EAAE,mBAAmB,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,MAAM,EAAE,CAanB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAgB9E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAelF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAejF;AAMD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAErE"}

package/dist/geometry/shape-boolean-svg.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SVG path data parsing and serialization for polygon-based operations.
+ *
+ * Converts between SVG path data strings and arrays of polygon vertex arrays
+ * ({@link Vec2}[][]).  Only linear commands (M, L, H, V, Z and their relative
+ * variants) are supported — curves are not handled.
+ *
+ * @module geometry/shape-boolean-svg
+ */
+import type { Vec2 } from './shape-boolean-types.js';
+/**
+ * Parse an SVG path data string into an array of polygon vertex arrays.
+ *
+ * Only absolute M, L, H, V, and Z commands (and their relative lower-case
+ * variants) are supported. Each sub-path (delimited by M..Z) becomes a
+ * separate polygon.
+ *
+ * @param pathData - SVG path data string.
+ * @returns Array of polygons (each polygon is an array of Vec2).
+ */
+export declare function svgPathToPolygons(pathData: string): Vec2[][];
+/**
+ * Convert polygon vertex arrays to an SVG path data string.
+ *
+ * Each polygon becomes an M ... L ... Z sub-path.
+ *
+ * @param polygons - Array of polygons (each an array of Vec2).
+ * @returns SVG path data string.
+ */
+export declare function polygonsToSvgPath(polygons: Vec2[][]): string;
+//# sourceMappingURL=shape-boolean-svg.d.ts.map

package/dist/geometry/shape-boolean-svg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-boolean-svg.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-boolean-svg.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAOrD;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,EAAE,CAoH5D;AAMD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,GAAG,MAAM,CAa5D"}

package/dist/geometry/shape-boolean-types.d.ts

@@ -0,0 +1,91 @@
+/** A 2D point for polygon operations. */
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+/** Tolerance used for floating-point comparisons. */
+export declare const EPSILON = 1e-9;
+/**
+ * Test approximate equality of two 2D points within {@link EPSILON}.
+ *
+ * @param a - First point.
+ * @param b - Second point.
+ * @returns `true` when the points are within EPSILON distance on both axes.
+ */
+export declare function vec2Eq(a: Vec2, b: Vec2): boolean;
+/**
+ * Compute the 2D cross product of vectors OA and OB.
+ *
+ * Positive when the turn O→A→B is counter-clockwise.
+ *
+ * @param o - Origin point.
+ * @param a - First arm endpoint.
+ * @param b - Second arm endpoint.
+ * @returns Signed scalar cross product.
+ */
+export declare function cross2(o: Vec2, a: Vec2, b: Vec2): number;
+/**
+ * Signed area of a polygon (positive = counter-clockwise).
+ *
+ * @param poly - Array of polygon vertices.
+ * @returns Signed area (positive for CCW winding).
+ */
+export declare function signedArea(poly: Vec2[]): number;
+/**
+ * Ensure polygon vertices are in counter-clockwise order.
+ *
+ * @param poly - Input polygon.
+ * @returns A polygon guaranteed to be CCW (may return a reversed copy).
+ */
+export declare function ensureCCW(poly: Vec2[]): Vec2[];
+/**
+ * Ensure polygon vertices are in clockwise order.
+ *
+ * @param poly - Input polygon.
+ * @returns A polygon guaranteed to be CW (may return a reversed copy).
+ */
+export declare function ensureCW(poly: Vec2[]): Vec2[];
+/**
+ * Unsigned area of a polygon.
+ *
+ * @param poly - Array of polygon vertices.
+ * @returns Absolute (unsigned) area.
+ */
+export declare function polygonArea(poly: Vec2[]): number;
+/**
+ * Remove consecutive duplicate vertices from a polygon.
+ *
+ * Also removes the closing duplicate when the first and last vertices coincide.
+ *
+ * @param poly - Input polygon.
+ * @returns De-duplicated polygon.
+ */
+export declare function dedupPoly(poly: Vec2[]): Vec2[];
+/**
+ * Format a number, removing unnecessary trailing zeros.
+ *
+ * Rounds to 4 decimal places to avoid floating-point noise.
+ *
+ * @param n - Number to format.
+ * @returns String representation.
+ */
+export declare function fmtNum(n: number): string;
+/**
+ * Test if point `p` is inside triangle `abc` (inclusive of edges).
+ *
+ * @param p - Point to test.
+ * @param a - First triangle vertex.
+ * @param b - Second triangle vertex.
+ * @param c - Third triangle vertex.
+ * @returns `true` when p lies on or inside the triangle.
+ */
+export declare function pointInTriangle(p: Vec2, a: Vec2, b: Vec2, c: Vec2): boolean;
+/**
+ * Test if a point is inside a polygon using the ray-casting algorithm.
+ *
+ * @param pt - Point to test.
+ * @param poly - Polygon vertices.
+ * @returns `true` when the point is inside the polygon.
+ */
+export declare function pointInPolygon(pt: Vec2, poly: Vec2[]): boolean;
+//# sourceMappingURL=shape-boolean-types.d.ts.map

package/dist/geometry/shape-boolean-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-boolean-types.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-boolean-types.ts"],"names":[],"mappings":"AAeA,yCAAyC;AACzC,MAAM,WAAW,IAAI;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qDAAqD;AACrD,eAAO,MAAM,OAAO,OAAO,CAAC;AAM5B;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAEhD;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,CAQ/C;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAE9C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAE7C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,CAEhD;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAe9C;AAED;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxC;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,OAAO,CAO3E;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,OAAO,CAa9D"}

package/dist/geometry/shape-boolean-union.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Union algorithm for polygon boolean operations.
+ *
+ * Implements a Weiler-Atherton-inspired boundary walk to merge two
+ * (possibly concave) polygons into their union outline. Falls back to
+ * convex-hull when the walk produces no result.
+ *
+ * @module geometry/shape-boolean-union
+ */
+import type { Vec2 } from './shape-boolean-types.js';
+/**
+ * Compute the intersection of two line segments (A1→A2 and B1→B2).
+ *
+ * Returns the intersection point together with the parametric `t` values
+ * along each segment, or `null` when the segments do not cross.
+ *
+ * @param a1 - Start of segment A.
+ * @param a2 - End of segment A.
+ * @param b1 - Start of segment B.
+ * @param b2 - End of segment B.
+ * @returns Intersection descriptor or `null`.
+ */
+export declare function segmentIntersection(a1: Vec2, a2: Vec2, b1: Vec2, b2: Vec2): {
+    pt: Vec2;
+    tA: number;
+    tB: number;
+} | null;
+/**
+ * Find all intersection points between the edges of two polygons.
+ *
+ * @param polyA - First polygon.
+ * @param polyB - Second polygon.
+ * @returns Array of intersection descriptors including the point, edge
+ *   indices, and parametric t values.
+ */
+export declare function findAllIntersections(polyA: Vec2[], polyB: Vec2[]): Array<{
+    pt: Vec2;
+    edgeA: number;
+    tA: number;
+    edgeB: number;
+    tB: number;
+}>;
+/**
+ * Build a copy of a polygon with intersection vertices inserted at the
+ * correct positions along each edge.
+ *
+ * @param poly - Original polygon.
+ * @param intersections - Intersection descriptors (edge index + parametric t).
+ * @returns Augmented polygon.
+ */
+export declare function insertIntersections(poly: Vec2[], intersections: Array<{
+    pt: Vec2;
+    edge: number;
+    t: number;
+}>): Vec2[];
+/**
+ * Compute the convex hull of a set of points using Andrew's monotone chain
+ * algorithm.
+ *
+ * @param points - Input points.
+ * @returns Vertices of the convex hull in CCW order.
+ */
+export declare function convexHull(points: Vec2[]): Vec2[];
+/**
+ * Walk along polygon boundaries to construct the union outline.
+ *
+ * Uses a simplified Weiler-Atherton-style approach: augmented polygons
+ * (with intersection vertices inserted) are walked, switching between
+ * polygon A and polygon B at each intersection to trace the exterior
+ * boundary.
+ *
+ * Falls back to convex hull when the walk produces no valid result.
+ *
+ * @param polyA - First polygon (CCW).
+ * @param polyB - Second polygon (CCW).
+ * @returns Array of union result polygons.
+ */
+export declare function computeUnionWalk(polyA: Vec2[], polyB: Vec2[]): Vec2[][];
+//# sourceMappingURL=shape-boolean-union.d.ts.map

package/dist/geometry/shape-boolean-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-boolean-union.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-boolean-union.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAOrD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAClC,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,IAAI,EACR,EAAE,EAAE,IAAI,GACN;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAuB7C;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,IAAI,EAAE,EACb,KAAK,EAAE,IAAI,EAAE,GACX,KAAK,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CA6B3E;AAMD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,IAAI,EAAE,EACZ,aAAa,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACzD,IAAI,EAAE,CAuBR;AAMD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,CAqCjD;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,EAAE,CA4HvE"}

package/dist/geometry/shape-boolean.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shape boolean operations: union, intersect, subtract, fragment, combine.
+ *
+ * Implements polygon clipping using the Sutherland-Hodgman algorithm for
+ * intersection and a vertex-insertion approach for union/subtract/fragment.
+ * Operates on polygon-only geometry (line segments, no curves), which covers
+ * the vast majority of real-world PowerPoint preset shapes.
+ *
+ * This file re-exports the public API from focused sub-modules:
+ * - `shape-boolean-types` — Vec2 type and point-level helpers
+ * - `shape-boolean-svg` — SVG path parsing / serialization
+ * - `shape-boolean-clipping` — Sutherland-Hodgman and convex decomposition
+ * - `shape-boolean-union` — Weiler-Atherton-inspired union walk
+ * - `shape-boolean-ops` — High-level boolean operations on SVG paths
+ *
+ * @module geometry/shape-boolean
+ */
+export type { Vec2 } from './shape-boolean-types.js';
+export { svgPathToPolygons, polygonsToSvgPath } from './shape-boolean-svg.js';
+export { unionShapes, intersectShapes, subtractShapes, fragmentShapes, combineShapes, mergeShapes, unionPolygons, intersectPolygons, subtractPolygons, unionSvgPaths, intersectSvgPaths, subtractSvgPaths, } from './shape-boolean-ops.js';
+export type { MergeShapeOperation } from './shape-boolean-ops.js';
+//# sourceMappingURL=shape-boolean.d.ts.map

package/dist/geometry/shape-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-boolean.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-boolean.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,YAAY,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAGrD,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAG9E,OAAO,EACN,WAAW,EACX,eAAe,EACf,cAAc,EACd,cAAc,EACd,aAAa,EACb,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GAChB,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/geometry/shape-definitions-extended.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Extended shape definitions: Arrows, Callouts, Flowchart, and Action Buttons.
+ *
+ * Each entry in the array is a {@link PresetShapeDefinition} with:
+ * - `name` — The canonical OOXML preset geometry name (camelCase).
+ * - `label` — A human-readable display label for the shape picker UI.
+ * - `category` — The {@link PresetShapeCategory} grouping.
+ *
+ * This file contains the second half of shape definitions. The first
+ * half (basic, rectangles, stars, math, other) lives in
+ * `shape-definitions-primary.ts`.
+ */
+import type { PresetShapeDefinition } from './preset-shape-types.js';
+/**
+ * Shape definitions for arrows, callouts, flowchart symbols, and action buttons.
+ */
+export declare const EXTENDED_SHAPE_DEFINITIONS: PresetShapeDefinition[];
+//# sourceMappingURL=shape-definitions-extended.d.ts.map

package/dist/geometry/shape-definitions-extended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-definitions-extended.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-definitions-extended.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,0BAA0B,EAAE,qBAAqB,EA6P7D,CAAC"}

package/dist/geometry/shape-definitions-primary.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Primary shape definitions: Basic, Rectangles, Stars and Banners, Math, and Other.
+ *
+ * Each entry in the array is a {@link PresetShapeDefinition} with:
+ * - `name` — The canonical OOXML preset geometry name (camelCase).
+ * - `label` — A human-readable display label for the shape picker UI.
+ * - `category` — The {@link PresetShapeCategory} grouping.
+ *
+ * This file contains the first half of shape definitions. The second
+ * half (arrows, callouts, flowchart, action buttons) lives in
+ * `shape-definitions-extended.ts`.
+ */
+import type { PresetShapeDefinition } from './preset-shape-types.js';
+/**
+ * Shape definitions for basic shapes, rectangle variants, stars and banners,
+ * math operators, and other miscellaneous shapes.
+ */
+export declare const PRIMARY_SHAPE_DEFINITIONS: PresetShapeDefinition[];
+//# sourceMappingURL=shape-definitions-primary.d.ts.map

package/dist/geometry/shape-definitions-primary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-definitions-primary.d.ts","sourceRoot":"","sources":["../../src/geometry/shape-definitions-primary.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE;;;GAGG;AACH,eAAO,MAAM,yBAAyB,EAAE,qBAAqB,EAgI5D,CAAC"}