ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/connector-router-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-router-types.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-router-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,kCAAkC;AAClC,MAAM,WAAW,WAAW;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,yDAAyD;AACzD,MAAM,WAAW,UAAU;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,qDAAqD;AACrD,MAAM,MAAM,KAAK,GAAG,WAAW,CAAC;AAEhC,oDAAoD;AACpD,MAAM,MAAM,IAAI,GAAG,UAAU,CAAC;AAE9B;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACtC,KAAK,EAAE,WAAW,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;IACjB,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,UAAU,CAAC,EAAE,OAAO,CAAC;CACrB;AAED,qEAAqE;AACrE,MAAM,WAAW,uBAAuB;IACvC,gDAAgD;IAChD,KAAK,EAAE,WAAW,CAAC;IACnB,8CAA8C;IAC9C,GAAG,EAAE,WAAW,CAAC;IACjB,mDAAmD;IACnD,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAC;IACrC,8EAA8E;IAC9E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+EAA+E;IAC/E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,yDAAyD;AACzD,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,KAAkB,CAAC;AAEvD,8DAA8D;AAC9D,eAAO,MAAM,eAAe,SAAU,CAAC"}

package/dist/pptx/render/connector-router.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Public orthogonal connector routing API (shared across bindings).
+ *
+ * Two equivalent entry points are exported so the React and Angular consumers
+ * keep their exact import surface:
+ * - {@link routeConnector}  -  React-style options object; `[start, end]`
+ *   fallbacks; pairs with {@link waypointsToPathData} (space-separated `M x y`).
+ * - {@link routeOrthogonalConnector}  -  Angular-style positional args with
+ *   optional canvas dims (sentinel default); pairs with {@link waypointsToPathD}
+ *   (comma-separated `Mx,y`).
+ *
+ * Both routers share one implementation; only the argument shape and the
+ * default-canvas handling differ.
+ */
+import type { ConnectorRouterOptions, OrthogonalRouterOptions, RouterPoint, RouterRect } from './connector-router-types.js';
+export type { RouterPoint, RouterRect, ConnectorRouterOptions, OrthogonalRouterOptions, } from './connector-router-types.js';
+export { PADDING_DEFAULT, ROUTING_PADDING_DEFAULT, CANVAS_SENTINEL, } from './connector-router-types.js';
+export { inflateRect, pointInRect, segmentIntersectsRect, directPathClear, heuristic, pointKey, buildGraphNodes, } from './connector-router-graph.js';
+export { aStarOrthogonal, simplifyPath } from './connector-router-astar.js';
+/**
+ * Route a connector between two points, avoiding obstacle bounding boxes.
+ * Returns an array of waypoints (including start and end) forming an orthogonal
+ * polyline. (React-style options object.)
+ */
+export declare function routeConnector(options: ConnectorRouterOptions): RouterPoint[];
+/** Convert an array of waypoints to an SVG path `d` string (space-separated). */
+export declare function waypointsToPathData(waypoints: ReadonlyArray<RouterPoint>): string;
+/**
+ * Route an orthogonal connector (positional args, optional canvas dims).
+ * Canvas dimensions default to a large sentinel when omitted.
+ */
+export declare function routeOrthogonalConnector(start: RouterPoint, end: RouterPoint, obstacles: ReadonlyArray<RouterRect>, opts?: Pick<OrthogonalRouterOptions, 'canvasWidth' | 'canvasHeight' | 'padding'>): RouterPoint[];
+/** Convert an array of waypoints to an SVG path `d` string (comma-separated). */
+export declare function waypointsToPathD(waypoints: ReadonlyArray<RouterPoint>): string;
+//# sourceMappingURL=connector-router.d.ts.map

package/dist/pptx/render/connector-router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-router.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-router.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAUH,OAAO,KAAK,EACX,sBAAsB,EACtB,uBAAuB,EACvB,WAAW,EACX,UAAU,EACV,MAAM,0BAA0B,CAAC;AAElC,YAAY,EACX,WAAW,EACX,UAAU,EACV,sBAAsB,EACtB,uBAAuB,GACvB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACN,eAAe,EACf,uBAAuB,EACvB,eAAe,GACf,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACN,WAAW,EACX,WAAW,EACX,qBAAqB,EACrB,eAAe,EACf,SAAS,EACT,QAAQ,EACR,eAAe,GACf,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AA6EzE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,sBAAsB,GAAG,WAAW,EAAE,CAG7E;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,MAAM,CASjF;AAMD;;;GAGG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,WAAW,EAClB,GAAG,EAAE,WAAW,EAChB,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,EACpC,IAAI,CAAC,EAAE,IAAI,CAAC,uBAAuB,EAAE,aAAa,GAAG,cAAc,GAAG,SAAS,CAAC,GAC9E,WAAW,EAAE,CAKf;AAED,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,MAAM,CAS9E"}

package/dist/pptx/render/connector-sites.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Connection-site resolution for connectors: where on a shape a connector end
+ * may bind, in slide-ready coordinates. Pure (no framework imports).
+ *
+ * Split out of `connector-reroute.ts`, which re-exports everything here so the
+ * historical import path keeps working. Consumed by the reroute, connector
+ * authoring, the endpoint-drag helpers and every binding's site overlay, so a
+ * site means the same place to all of them.
+ *
+ * @module render/connector-sites
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** A single connection site on a shape's bounding box (element-local coords). */
+export interface ConnectionSite {
+    x: number;
+    y: number;
+    index: number;
+}
+/**
+ * Compute connection sites for a rectangular bounding box. Returns the four
+ * edge midpoints in element-local coordinates: top, right, bottom, left.
+ *
+ * This is the fallback used for shapes whose real connection sites are
+ * unknown (preset shapes without a parsed `a:cxnLst`).
+ */
+export declare function getConnectionSites(width: number, height: number): ConnectionSite[];
+/** The frame fields that place a connection site on the slide. */
+export type ConnectionSiteFrame = Pick<PptxElement, 'width' | 'height' | 'rotation' | 'flipHorizontal' | 'flipVertical'>;
+/**
+ * Carry a site from the shape's UNROTATED box into the frame the shape is
+ * actually drawn in: flip about the box centre (`a:xfrm/@flipH`, `@flipV`),
+ * then rotate about it by `@rot` (degrees, clockwise on screen), the same
+ * order `getElementOrientationMatrix` composes for text. The result is still
+ * relative to the frame origin, so `shape.x + site.x` is the on-slide point.
+ *
+ * Without this every consumer attached a connector to where the site WOULD be
+ * if the shape were upright: on a 90-degree-rotated rectangle the "top" site
+ * sat in mid-air a half-width away from the edge it belongs to, and the site
+ * dots the overlay draws for the drag were in the same wrong place.
+ */
+export declare function transformConnectionSite(site: ConnectionSite, frame: ConnectionSiteFrame): ConnectionSite;
+/**
+ * Resolve the connection sites of a shape element relative to its frame
+ * origin, with the shape's own flip and rotation applied (see
+ * {@link transformConnectionSite}) so `shape.x + site.x` / `shape.y + site.y`
+ * is where the site sits on the slide.
+ *
+ * When the shape carries typed custom-geometry connection sites (parsed from
+ * `a:custGeom/a:cxnLst/a:cxn`), each `a:pos` formula is evaluated against the
+ * shape's path coordinate space and scaled to the element's pixel box, so a
+ * connector referencing `stCxn/@idx` on a non-rectangular shape attaches near
+ * the real site rather than collapsing to an edge midpoint. Shapes with no
+ * known sites fall back to the four edge midpoints.
+ */
+export declare function getShapeConnectionSites(shape: PptxElement): ConnectionSite[];
+/**
+ * The same sites as {@link getShapeConnectionSites} in the shape's upright,
+ * unflipped box: what `a:cxnLst` literally describes, before the frame
+ * transform. For callers that draw inside the shape's own (already
+ * transformed) coordinate system.
+ *
+ * Resolution order: an authored `a:custGeom/a:cxnLst` wins when present (each
+ * `a:pos` formula evaluated against the shape's own path coordinate space and
+ * scaled to the element's pixel box). Otherwise a PRESET shape consults
+ * {@link getPresetConnectionSites} (ECMA-376's own `cxnLst` for that preset,
+ * evaluated with the shape's `a:avLst` adjustments), so a
+ * `triangle`/`chevron`/`pentagon`/... attaches near its real sites instead of
+ * collapsing to an edge midpoint. Shapes with no known sites at all fall back
+ * to the four edge midpoints.
+ */
+export declare function getUnrotatedShapeConnectionSites(shape: PptxElement): ConnectionSite[];
+//# sourceMappingURL=connector-sites.d.ts.map

package/dist/pptx/render/connector-sites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-sites.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-sites.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,EAAE,CAWlF;AAWD,kEAAkE;AAClE,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACrC,WAAW,EACX,OAAO,GAAG,QAAQ,GAAG,UAAU,GAAG,gBAAgB,GAAG,cAAc,CACnE,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,mBAAmB,GACxB,cAAc,CAmBhB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,EAAE,CAI5E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,EAAE,CAgCrF"}

package/dist/pptx/render/connector-style.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pure connector line-style helpers shared across bindings.
+ *
+ * Compound (double/triple) parallel-stroke geometry and connector-family
+ * classification. No framework imports. The actual SVG `<marker>` / `<path>`
+ * emission stays in each binding's view layer.
+ */
+/** OOXML compound line token type (`a:ln/@cmpd`). */
+export type CompoundLineType = 'sng' | 'dbl' | 'thickThin' | 'thinThick' | 'tri';
+/**
+ * Compute perpendicular offsets for compound (double/triple) line styles.
+ * Returns an array of offset distances from the centre line in px. A single
+ * line style returns `[0]`.
+ *
+ * @param compoundLine - OOXML `a:ln/@cmpd` value (e.g. `"dbl"`, `"tri"`).
+ * @param strokeWidth  - The resolved stroke width in pixels.
+ */
+export declare function getCompoundLineOffsets(compoundLine: string | undefined, strokeWidth: number): number[];
+/**
+ * Compute individual stroke widths for each parallel path in a compound line.
+ * The array length matches the one returned by {@link getCompoundLineOffsets}.
+ *
+ * @param compoundLine - OOXML `a:ln/@cmpd` value.
+ * @param strokeWidth  - The resolved stroke width in pixels.
+ */
+export declare function getCompoundLineWidths(compoundLine: string | undefined, strokeWidth: number): number[];
+/**
+ * Map an OOXML line-cap token (`a:ln/@cap`) to its SVG `stroke-linecap` value.
+ *
+ * `flat` -> `butt`, `sq` -> `square`, `rnd` -> `round`. Anything absent or
+ * unrecognised falls back to `round`, matching the viewer's historical default.
+ */
+export declare function svgLineCap(lineCap: 'flat' | 'rnd' | 'sq' | undefined): 'butt' | 'round' | 'square';
+/** Connector routing family, derived from the OOXML preset shape type. */
+export type ConnectorKind = 'straight' | 'bent' | 'curved';
+/**
+ * Classify a connector by its OOXML preset shape type (case-insensitive):
+ * `bentConnector*` → `"bent"`, `curvedConnector*` → `"curved"`, everything
+ * else (incl. `straightConnector1`) → `"straight"`.
+ */
+export declare function connectorKind(shapeType: string | undefined): ConnectorKind;
+/**
+ * Determine whether a connector `shapeType` requires multi-segment (path)
+ * rendering rather than a simple `<line>` element.
+ */
+export declare function connectorNeedsPath(shapeType: string | undefined): boolean;
+//# sourceMappingURL=connector-style.d.ts.map

package/dist/pptx/render/connector-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/connector-style.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,KAAK,CAAC;AAEjF;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACrC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,WAAW,EAAE,MAAM,GACjB,MAAM,EAAE,CAkBV;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACpC,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,WAAW,EAAE,MAAM,GACjB,MAAM,EAAE,CAkBV;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACzB,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS,GACxC,MAAM,GAAG,OAAO,GAAG,QAAQ,CAS7B;AAED,0EAA0E;AAC1E,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE3D;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,aAAa,CAS1E;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEzE"}

package/dist/pptx/render/content-part-strokes.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var chunkFOE75Z6N_cjs = require('../chunk-FOE75Z6N.cjs');
+require('../chunk-NTXHQHCS.cjs');
+
+
+
+Object.defineProperty(exports, "buildContentPartStrokes", {
+  enumerable: true,
+  get: function () { return chunkFOE75Z6N_cjs.buildContentPartStrokes; }
+});
+Object.defineProperty(exports, "contentPartViewBox", {
+  enumerable: true,
+  get: function () { return chunkFOE75Z6N_cjs.contentPartViewBox; }
+});

package/dist/pptx/render/content-part-strokes.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Framework-neutral view model for `p:contentPart` ink.
+ *
+ * Every binding paints the same thing from the same data: one SVG per content
+ * part, sized to the element box, holding a constant-width `<path>` per
+ * stroke, a run of pressure `<circle>`s, or (when the source declared a pen-
+ * tilt channel) a run of tilt-driven `<ellipse>` nib marks. This module is
+ * the single decision function for that; a binding only maps the returned
+ * descriptors onto its own template.
+ *
+ * It was lifted out of `packages/svelte/src/viewer/render/contentpart-view.ts`
+ * when Vue and Angular needed the same logic. Before that, three of the five
+ * bindings each had their own copy and Vue and Angular had none at all, so a
+ * real inked slide fell through to their "unsupported element" placeholder.
+ *
+ * @module render/content-part-strokes
+ */
+import type { ContentPartPptxElement } from 'ooxml-core/pptx';
+import type { InkStrokeView } from './ink-stroke-view.js';
+/** One rendered content-part ink stroke: a constant-width path, pressure circles, or tilt nib marks. */
+export interface ContentPartStrokeView extends InkStrokeView {
+    key: string;
+}
+/** SVG `viewBox` for the content-part element's bounding box (min 1x1). */
+export declare function contentPartViewBox(element: ContentPartPptxElement): string;
+/** Project the element's ink strokes into per-stroke view models. */
+export declare function buildContentPartStrokes(element: ContentPartPptxElement): ContentPartStrokeView[];
+//# sourceMappingURL=content-part-strokes.d.ts.map

package/dist/pptx/render/content-part-strokes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-part-strokes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/content-part-strokes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,wGAAwG;AACxG,MAAM,WAAW,qBAAsB,SAAQ,aAAa;IAC3D,GAAG,EAAE,MAAM,CAAC;CACZ;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,sBAAsB,GAAG,MAAM,CAE1E;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,EAAE,CAahG"}

package/dist/pptx/render/content-part-strokes.mjs

@@ -0,0 +1,2 @@
+export { buildContentPartStrokes, contentPartViewBox } from '../chunk-IB6ZM2E2.mjs';
+import '../chunk-JA7WYSRE.mjs';

package/dist/pptx/render/context-menu-commands.d.ts

@@ -0,0 +1,104 @@
+/**
+ * The one definition of what the canvas context menu contains.
+ *
+ * The five menus were written five times from scratch rather than ported from a
+ * single item list, and their command sets drifted exactly as you would expect:
+ * Vue had no Bring to Front, Angular had no Edit Hyperlink or Group, Svelte had
+ * no table commands at all, and Vanilla had no menu whatsoever. Nothing crashes
+ * when a binding omits a command, so each omission was only ever discoverable by
+ * the user who right-clicked expecting it.
+ *
+ * This module owns the command ids, their labels, their order, the separators
+ * between the groups, and the rules deciding which are offered. A binding
+ * supplies the context (what was clicked, what is selected) and renders the
+ * result; it does not decide what is in the menu. Adding a command here adds it
+ * to all five at once, which is the point.
+ *
+ * The operations themselves stay in the bindings: each already owns clipboard,
+ * z-order, grouping, comments, hyperlink and table mutation, and routing them is
+ * a switch over {@link ContextMenuCommandId}.
+ *
+ * @module render/context-menu-commands
+ */
+import type { PptxTableData } from 'ooxml-core/pptx';
+import type { EditPointsAvailability } from './edit-points/edit-points-availability.js';
+import type { MergeShapesCommandId } from './merge-shapes/merge-shapes-menu.js';
+import type { CellCoord } from './table-merge.js';
+/**
+ * A merge-aware range includes hidden continuation cells. Count visible
+ * anchors, not those logical slots, when choosing between Merge and Split.
+ * Raw-only tables retain coordinate-based selection when no model is available.
+ */
+export declare function hasMultipleSelectedTableCells(cells: readonly CellCoord[] | undefined, tableData?: PptxTableData): boolean;
+/** Every command a canvas context menu can offer, in no particular order. */
+export type ContextMenuCommandId = 'copy' | 'cut' | 'paste' | 'duplicate' | 'edit-text' | 'edit-points' | 'bring-forward' | 'send-backward' | 'bring-front' | 'send-back' | 'ai-ask' | 'ai-fix' | 'comment' | 'hyperlink' | 'table-insert-row-above' | 'table-insert-row-below' | 'table-delete-row' | 'table-insert-col-left' | 'table-insert-col-right' | 'table-delete-col' | 'table-merge-selected' | 'table-merge-right' | 'table-merge-down' | 'table-split' | 'group' | 'ungroup' | 'crop' | MergeShapesCommandId | 'save-as-picture' | 'edit-alt-text' | 'size-and-position' | 'format-shape' | 'delete';
+/** One rendered entry: a command, plus how it is presented. */
+export interface ContextMenuEntry {
+    id: ContextMenuCommandId;
+    /** i18n key; the binding translates it with its own translator. */
+    labelKey: string;
+    /** Draw a rule above this entry (it opens a new group of commands). */
+    separatorBefore?: boolean;
+    /** Destructive: tinted red, as PowerPoint tints Delete. */
+    danger?: boolean;
+    /** Offered but not usable right now (greyed out, still announced). */
+    disabled?: boolean;
+}
+/** The table cell the menu was opened on, when it was opened on one. */
+export interface ContextMenuTableContext {
+    /** Two or more visible cells are selected, so the merge is a block merge. */
+    hasMultiCellSelection: boolean;
+    /** The cell already spans, so it can be split but not merged again. */
+    isMergedCell: boolean;
+}
+/** What the menu is being opened on. */
+export interface ContextMenuContext {
+    /** `PptxElement['type']` of the right-clicked element, when known. */
+    elementType?: string | null;
+    /** The table cell context, or null when this is not a table cell. */
+    table?: ContextMenuTableContext | null;
+    /** Two or more elements are selected, so they can be grouped. */
+    hasMultiSelection?: boolean;
+    /**
+     * `a:spLocks/@noGrp` on any selected element (Group) or `a:grpSpLocks/@noGrp`
+     * on the right-clicked group itself (Ungroup) rejects the whole attempt.
+     * Omit when the binding has not computed it yet; the entry is then offered
+     * enabled, same as before this field existed.
+     */
+    selectionGroupable?: boolean;
+    /** The AI assistant is configured by the host. */
+    aiEnabled?: boolean;
+    /**
+     * Two or more mergeable shapes are selected (shared `canMergeShapes`), so
+     * the five Merge Shapes entries are offered.
+     */
+    canMergeShapes?: boolean;
+    /**
+     * For a picture: whether it may be cropped (shared `canCropElement`).
+     * Omitted means croppable; false greys Crop out (`a:picLocks/@noCrop`).
+     */
+    canCrop?: boolean;
+    /**
+     * Whether there is anything to paste. Omit when the binding does not track
+     * it: Paste is then offered enabled, which is what React has always done.
+     */
+    hasClipboard?: boolean;
+    /**
+     * Edit Points for the right-clicked element, from
+     * `resolveEditPointsAvailability`: offered when `available`, greyed out when
+     * `locked` (`a:spLocks/@noEditPoints`), absent otherwise. Omit when the
+     * binding does not support Edit Points.
+     */
+    editPoints?: EditPointsAvailability;
+}
+/** The i18n key for a command, so a binding never spells one out itself. */
+export declare function contextMenuLabelKey(id: ContextMenuCommandId): string;
+/**
+ * The menu for `context`, in order, separators included.
+ *
+ * Group is offered only on a multi-selection and Ungroup only on a group, which
+ * is how PowerPoint behaves and how React has always behaved: a permanently
+ * present, permanently greyed Group is noise on a single shape.
+ */
+export declare function buildContextMenuEntries(context?: ContextMenuContext): ContextMenuEntry[];
+//# sourceMappingURL=context-menu-commands.d.ts.map

package/dist/pptx/render/context-menu-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-commands.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/context-menu-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AACrF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAE7E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC5C,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,SAAS,EACvC,SAAS,CAAC,EAAE,aAAa,GACvB,OAAO,CAaT;AAED,6EAA6E;AAC7E,MAAM,MAAM,oBAAoB,GAC7B,MAAM,GACN,KAAK,GACL,OAAO,GACP,WAAW,GACX,WAAW,GACX,aAAa,GACb,eAAe,GACf,eAAe,GACf,aAAa,GACb,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,WAAW,GACX,wBAAwB,GACxB,wBAAwB,GACxB,kBAAkB,GAClB,uBAAuB,GACvB,wBAAwB,GACxB,kBAAkB,GAClB,sBAAsB,GACtB,mBAAmB,GACnB,kBAAkB,GAClB,aAAa,GACb,OAAO,GACP,SAAS,GACT,MAAM,GACN,oBAAoB,GACpB,iBAAiB,GACjB,eAAe,GACf,mBAAmB,GACnB,cAAc,GACd,QAAQ,CAAC;AAEZ,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAChC,EAAE,EAAE,oBAAoB,CAAC;IACzB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,uEAAuE;IACvE,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,wEAAwE;AACxE,MAAM,WAAW,uBAAuB;IACvC,6EAA6E;IAC7E,qBAAqB,EAAE,OAAO,CAAC;IAC/B,uEAAuE;IACvE,YAAY,EAAE,OAAO,CAAC;CACtB;AAED,wCAAwC;AACxC,MAAM,WAAW,kBAAkB;IAClC,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,qEAAqE;IACrE,KAAK,CAAC,EAAE,uBAAuB,GAAG,IAAI,CAAC;IACvC,iEAAiE;IACjE,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,kDAAkD;IAClD,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAC;CACpC;AA0CD,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,oBAAoB,GAAG,MAAM,CAEpE;AA0CD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,GAAE,kBAAuB,GAAG,gBAAgB,EAAE,CAmE5F"}

package/dist/pptx/render/context-menu-inspector-anchor.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Which inspector section a "format object" context-menu command should
+ * scroll into view, once the binding has switched the sidebar to the element
+ * properties tab.
+ *
+ * PowerPoint's "Edit Alt Text", "Size and Position" and "Format Shape" each
+ * open a dedicated task pane; this viewer keeps one scrollable properties
+ * panel instead, so the closest equivalent is jumping straight to the
+ * matching section of it rather than making the user hunt for it. A binding
+ * that has not tagged its sections with {@link INSPECTOR_SECTION_ATTRIBUTE}
+ * still opens the properties tab (the command is never a no-op); it only
+ * misses the extra scroll, which degrades gracefully since
+ * {@link scrollInspectorSectionIntoView} is a no-op when the node is absent.
+ *
+ * @module render/context-menu-inspector-anchor
+ */
+import type { ContextMenuCommandId } from './context-menu-commands.js';
+/** One inspector section a context-menu command can jump to. */
+export type InspectorSectionAnchor = 'transform' | 'fill-stroke' | 'alt-text';
+/**
+ * The DOM attribute a binding puts on its section wrapper so this module can
+ * find it, e.g. `<div data-pptx-inspector-section="transform">`.
+ */
+export declare const INSPECTOR_SECTION_ATTRIBUTE = "data-pptx-inspector-section";
+/** The section a command should reveal, or `null` when it does not target one. */
+export declare function contextMenuInspectorAnchor(id: ContextMenuCommandId): InspectorSectionAnchor | null;
+/**
+ * Scroll the tagged section into view, when present. Call after the binding
+ * has switched to the properties tab and let it mount/render; a section that
+ * is not tagged (or not yet mounted) is silently skipped, so this is always
+ * safe to call.
+ */
+export declare function scrollInspectorSectionIntoView(doc: Document, anchor: InspectorSectionAnchor): void;
+//# sourceMappingURL=context-menu-inspector-anchor.d.ts.map

package/dist/pptx/render/context-menu-inspector-anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-inspector-anchor.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/context-menu-inspector-anchor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,gEAAgE;AAChE,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG,aAAa,GAAG,UAAU,CAAC;AAE9E;;;GAGG;AACH,eAAO,MAAM,2BAA2B,gCAAgC,CAAC;AAEzE,kFAAkF;AAClF,wBAAgB,0BAA0B,CACzC,EAAE,EAAE,oBAAoB,GACtB,sBAAsB,GAAG,IAAI,CAW/B;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAC7C,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,sBAAsB,GAC5B,IAAI,CAGN"}

package/dist/pptx/render/context-menu-target.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkJJP5HOLA_cjs = require('../chunk-JJP5HOLA.cjs');
+
+
+
+Object.defineProperty(exports, "INLINE_EDITOR_SELECTOR", {
+  enumerable: true,
+  get: function () { return chunkJJP5HOLA_cjs.INLINE_EDITOR_SELECTOR; }
+});
+Object.defineProperty(exports, "isInsideInlineEditor", {
+  enumerable: true,
+  get: function () { return chunkJJP5HOLA_cjs.isInsideInlineEditor; }
+});
+Object.defineProperty(exports, "resolveContextMenuElementId", {
+  enumerable: true,
+  get: function () { return chunkJJP5HOLA_cjs.resolveContextMenuElementId; }
+});

package/dist/pptx/render/context-menu-target.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Resolve which slide element a canvas right-click belongs to, including the
+ * case where the click landed inside an open inline text editor.
+ *
+ * Every binding resolves a context-menu target by walking up from the event
+ * target to the nearest `[data-element-id]` node. That walk fails the moment an
+ * inline text editor is open, because four of the five bindings mount the
+ * editor as a sibling overlay of the rendered elements rather than as a child
+ * of the element it edits: the editor has to paint above the selection chrome
+ * and escape the element's own clipping, so nothing above the caret carries an
+ * element id. The right-click then resolves to nothing and the menu never
+ * opens, for exactly the element the user had just clicked, which is the one
+ * they are most likely to want it on.
+ *
+ * The editor surface carries `data-inline-editor` in every binding, and the
+ * binding already knows which element is being edited, so the fallback is an
+ * exact lookup rather than a geometric guess.
+ *
+ * @module render/context-menu-target
+ */
+/** Attribute marking the inline text-editing surface in every binding. */
+export declare const INLINE_EDITOR_SELECTOR = "[data-inline-editor]";
+/**
+ * The slice of `Element` used here. Declaring it structurally keeps the helper
+ * unit-testable without a DOM and free of a `lib.dom` dependency.
+ */
+export interface ContextMenuTargetNode {
+    closest(selectors: string): ContextMenuTargetNode | null;
+}
+/** True when `target` sits inside (or is) an open inline text editor. */
+export declare function isInsideInlineEditor(target: ContextMenuTargetNode | EventTarget | null | undefined): boolean;
+/**
+ * The element the context menu should act on.
+ *
+ * `directId` is whatever the binding's own `[data-element-id]` hit-test found
+ * (null when it found nothing). Only when that fails does the inline-editor
+ * fallback apply, so a right-click on a *different* element while an editor is
+ * open still targets the element under the cursor.
+ */
+export declare function resolveContextMenuElementId(directId: string | null | undefined, target: ContextMenuTargetNode | EventTarget | null | undefined, inlineEditingElementId: string | null | undefined): string | null;
+//# sourceMappingURL=context-menu-target.d.ts.map

package/dist/pptx/render/context-menu-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-menu-target.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/context-menu-target.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,0EAA0E;AAC1E,eAAO,MAAM,sBAAsB,yBAAyB,CAAC;AAE7D;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAAC;CACzD;AAED,yEAAyE;AACzE,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,qBAAqB,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,GAC5D,OAAO,CAKT;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACnC,MAAM,EAAE,qBAAqB,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,EAC9D,sBAAsB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/C,MAAM,GAAG,IAAI,CAQf"}

package/dist/pptx/render/context-menu-target.mjs

@@ -0,0 +1 @@
+export { INLINE_EDITOR_SELECTOR, isInsideInlineEditor, resolveContextMenuElementId } from '../chunk-V4YMLIGL.mjs';

package/dist/pptx/render/crop-shape-clip.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The CSS `clip-path` value for a "Crop to Shape" picture, or `undefined`
+ * when the picture has no crop shape (`cropShape` unset or `'none'`).
+ *
+ * @param cropShape `element.cropShape` from an image/picture element.
+ * @param width     Element width in pixels.
+ * @param height    Element height in pixels.
+ */
+export declare function getCropShapeClipPath(cropShape: string | undefined, width: number, height: number): string | undefined;
+//# sourceMappingURL=crop-shape-clip.d.ts.map

package/dist/pptx/render/crop-shape-clip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crop-shape-clip.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/crop-shape-clip.ts"],"names":[],"mappings":"AA+BA;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAMpB"}

package/dist/pptx/render/cross-slide-audio.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cross-slide ("play across slides") audio registration.
+ *
+ * PowerPoint keeps background audio marked `playAcrossSlides` playing when
+ * the show advances, but a slide-local `<audio>` dies with its slide's DOM.
+ * {@link registerCrossSlideAudio} hands the track to the shared
+ * `media-persistent-audio` manager (a hidden document-level element that
+ * survives slide unmount) at the moment presentation-mode autoplay would
+ * have started the slide-local copy.
+ *
+ * Vue, Angular, Svelte and Vanilla each carried a byte-identical copy of this
+ * function; this is the one copy, sitting next to {@link mediaPlaybackAttributes}
+ * in `media-playback.ts` as the task that named it expected, split into its
+ * own sibling module purely to keep `media-playback.ts` under the file-size
+ * cap.
+ */
+import type { MediaPptxElement } from 'ooxml-core/pptx';
+/**
+ * Register a `playAcrossSlides` audio element with the shared persistent-audio
+ * manager, using the same resolved source, loop, volume and trim start the
+ * slide-local element would have used. Returns true when the persistent
+ * (document-level) element owns playback, in which case the slide-local media
+ * node must stay silent or the track doubles. Idempotent per element id
+ * (the manager no-ops a re-register), so re-entering the owning slide does not
+ * restart the track.
+ */
+export declare function registerCrossSlideAudio(element: MediaPptxElement, src: string | undefined): boolean;
+//# sourceMappingURL=cross-slide-audio.d.ts.map

package/dist/pptx/render/cross-slide-audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-slide-audio.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/cross-slide-audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAKxD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACtC,OAAO,EAAE,gBAAgB,EACzB,GAAG,EAAE,MAAM,GAAG,SAAS,GACrB,OAAO,CAcT"}

package/dist/pptx/render/css-escape.d.ts

@@ -0,0 +1,23 @@
+/**
+ * css-escape.ts: escape a value for use inside an attribute selector.
+ *
+ * Every binding locates a rendered element by id with
+ * `querySelector('[data-element-id="<id>"]')`. Browsers provide `CSS.escape`
+ * for that, but the bindings also run under test DOMs (happy-dom / jsdom)
+ * where it can be missing, and several copies of a hand-rolled fallback had
+ * drifted: one escaped only the quote and left a backslash able to eat the
+ * closing quote, another escaped nothing at all.
+ *
+ * @module render/css-escape
+ */
+/**
+ * Escape `value` so it can be spliced into a double-quoted CSS attribute
+ * selector. Uses `CSS.escape` when available; otherwise escapes the quote
+ * and the backslash in ONE pass, so an escape sequence produced for the
+ * quote cannot itself be re-escaped or a backslash in the input cannot
+ * neutralise the closing quote.
+ */
+export declare function escapeCssAttributeValue(value: string): string;
+/** `[data-element-id="<id>"]`, with the id escaped for the selector. */
+export declare function elementIdSelector(id: string): string;
+//# sourceMappingURL=css-escape.d.ts.map

package/dist/pptx/render/css-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-escape.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/css-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAK7D;AAED,wEAAwE;AACxE,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/pptx/render/css-top-level-split.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `css-top-level-split` - split a CSS value at separators that sit outside any
+ * parentheses. An `animation` shorthand's easing can be `cubic-bezier(0.2, 0,
+ * 0.4, 1)` or `linear(0, 0.1 25%, 1)`, whose nested commas and spaces a plain
+ * `split(',')` or `split(/\s+/)` would tear apart.
+ *
+ * @module render/css-top-level-split
+ */
+/** Split a comma-separated CSS list (e.g. `animation` tracks) at top level. */
+export declare function splitCssList(value: string): string[];
+/** Split one CSS list item into its whitespace-separated top-level tokens. */
+export declare function splitCssTokens(value: string): string[];
+//# sourceMappingURL=css-top-level-split.d.ts.map

package/dist/pptx/render/css-top-level-split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css-top-level-split.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/css-top-level-split.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqBH,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEpD;AAED,8EAA8E;AAC9E,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAEtD"}

package/dist/pptx/render/custom-fonts.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunkQWF3PGUX_cjs = require('../chunk-QWF3PGUX.cjs');
+
+
+
+Object.defineProperty(exports, "CUSTOM_FONT_ACCEPT", {
+  enumerable: true,
+  get: function () { return chunkQWF3PGUX_cjs.CUSTOM_FONT_ACCEPT; }
+});
+Object.defineProperty(exports, "CUSTOM_FONT_EXTENSIONS", {
+  enumerable: true,
+  get: function () { return chunkQWF3PGUX_cjs.CUSTOM_FONT_EXTENSIONS; }
+});
+Object.defineProperty(exports, "deriveCustomFontDescriptor", {
+  enumerable: true,
+  get: function () { return chunkQWF3PGUX_cjs.deriveCustomFontDescriptor; }
+});
+Object.defineProperty(exports, "registerCustomFont", {
+  enumerable: true,
+  get: function () { return chunkQWF3PGUX_cjs.registerCustomFont; }
+});

package/dist/pptx/render/custom-fonts.d.ts

@@ -0,0 +1,65 @@
+/**
+ * custom-fonts.ts: registering a user-supplied font file with the document.
+ *
+ * Backs the opt-in "Custom fonts" pane under File > Options. The viewer cannot
+ * render a family the browser has never heard of, so a deck authored with a
+ * corporate face falls back to a substitute; letting the user hand the font
+ * file over fixes that for the session.
+ *
+ * Nothing here is persisted: the registration lives in the page's font set and
+ * disappears on reload. That is deliberate, because keeping a licensed font
+ * binary in local storage is not ours to decide.
+ *
+ * @module render/custom-fonts
+ */
+/** Recognised font file extensions, in the order the file input advertises. */
+export declare const CUSTOM_FONT_EXTENSIONS: readonly string[];
+/** `accept` attribute for a font file input. */
+export declare const CUSTOM_FONT_ACCEPT: string;
+/** Style axes recovered from a font file's name. */
+export interface CustomFontDescriptor {
+    /** Family name, with the style suffix and separators stripped. */
+    family: string;
+    /** CSS `font-weight` for the face. */
+    weight: string;
+    /** CSS `font-style` for the face. */
+    style: string;
+}
+/**
+ * Derive a family name, weight and style from a font file's name.
+ *
+ * Foundries encode the face in the filename (`Inter-SemiBoldItalic.woff2`),
+ * and registering every file under its full filename would give the user a
+ * dropdown of near-duplicate families that never combine with the bold and
+ * italic buttons. Splitting the axes out means the four files of a family all
+ * register as one selectable name.
+ *
+ * @param fileName - The uploaded file's name, extension included.
+ * @returns The descriptor; `family` is empty when the name carried nothing but
+ *   style tokens, which callers should treat as unusable.
+ *
+ * @example
+ * ```ts
+ * deriveCustomFontDescriptor("Inter-SemiBoldItalic.woff2");
+ * // => { family: "Inter", weight: "600", style: "italic" }
+ * ```
+ */
+export declare function deriveCustomFontDescriptor(fileName: string): CustomFontDescriptor;
+/** Outcome of a registration attempt. */
+export interface CustomFontRegistration {
+    family: string;
+    descriptor: CustomFontDescriptor;
+}
+/**
+ * Load a font file and add it to the document's font set.
+ *
+ * @param file - The user-selected font file.
+ * @param target - Font set to add to; defaults to the ambient `document`.
+ *   Injectable so tests and non-browser hosts can supply their own.
+ * @returns The registered family, or `null` when the environment has no
+ *   `FontFace` support or the filename yields no usable family.
+ * @throws Whatever `FontFace.load` rejects with when the file is not a font,
+ *   so callers can surface a message instead of silently doing nothing.
+ */
+export declare function registerCustomFont(file: File, target?: FontFaceSet): Promise<CustomFontRegistration | null>;
+//# sourceMappingURL=custom-fonts.d.ts.map