pptx-angular-viewer 1.1.43 → 1.1.45

package/types/pptx-angular-viewer.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
-import { Signal, OnInit, OnChanges, SimpleChanges, InjectionToken, Provider } from '@angular/core';
+import { Signal, OnDestroy, OnInit, OnChanges, SimpleChanges, InjectionToken, Provider } from '@angular/core';
 import * as pptx_viewer_core from 'pptx-viewer-core';
-import { ShapeStyle, PptxTextWarpPreset, XmlObject, PptxElementAnimation, PptxSlide, PptxElement, TextStyle, PptxTransitionType, PptxEmbeddedFont, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, PptxComment, PptxTheme, PptxSlideMaster, PptxCoreProperties, ParsedSignature, PptxTableCell, PptxThemePreset, InkPptxElement, TextSegment, Model3DPptxElement, ZoomPptxElement, PptxSlideTransition, TablePptxElement, ChartPptxElement, SmartArtPptxElement, PptxSmartArtData, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartSeries, PptxChartType, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, PptxAnimationPreset, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, PptxAnimationSequence, SignatureStatus } from 'pptx-viewer-core';
+import { PptxElement, ShapeStyle, PptxTextWarpPreset, XmlObject, PptxElementAnimation, PptxSlide, TextSegment, TextStyle, PptxTransitionType, PptxEmbeddedFont, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, PptxComment, SmartArtLayout, PptxTheme, PptxSlideMaster, PptxCoreProperties, PptxCustomProperty, PptxHeaderFooter, ParsedSignature, PptxTableCell, PptxThemePreset, InkPptxElement, Model3DPptxElement, ZoomPptxElement, PptxSlideTransition, TablePptxElement, ChartPptxElement, SmartArtPptxElement, PptxSmartArtData, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartSeries, PptxChartType, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, PptxAnimationPreset, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, PptxAnimationSequence, SignatureStatus } from 'pptx-viewer-core';
 import * as pptx_angular_viewer from 'pptx-angular-viewer';
 import { Options } from 'html2canvas-pro';
 import { SafeHtml } from '@angular/platform-browser';
@@ -183,6 +183,52 @@ declare const DEFAULT_FILL_COLOR = "#3b82f6";
 /** Fallback shape stroke colour. */
 declare const DEFAULT_STROKE_COLOR = "#1f2937";
 
+/**
+ * Shape geometry helpers — Vue port of the React package's
+ * `viewer/utils/resolved-shape-clip-path.ts` cascade.
+ *
+ * All the heavy lifting (the ECMA-376 preset evaluator, the adjustment-aware
+ * table, the cubic-Bezier cloud paths, and the static preset clip-path table)
+ * already lives in `pptx-viewer-core` and is framework-agnostic, so — unlike
+ * the React package, which keeps a local polygon fallback — the Vue binding
+ * imports those entry points directly. No `pptx-viewer-shared` extraction is
+ * required here.
+ *
+ * The resolution priority mirrors React exactly:
+ *
+ *   1. **Adjustment-aware** — when `shapeAdjustments` exist, consult
+ *      {@link getAdjustmentAwareShapeClipPath} so `pie`, `arc`, `donut`,
+ *      `blockArc`, and wedge callouts respond to their adjustment values.
+ *   2. **Spec-correct preset evaluator** — {@link getShapeClipPathFromPreset}
+ *      produces a `path('…')` clip-path for any shape in the preset table.
+ *   3. **Cloud Bezier path** — {@link getCloudPathForRendering} for
+ *      `cloud` / `cloudCallout`.
+ *   4. **Static preset table** — {@link getShapeClipPath} as the final
+ *      fallback (core's comprehensive `PRESET_SHAPE_CLIP_PATHS`).
+ */
+
+/**
+ * Resolve the best available CSS `clip-path` value for a shape type at a given
+ * pixel size. Implements the priority cascade described in the module
+ * docstring. Returns `undefined` when the shape needs no clipping.
+ *
+ * @param shapeType   The OOXML preset geometry name (case-insensitive).
+ * @param width       Element width in pixels (must be > 0 for path output).
+ * @param height      Element height in pixels (must be > 0 for path output).
+ * @param adjustments Optional `shapeAdjustments` record from the element.
+ */
+declare function getResolvedShapeClipPathFor(shapeType: string | undefined, width: number, height: number, adjustments?: Record<string, number>): string | undefined;
+/**
+ * Element-level convenience wrapper. Pulls `shapeType`, `width`, `height`, and
+ * `shapeAdjustments` off a {@link PptxElement} and delegates to
+ * {@link getResolvedShapeClipPathFor}.
+ *
+ * @param element The PPTX element to resolve a clip-path for.
+ * @param width   Optional width override (pixels). Defaults to `element.width`.
+ * @param height  Optional height override (pixels). Defaults to `element.height`.
+ */
+declare function getResolvedShapeClipPath(element: PptxElement, width?: number, height?: number): string | undefined;
+
 /**
  * Framework-agnostic fill resolver for the Vue viewer.
  *
@@ -272,6 +318,14 @@ type CssStyleMap = Record<string, string | number>;
  * SVG `<textPath>` renderer applies.
  */
 
+/**
+ * Rendering-strategy category for a warp preset.
+ *  - `path`:     renders along an SVG `<textPath>` (arcs, waves, circles…)
+ *  - `envelope`: non-uniform vertical stretch (inflate/deflate/can)
+ *  - `simple`:   basic 2D transforms (slant, fade, cascade)
+ *  - `none`:     no warp (`textNoShape`, `textPlain`, unknown)
+ */
+type WarpCategory$1 = 'path' | 'envelope' | 'simple' | 'none';
 /**
  * Build the SVG path `d` attribute for a warp preset at a given line position.
  *
@@ -620,6 +674,9 @@ type AlignMode = AlignEdge;
 /** Axis along which to distribute spacing evenly (alias of {@link DistributeAxis}). */
 type DistributeMode = DistributeAxis;
 
+/** The eight resize handles, named by compass direction. */
+type ResizeHandleId = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+
 /**
  * Slide-background style resolution.
  *
@@ -850,6 +907,28 @@ declare class EditorHistory<T> {
     clear(): void;
 }
 
+/**
+ * ole-renderer-helpers.ts - framework-agnostic OLE type-resolution helpers.
+ *
+ * Resolves an embedded `OlePptxElement` to a narrowed application type and
+ * derives the per-type brand colour, human-readable label, accessible label,
+ * short badge text, display name, and placeholder box style. Shared by every
+ * binding's OLE renderer (React/Vue/Angular) so the branding stays identical.
+ *
+ * Pure: no framework or DOM dependencies. The JSX/template that paints icons and
+ * badges stays in each binding; only the type -> colour/label mapping lives here.
+ *
+ * @module shared/render/ole-renderer-helpers
+ */
+
+/**
+ * Resolved OLE application type, narrowed from the raw `OleObjectType` union.
+ *
+ * `package` and `unknown` from the core type both collapse to `'unknown'` here
+ * so that every branch is guaranteed to have a colour and label.
+ */
+type ResolvedOleType = 'excel' | 'word' | 'pdf' | 'visio' | 'mathtype' | 'unknown';
+
 /**
  * A single span guide line to draw.
  *
@@ -866,6 +945,85 @@ interface SnapGuide {
     end: number;
 }
 
+/**
+ * Render the n-th (1-based) marker for an OOXML auto-numbering scheme.
+ *
+ * Suffix conventions: `…Period` → `label.`, `…ParenR` → `label)`,
+ * `…ParenBoth` → `(label)`, `…Plain` → bare numeral. Unrecognised schemes
+ * fall back to `"<n>."`.
+ */
+declare function formatAutoNumber(autoNumType: string | undefined, n: number): string;
+
+/**
+ * Pure paragraph bullet / list-marker + indent helpers (framework-agnostic).
+ *
+ * Mirrors React's paragraph + bullet renderer (`text-paragraph-render.tsx` +
+ * `text-segment-render.tsx`): bullet-glyph selection, auto-numbering (see
+ * {@link ./bullet-autonum}), bullet font/size/colour, and the marginLeft /
+ * hanging-indent layout. Shared by the React/Vue/Angular bindings.
+ */
+
+/**
+ * Resolved bullet marker for a single paragraph. `marker` is the text to
+ * prepend (e.g. "•", "1.", "a)"); `isNumbered` is true for auto-numbered lists.
+ * `color`/`fontFamily`/`sizePts`/`sizePercent` carry optional explicit overrides
+ * (the latter as a percentage of the run font size).
+ */
+interface ParagraphBulletResult {
+    marker: string;
+    isNumbered: boolean;
+    color?: string;
+    fontFamily?: string;
+    sizePts?: number;
+    sizePercent?: number;
+}
+/**
+ * Resolve the bullet marker for the first segment of a paragraph.
+ *
+ * Returns `undefined` when the segment is absent or carries no `bulletInfo`,
+ * when `bulletInfo.none`/`listType:'none'` suppresses it, or when neither a
+ * character bullet nor an auto-number type is present. For auto-numbered
+ * bullets the 1-based sequence index is `autoNumStartAt` (default 1) plus the
+ * 0-based `paragraphIndex`.
+ */
+declare function resolveParagraphBullet(firstSegment: TextSegment | undefined): ParagraphBulletResult | undefined;
+/**
+ * Return the left-indent in pixels for the given 0-based list nesting level
+ * (OOXML `a:p/@lvl`). `undefined`/negative is treated as level 0. Used as a
+ * fallback when the element carries no explicit per-paragraph `marginLeft`.
+ */
+declare function bulletIndentPx(level: number | undefined): number;
+
+/**
+ * Text-field placeholder substitution, shared by every binding's text
+ * renderer.
+ *
+ * Pure string logic: resolves OOXML field runs (slide number, date/time,
+ * header/footer, document properties, slide title) into their display text.
+ * Extracted from the React `viewer/utils/text-field-substitution` module so
+ * every binding substitutes identically.
+ */
+/** Context for substituting field placeholders (slide number, date/time, header/footer, etc.). */
+interface FieldSubstitutionContext {
+    slideNumber?: number;
+    dateTimeText?: string;
+    /** OOXML date-format pattern from header/footer settings (e.g. "M/d/yyyy"). */
+    dateFormat?: string;
+    /** Footer text from PptxHeaderFooter settings. */
+    footerText?: string;
+    /** Header text from PptxHeaderFooter settings. */
+    headerText?: string;
+    /** Custom document properties for `docproperty` field substitution (keyed by property name). */
+    customProperties?: ReadonlyArray<{
+        name: string;
+        value: string;
+    }>;
+    /** Locale string for date/time formatting (e.g. "en-US"). Falls back to browser default. */
+    locale?: string;
+    /** Title text extracted from the first title placeholder on the slide. */
+    slideTitle?: string;
+}
+
 /**
  * Pure (framework-agnostic) helpers for the advanced text panel.
  *
@@ -1326,6 +1484,37 @@ interface SmartArtLayoutResult {
     family: LayoutFamily;
 }
 
+/**
+ * smartart-accessibility.ts: framework-agnostic accessibility metadata for the
+ * SmartArt renderer, shared across the React, Vue, and Angular bindings.
+ *
+ * The generated SmartArt SVG is otherwise opaque to assistive technology. These
+ * pure helpers derive a screen-reader description of the whole diagram, a label
+ * for each node, and a small `SmartArtA11y` view-model that a binding maps onto
+ * `role="img"` + `aria-label` on the container and a `<title>` / `aria-label`
+ * per node. No DOM, no framework imports.
+ */
+
+/** Accessibility view-model for one SmartArt node. */
+interface SmartArtNodeA11y {
+    /** Stable node id (for keying). */
+    id: string;
+    /** `aria-label` / `<title>` text for the node. */
+    label: string;
+}
+/**
+ * Accessibility view-model for a whole SmartArt diagram. A binding maps this
+ * onto `role="img"` + `aria-label` on the container and a per-node label.
+ */
+interface SmartArtA11y {
+    /** ARIA role for the container element. Always `"img"`. */
+    role: 'img';
+    /** Container `aria-label` (the full diagram description). */
+    label: string;
+    /** Per-node labels in flattened, depth-first order. */
+    nodes: SmartArtNodeA11y[];
+}
+
 /**
  * smartart-drawing.ts: Drawing-shape view-model helpers for the SmartArt
  * renderer, shared across the React, Vue, and Angular bindings.
@@ -1560,6 +1749,70 @@ interface CustomShow {
     slideIds: readonly string[];
 }
 
+/**
+ * broadcast-helpers.ts: framework-agnostic helpers for the Broadcast dialog,
+ * shared by the React, Vue and Angular bindings.
+ *
+ * A broadcast is a one-way collaboration session: the presenter drives slide
+ * navigation and viewers follow along via a shareable link. These helpers
+ * cover the testable, framework-agnostic parts of each binding's broadcast
+ * dialog: room-id generation, form validation, and the viewer-link builder.
+ *
+ * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
+ * no regex named-capture-groups (Angular vendors this source under its
+ * ng-packagr lib target). `Math.random` is read inside the generator at call
+ * time, never at module eval.
+ */
+/** Default y-websocket server URL used when no default is supplied. */
+declare const DEFAULT_BROADCAST_SERVER_URL = "ws://localhost:1234";
+/** Optional seed values for the broadcast start form. */
+interface BroadcastDefaults {
+    roomId?: string;
+    serverUrl?: string;
+}
+/** The configuration emitted when a broadcast starts. */
+interface BroadcastConfig {
+    roomId: string;
+    serverUrl: string;
+}
+/** Generate a fresh, broadcast-scoped room id (`broadcast-<suffix>`). */
+declare function generateBroadcastRoomId(): string;
+/**
+ * Seed the start form from the (optional) defaults, generating a fresh room id
+ * when none is supplied and falling back to the default server URL.
+ */
+declare function seedBroadcastFields(defaults?: BroadcastDefaults): BroadcastConfig;
+/** Whether both required fields are non-blank (after trimming). */
+declare function canStartBroadcast(fields: BroadcastConfig): boolean;
+/**
+ * Assemble a {@link BroadcastConfig} from the (trimmed) form fields, or `null`
+ * when incomplete.
+ */
+declare function buildBroadcastConfig(fields: BroadcastConfig): BroadcastConfig | null;
+/**
+ * Build the shareable viewer follow-link for a broadcast. Returns just the
+ * room id when no `origin`/`pathname` are available (non-browser environments).
+ */
+declare function buildBroadcastViewerUrl(roomId: string, serverUrl: string, location?: {
+    origin: string;
+    pathname: string;
+}): string;
+/** Whether the runtime exposes a usable async clipboard write API. */
+declare function canUseClipboard(nav: Navigator | undefined): boolean;
+
+/**
+ * presenter-view.ts: pure presenter-view helpers shared across bindings.
+ *
+ * Time formatting, notes font-size clamping, and rich-text notes -> render-spec
+ * conversion. DOM-free; each binding renders the returned `NotesSpan[]` spec
+ * into its own `<span>`/`<br>` nodes.
+ */
+
+/** Clamp a notes font size to the allowed range. */
+declare function clampNotesFontSize(size: number): number;
+/** Format a Date as a locale time string (HH:MM:SS). */
+declare function formatTime(date: Date): string;
+
 /**
  * Pure helpers for the hyperlink-edit dialog, shared by every binding.
  *
@@ -2083,55 +2336,6 @@ declare class AccessibilityService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<AccessibilityService>;
 }
 
-/**
- * broadcast-helpers.ts: Pure (no Angular) helpers for the Broadcast dialog.
- *
- * A broadcast is a one-way collaboration session: the presenter drives slide
- * navigation and viewers follow along via a shareable link. These helpers
- * cover the testable, framework-agnostic parts of the Vue `BroadcastDialog.vue`
- * and React `BroadcastDialog.tsx`: room-id generation, form validation, and
- * the viewer-link builder.
- *
- * No `any`; all regexes use the `/u` flag; no `String.prototype.replaceAll`,
- * no regex named-capture-groups (ng-packagr lib-target constraints).
- */
-/** Default y-websocket server URL used when no default is supplied. */
-declare const DEFAULT_BROADCAST_SERVER_URL = "ws://localhost:1234";
-/** Optional seed values for the broadcast start form. */
-interface BroadcastDefaults {
-    roomId?: string;
-    serverUrl?: string;
-}
-/** The configuration emitted when a broadcast starts. */
-interface BroadcastConfig {
-    roomId: string;
-    serverUrl: string;
-}
-/** Generate a fresh, broadcast-scoped room id (`broadcast-<suffix>`). */
-declare function generateBroadcastRoomId(): string;
-/**
- * Seed the start form from the (optional) defaults, generating a fresh room id
- * when none is supplied and falling back to the default server URL.
- */
-declare function seedBroadcastFields(defaults?: BroadcastDefaults): BroadcastConfig;
-/** Whether both required fields are non-blank (after trimming). */
-declare function canStartBroadcast(fields: BroadcastConfig): boolean;
-/**
- * Assemble a {@link BroadcastConfig} from the (trimmed) form fields, or `null`
- * when incomplete.
- */
-declare function buildBroadcastConfig(fields: BroadcastConfig): BroadcastConfig | null;
-/**
- * Build the shareable viewer follow-link for a broadcast. Returns just the
- * room id when no `origin`/`pathname` are available (non-browser environments).
- */
-declare function buildBroadcastViewerUrl(roomId: string, serverUrl: string, location?: {
-    origin: string;
-    pathname: string;
-}): string;
-/** Whether the runtime exposes a usable async clipboard write API. */
-declare function canUseClipboard(nav: Navigator | undefined): boolean;
-
 /**
  * Thin re-export shim → vendored `pptx-viewer-shared`
  * (`render/collaboration-presence`).
@@ -2148,8 +2352,10 @@ declare function canUseClipboard(nav: Navigator | undefined): boolean;
  *    truncation, which differs from shared's three-dot (`...`) variant that the
  *    React binding expects. Kept local so the rendered label and the colocated
  *    test are unchanged.
- *  - `mapAwarenessCursors` is the foundational bare-`{ cursor, user }` mapping
- *    that has no shared equivalent yet.
+ *
+ * `mapAwarenessCursors` (the foundational bare-`{ cursor, user }` mapping) now
+ * lives in shared and is re-exported here so existing Angular imports are
+ * unchanged.
  */
 
 /**
@@ -2158,11 +2364,41 @@ declare function canUseClipboard(nav: Navigator | undefined): boolean;
  */
 declare function formatCursorLabel(userName: string, maxChars?: number): string;
 
+/**
+ * template-mode.ts: separate-state model + per-element interactivity gate for the
+ * editTemplateMode feature.
+ *
+ * Inherited master/layout (template) elements are merged BEHIND the slide's own
+ * elements by the core loader and carry ids prefixed `layout-` / `master-`. At
+ * load time we PARTITION them out of `slide.elements` into a dedicated
+ * `templateElementsBySlideId` store ({@link partitionSlides}); the editor then
+ * holds a template-free deck and renders the template store as a separate layer
+ * behind the slide. They should only be selectable/draggable/deletable when the
+ * user has explicitly turned on "edit template" mode; otherwise they are inert so
+ * normal slide editing never disturbs the shared template. Every save merges the
+ * two stores back together ({@link buildSaveSlides}).
+ *
+ * Pure (no Angular), so it stays unit-testable in isolation and the components
+ * remain thin.
+ *
+ * @module viewer/template-mode
+ */
+
+/** Map of slide id -> the inherited template (master/layout) elements for it. */
+type TemplateElementsBySlideId = Record<string, PptxElement[]>;
+
 interface ConnectOptions {
     onRemoteSlides?: (slides: PptxSlide[]) => void;
     canvasWidth?: number;
     canvasHeight?: number;
     getSourceBytes?: () => Uint8Array | null;
+    /**
+     * Returns the editor's separated template (master/layout) elements keyed by
+     * slide id, so the elected-writer write-back can merge them back into the
+     * broadcast (template-free) slides before serializing. Without this, template
+     * edits would be dropped from the persisted deck.
+     */
+    getTemplateElements?: () => TemplateElementsBySlideId;
 }
 declare class CollaborationService {
     readonly connected: _angular_core.WritableSignal<boolean>;
@@ -2183,6 +2419,7 @@ declare class CollaborationService {
     private canvasWidth;
     private canvasHeight;
     private getSourceBytes;
+    private getTemplateElements;
     private userName;
     private userColor;
     private userAvatar;
@@ -2210,14 +2447,37 @@ declare class EditorStateService {
     readonly selectedIds: _angular_core.WritableSignal<readonly string[]>;
     /** Whether the deck has unsaved edits. */
     readonly dirty: _angular_core.WritableSignal<boolean>;
+    /**
+     * When true, inherited master/layout (template) elements become interactive:
+     * selectable, draggable, deletable, and editable. When false (default) they
+     * render but are inert, so normal slide editing never disturbs the template.
+     *
+     * Note: a template element is shared by every slide inheriting the same
+     * layout/master, so editing one updates the shared part for all of them.
+     */
+    readonly editTemplateMode: _angular_core.WritableSignal<boolean>;
+    /**
+     * Inherited master/layout (template) elements, separated out of every slide's
+     * own elements at load time and keyed by slide id. They render as a dedicated
+     * layer BEHIND the slide and are only mutated while {@link editTemplateMode} is
+     * on; {@link buildSaveSlides} re-merges them for serialization.
+     */
+    readonly templateElementsBySlideId: _angular_core.WritableSignal<TemplateElementsBySlideId>;
     readonly canUndo: _angular_core.WritableSignal<boolean>;
     readonly canRedo: _angular_core.WritableSignal<boolean>;
     readonly undoLabel: _angular_core.WritableSignal<string | undefined>;
     readonly redoLabel: _angular_core.WritableSignal<string | undefined>;
     readonly hasSelection: _angular_core.Signal<boolean>;
-    /** Replace the editable deck (clones the source); resets selection + history. */
+    /**
+     * Replace the editable deck (clones the source); resets selection + history.
+     *
+     * Inherited template (master/layout) elements are PARTITIONED out of each
+     * slide here: the editable deck keeps only its own elements while the template
+     * elements move into {@link templateElementsBySlideId}, rendered as a separate
+     * layer and re-merged on save.
+     */
     setSlides(slides: readonly PptxSlide[]): void;
-    /** Current editable slides as a fresh (cloned) array. */
+    /** Current editable (template-free) slides as a fresh (cloned) array. */
     snapshot(): readonly PptxSlide[];
     /**
      * Replace the whole deck with pre-computed slides (e.g. a find/replace
@@ -2225,6 +2485,16 @@ declare class EditorStateService {
      * preserves history and selection.
      */
     applyReplacement(newSlides: readonly PptxSlide[], label?: string): void;
+    /** Capture the current deck + template store as one undo/redo snapshot. */
+    private captureSnapshot;
+    /** Restore both the deck and the template store from a snapshot. */
+    private restoreSnapshot;
+    /** The template (master/layout) elements separated out of a slide, by id. */
+    private templatesForSlide;
+    /** Replace a slide's template-element list (drops the entry when empty). */
+    private writeTemplatesForSlide;
+    /** Toggle whether inherited template (master/layout) elements are editable. */
+    setEditTemplateMode(mode: boolean): void;
     select(ids: readonly string[]): void;
     toggleSelect(id: string, additive: boolean): void;
     clearSelection(): void;
@@ -2247,7 +2517,8 @@ declare class EditorStateService {
     /**
      * Apply a live transform during a gesture WITHOUT recording history (the
      * gesture's snapshot was taken in {@link beginTransform}). Accepts any subset
-     * of x/y/width/height.
+     * of x/y/width/height. Routes by id: template (master/layout) elements mutate
+     * the template store, normal elements mutate the slide.
      */
     applyTransform(slideIndex: number, id: string, box: {
         x?: number;
@@ -2366,23 +2637,23 @@ declare class FindReplaceBarComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FindReplaceBarComponent, "pptx-find-replace-bar", never, { "matchCount": { "alias": "matchCount"; "required": false; "isSignal": true; }; "matchIndex": { "alias": "matchIndex"; "required": false; "isSignal": true; }; }, { "find": "find"; "navigate": "navigate"; "replaceOne": "replaceOne"; "replaceAll": "replaceAll"; "close": "close"; }, never, never, true, never>;
 }
 
+/** Payload emitted when the user confirms an insert. */
+interface SmartArtInsertEvent {
+    layout: SmartArtLayout;
+    items: string[];
+}
+
 /**
- * Decide whether the current environment should use the mobile layout:
- * - a narrow viewport (`width < MOBILE_BREAKPOINT`), OR
- * - a short *touch* viewport below the tablet width: a landscape phone, which
- *   is wide enough to look like a tablet but far too short for the desktop
- *   ribbon + side panels.
- *
- * This mirrors React's `isMobileViewport(width, height, isTouch)` so the three
- * frameworks switch chrome at the same breakpoints (and the shared mobile e2e
- * specs pass identically). A tall touch tablet (e.g. 820×1180) is NOT mobile.
+ * Decide whether the current environment should use the mobile layout.
+ * Delegates to the shared `isMobileViewport`; kept under this name for the
+ * existing Angular barrel + test surface.
  *
  * @pure: no side effects, fully testable without a DOM.
  */
 declare function computeIsMobile(width: number, height: number, isTouch: boolean): boolean;
 /**
  * Decide whether the current environment is "tablet" (desktop chrome, but in
- * the 768–1023px width band). A short landscape-phone touch viewport is mobile,
+ * the 768-1023px width band). A short landscape-phone touch viewport is mobile,
  * not tablet (handled by {@link computeIsMobile}).
  *
  * @pure
@@ -2479,6 +2750,10 @@ declare class LoadContentService {
     readonly embeddedFonts: _angular_core.WritableSignal<PptxEmbeddedFont[]>;
     /** Core document properties from `docProps/core.xml`. */
     readonly coreProperties: _angular_core.WritableSignal<PptxCoreProperties | undefined>;
+    /** Custom document properties (used for `docproperty` field substitution). */
+    readonly customProperties: _angular_core.WritableSignal<PptxCustomProperty[]>;
+    /** Header/footer settings (footer/header/date-time text + format) for field substitution. */
+    readonly headerFooter: _angular_core.WritableSignal<PptxHeaderFooter | undefined>;
     /** Whether the presentation contains digital signatures. */
     /** Parsed digital signatures (empty when unsigned or parsing fails). */
     readonly signatures: _angular_core.WritableSignal<ParsedSignature[]>;
@@ -3019,9 +3294,18 @@ declare class PowerPointViewerComponent {
     /** Slides to display: the editable deck when `canEdit`, else the loaded deck. */
     protected readonly displaySlides: _angular_core.Signal<readonly PptxSlide[]>;
     protected readonly slideCount: _angular_core.Signal<number>;
-    /** Mutable copy of the display deck for inputs that require a non-readonly array. */
+    /**
+     * The deck with the separated template (master/layout) elements merged back
+     * into each slide. The editable {@link displaySlides} is template-free; any
+     * consumer that needs the COMPLETE slide (export, print, slide thumbnails,
+     * accessibility) renders this instead so template elements are not lost.
+     */
+    protected readonly mergedSlides: _angular_core.Signal<readonly PptxSlide[]>;
+    /** Mutable copy of the merged display deck for inputs that require a non-readonly array. */
     protected readonly displaySlidesMut: _angular_core.Signal<PptxSlide[]>;
     protected readonly activeSlide: _angular_core.Signal<PptxSlide>;
+    /** Inherited template (master/layout) elements for the active slide, when editing. */
+    protected readonly activeTemplateElements: _angular_core.Signal<readonly PptxElement[]>;
     protected readonly rootStyle: _angular_core.Signal<Record<string, string>>;
     protected readonly zoom: _angular_core.WritableSignal<number>;
     protected readonly zoomPercent: _angular_core.Signal<number>;
@@ -3119,6 +3403,8 @@ declare class PowerPointViewerComponent {
     protected readonly showThemeGallery: _angular_core.WritableSignal<boolean>;
     /** Whether the custom-shows dialog is open. */
     protected readonly showCustomShows: _angular_core.WritableSignal<boolean>;
+    /** Whether the Insert SmartArt gallery dialog is open. */
+    protected readonly showSmartArtInsert: _angular_core.WritableSignal<boolean>;
     /** The list of user-defined custom shows for this session. */
     protected readonly customShows: _angular_core.WritableSignal<readonly CustomShow[]>;
     /** The id of the currently active custom show, or null. */
@@ -3335,6 +3621,12 @@ declare class PowerPointViewerComponent {
     onSelectionPaneBringForward(id: string): void;
     onSelectionPaneSendBackward(id: string): void;
     onToggleElementHidden(id: string): void;
+    /**
+     * Insert a new SmartArt element built from the dialog's chosen preset + item
+     * texts. The element id is left empty so `EditorStateService.addElement`
+     * assigns one; the insert is a single undo/redo history entry.
+     */
+    protected onInsertSmartArt(event: SmartArtInsertEvent): void;
     onCustomShowCreate(show: {
         name: string;
         slideIds: string[];
@@ -3397,14 +3689,8 @@ declare class PowerPointViewerComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerPointViewerComponent, "pptx-viewer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "collaboration": { "alias": "collaboration"; "required": false; "isSignal": true; }; "onOpenFile": { "alias": "onOpenFile"; "required": false; "isSignal": true; }; "smartArt3D": { "alias": "smartArt3D"; "required": false; "isSignal": true; }; }, { "activeSlideChange": "activeSlideChange"; "dirtyChange": "dirtyChange"; "contentChange": "contentChange"; "propertiesChange": "propertiesChange"; }, never, never, true, never>;
 }
 
-/**
- * Pure geometry for interactive element drag/resize.
- *
- * Stage-space deltas in, a new bounding box out: no DOM, no framework, so the
- * SlideCanvas pointer wiring stays thin and the maths is unit-testable.
- */
 /** The eight resize-handle positions around a selection box. */
-type ResizeHandle = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
+type ResizeHandle = ResizeHandleId;
 /** An axis-aligned box in stage (slide) coordinates. */
 interface Box {
     x: number;
@@ -3501,6 +3787,19 @@ declare class SlideCanvasComponent {
     readonly selectedIds: _angular_core.InputSignal<readonly string[]>;
     /** Id of the element currently being text-edited inline (or null). */
     readonly editingId: _angular_core.InputSignal<string | null>;
+    /**
+     * When true, inherited master/layout (template) elements become interactive
+     * (selectable/draggable/deletable/editable) and show the editable affordance.
+     * When false (default) template elements still render but are inert, so normal
+     * slide editing never disturbs the shared template.
+     */
+    readonly editTemplateMode: _angular_core.InputSignal<boolean>;
+    /**
+     * Inherited master/layout (template) elements for this slide, separated out of
+     * `slide.elements` by the editor. Rendered as a dedicated layer BEHIND the
+     * slide's own elements; interactive only while {@link editTemplateMode} is on.
+     */
+    readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
     /** Active draw tool. When not 'select', pointer gestures draw ink strokes. */
     readonly drawTool: _angular_core.InputSignal<"pen" | "highlighter" | "eraser" | "select" | "freeform">;
     /** Active ink stroke colour (CSS colour string). */
@@ -3610,6 +3909,20 @@ declare class SlideCanvasComponent {
      */
     private recomputeFit;
     readonly elements: _angular_core.Signal<PptxElement[]>;
+    /**
+     * Template elements + the slide's own elements, template first (behind). Used
+     * for every id-based lookup (hit-testing, selection boxes, inline-edit box) so
+     * a selected/dragged template element resolves the same as a normal one.
+     */
+    readonly allElements: _angular_core.Signal<readonly PptxElement[]>;
+    /**
+     * OOXML field-substitution context for the slide being rendered. Built from
+     * the viewer-scoped {@link FieldContextService} (header/footer + custom doc
+     * properties) folded with this slide's number + title. `optional` injection
+     * means canvases used outside the viewer subtree get no substitution.
+     */
+    private readonly fieldContextSvc;
+    readonly fieldContext: _angular_core.Signal<FieldSubstitutionContext | undefined>;
     /**
      * Obstacle rects (absolute slide coords) for connector A* routing: every
      * non-connector element with a positive footprint. Bent connectors detour
@@ -3635,7 +3948,7 @@ declare class SlideCanvasComponent {
     }) | null>;
     /** Resize-handle render boxes (stage coords) for the single selection. */
     readonly handleBoxes: _angular_core.Signal<{
-        handle: ResizeHandle;
+        handle: ResizeHandleId;
         left: number;
         top: number;
         size: number;
@@ -3658,7 +3971,24 @@ declare class SlideCanvasComponent {
         top: number;
         size: number;
     } | null>;
+    /**
+     * Resolve the id of the interactive element under a pointer target, or null.
+     * An element host carries `data-element-id`, but template (master/layout)
+     * elements are only interactive while editTemplateMode is on; when off they
+     * are reported as null so the canvas treats them as background (no
+     * select/drag/context-menu/inline-edit).
+     */
+    private interactiveElementIdAt;
     onStagePointerDown(event: PointerEvent): void;
+    /**
+     * Press on the scrollable viewport background (the empty workspace around a
+     * centered slide). The slide stage owns its own empty-press deselect, but
+     * clicks outside the slide borders land on the viewport container instead, so
+     * without this they would leave the current selection intact. Only direct hits
+     * on the viewport itself deselect; bubbled child events (wrapper, stage,
+     * rulers, handles, content) keep their existing behavior.
+     */
+    onViewportPointerDown(event: PointerEvent): void;
     /** Box + current plain text for the element under inline edit, or null. */
     readonly editingBox: _angular_core.Signal<{
         id: string;
@@ -3705,7 +4035,22 @@ declare class SlideCanvasComponent {
     readonly vRulerTicks: _angular_core.Signal<readonly RulerTick[]>;
     readonly stageStyle: _angular_core.Signal<StyleMap>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideCanvasComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideCanvasComponent, "pptx-slide-canvas", never, { "slide": { "alias": "slide"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showRulers": { "alias": "showRulers"; "required": false; "isSignal": true; }; "showGuides": { "alias": "showGuides"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "snapToGuides": { "alias": "snapToGuides"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "editingId": { "alias": "editingId"; "required": false; "isSignal": true; }; "drawTool": { "alias": "drawTool"; "required": false; "isSignal": true; }; "drawColor": { "alias": "drawColor"; "required": false; "isSignal": true; }; "drawWidth": { "alias": "drawWidth"; "required": false; "isSignal": true; }; }, { "elementSelect": "elementSelect"; "backgroundClick": "backgroundClick"; "transformStart": "transformStart"; "transformUpdate": "transformUpdate"; "contextMenu": "contextMenu"; "textEditStart": "textEditStart"; "textCommit": "textCommit"; "textCancel": "textCancel"; "rotateUpdate": "rotateUpdate"; "marqueeSelect": "marqueeSelect"; "inkStrokeComplete": "inkStrokeComplete"; "eraserHit": "eraserHit"; "cellCommit": "cellCommit"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideCanvasComponent, "pptx-slide-canvas", never, { "slide": { "alias": "slide"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "showGrid": { "alias": "showGrid"; "required": false; "isSignal": true; }; "showRulers": { "alias": "showRulers"; "required": false; "isSignal": true; }; "showGuides": { "alias": "showGuides"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "snapToGuides": { "alias": "snapToGuides"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "editingId": { "alias": "editingId"; "required": false; "isSignal": true; }; "editTemplateMode": { "alias": "editTemplateMode"; "required": false; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "drawTool": { "alias": "drawTool"; "required": false; "isSignal": true; }; "drawColor": { "alias": "drawColor"; "required": false; "isSignal": true; }; "drawWidth": { "alias": "drawWidth"; "required": false; "isSignal": true; }; }, { "elementSelect": "elementSelect"; "backgroundClick": "backgroundClick"; "transformStart": "transformStart"; "transformUpdate": "transformUpdate"; "contextMenu": "contextMenu"; "textEditStart": "textEditStart"; "textCommit": "textCommit"; "textCancel": "textCancel"; "rotateUpdate": "rotateUpdate"; "marqueeSelect": "marqueeSelect"; "inkStrokeComplete": "inkStrokeComplete"; "eraserHit": "eraserHit"; "cellCommit": "cellCommit"; }, never, never, true, never>;
+}
+
+/**
+ * Pure (Angular-free) helpers for the `<a:clrChange>` colour-change image
+ * effect. Kept out of the component so they can be unit-tested without TestBed
+ * or a DOM, mirroring `model3d-renderer-helpers.ts`.
+ */
+/** Parsed `<a:clrChange>` parameters needed to drive the chroma-key. */
+interface ClrChangeParams {
+    clrFrom: string;
+    clrTo: string;
+    /** Whether the target colour becomes fully transparent (alpha = 0). */
+    clrToTransparent: boolean;
+    /** Match tolerance percentage (0-100). */
+    tolerance: number;
 }
 
 /**
@@ -3735,14 +4080,16 @@ declare class SlideCanvasComponent {
  */
 
 /** The four rendering strategy families. */
-type WarpCategory = 'path' | 'envelope' | 'simple' | 'none';
+type WarpCategory = WarpCategory$1;
 /**
  * Classify a warp preset into a rendering strategy category.
  *
  * Returns `'none'` for unknown or empty presets so callers can safely
- * skip rendering without an explicit allowlist check.
+ * skip rendering without an explicit allowlist check. Thin alias for the
+ * shared `classifyTextWarp` helper.
  */
-declare function getWarpCategory(preset: string | undefined): WarpCategory;
+declare const getWarpCategory: (preset: string | undefined) => WarpCategory;
+
 /**
  * A single pre-computed SVG path line for one text paragraph.
  *
@@ -3810,10 +4157,14 @@ type TextWarpDef = TextWarpPathDef | TextWarpCssDef;
  *
  * @param element  Any `PptxElement`.  Elements without text properties always
  *                 return `undefined`.
+ * @param fieldContext  Optional OOXML field-substitution context. When given,
+ *                 field runs (slide number, date/time, footer, ...) in the warp
+ *                 paragraphs are resolved to their display text, mirroring
+ *                 React's warp-text-renderer.
  * @returns  A `TextWarpDef` with `strategy: 'path'` for SVG textPath warps, or
  *           `strategy: 'css'` for CSS-transform approximations.
  */
-declare function getTextWarp(element: PptxElement): TextWarpDef | undefined;
+declare function getTextWarp(element: PptxElement, fieldContext?: FieldSubstitutionContext): TextWarpDef | undefined;
 
 interface TextRun {
     text: string;
@@ -3884,6 +4235,20 @@ declare class ElementRendererComponent {
     readonly interactive: _angular_core.InputSignal<boolean>;
     /** Whether inline editing (e.g. table-cell text input) is enabled. */
     readonly editable: _angular_core.InputSignal<boolean>;
+    /**
+     * OOXML field-substitution context (slide number, date/time, header/footer,
+     * slide title, custom doc properties). Built once per slide by the slide
+     * canvas and threaded down (including to recursive group children) so field
+     * runs resolve to display text, mirroring React's `fieldContext`.
+     */
+    readonly fieldContext: _angular_core.InputSignal<FieldSubstitutionContext | undefined>;
+    /**
+     * When true, inherited master/layout (template) elements get a visual
+     * affordance (amber outline ring + slightly reduced opacity) signalling that
+     * they are now directly editable. Has no effect on normal slide elements, and
+     * no effect at all when false, so default rendering is untouched.
+     */
+    readonly editTemplateMode: _angular_core.InputSignal<boolean>;
     /** Emitted when a table cell's text edit is committed. */
     readonly cellCommit: _angular_core.OutputEmitterRef<{
         id: string;
@@ -3891,15 +4256,34 @@ declare class ElementRendererComponent {
     }>;
     /** Duotone SVG `<filter>` descriptor for this element, if any. */
     readonly duotoneFilter: _angular_core.Signal<pptx_angular_viewer.DuotoneFilterDef | undefined>;
+    /**
+     * Outline ring + slight transparency applied to inherited template
+     * (master/layout) elements while editTemplateMode is on. Empty otherwise, so
+     * normal rendering is never altered.
+     */
+    readonly templateAffordanceStyle: _angular_core.Signal<StyleMap>;
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly shapeContainerStyle: _angular_core.Signal<StyleMap>;
     readonly textStyle: _angular_core.Signal<StyleMap>;
     readonly imageSrc: _angular_core.Signal<string | undefined>;
+    /**
+     * Parsed `<a:clrChange>` colour-change effect for this element, or
+     * `undefined` when it carries none. When present the image / media branch
+     * renders via {@link ColorChangedImageComponent} (offscreen-canvas chroma
+     * key) instead of a plain `<img>`.
+     */
+    readonly clrChangeParams: _angular_core.Signal<ClrChangeParams | undefined>;
     /** Text-warp (WordArt) descriptor for the element, if any. */
     readonly textWarp: _angular_core.Signal<pptx_angular_viewer.TextWarpDef | undefined>;
     /** Only the SVG-textPath warp variant (for the `<svg>` overlay branch). */
     readonly pathWarp: _angular_core.Signal<TextWarpPathDef | undefined>;
-    /** Text block style, folding in a CSS-transform warp when present. */
+    /** Text block 3D scene style (a:bodyPr/a:scene3d), mirroring React's ElementBody. */
+    readonly scene3dStyle: _angular_core.Signal<StyleMap | undefined>;
+    /**
+     * Text block style, folding in a CSS-transform warp and the 3D scene
+     * (perspective + rotation) when present. The warp transform and the scene
+     * transform are composed rather than clobbering each other.
+     */
     readonly warpedTextStyle: _angular_core.Signal<StyleMap>;
     readonly children: _angular_core.Signal<PptxElement[]>;
     readonly isShapeLike: _angular_core.Signal<boolean>;
@@ -3907,9 +4291,8 @@ declare class ElementRendererComponent {
     readonly paragraphs: _angular_core.Signal<Paragraph[]>;
     readonly hasText: _angular_core.Signal<boolean>;
     readonly placeholderLabel: _angular_core.Signal<string>;
-    private segmentStyle;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementRendererComponent, "pptx-element-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "obstacles": { "alias": "obstacles"; "required": false; "isSignal": true; }; "canvasWidth": { "alias": "canvasWidth"; "required": false; "isSignal": true; }; "canvasHeight": { "alias": "canvasHeight"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, { "cellCommit": "cellCommit"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementRendererComponent, "pptx-element-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "obstacles": { "alias": "obstacles"; "required": false; "isSignal": true; }; "canvasWidth": { "alias": "canvasWidth"; "required": false; "isSignal": true; }; "canvasHeight": { "alias": "canvasHeight"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "fieldContext": { "alias": "fieldContext"; "required": false; "isSignal": true; }; "editTemplateMode": { "alias": "editTemplateMode"; "required": false; "isSignal": true; }; }, { "cellCommit": "cellCommit"; }, never, never, true, never>;
 }
 
 /**
@@ -4020,6 +4403,49 @@ declare class ChartRendererComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartRendererComponent, "pptx-chart-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * smart-art-inline-edit.ts: pure logic for on-canvas SmartArt node text editing.
+ *
+ * The Angular SmartArt renderer lets a user double-click a rendered node to edit
+ * its text directly on the diagram. Everything that can be expressed as a pure
+ * function lives here so it can be unit-tested in plain vitest (the Angular
+ * package's vitest setup has no Angular compiler, so component/TestBed tests are
+ * not available - see PORTING.md). The component
+ * (`smart-art-renderer.component.ts`) stays thin: it owns only the edit-state
+ * signal, the positioned `<textarea>`, and the call into the existing commit
+ * path (`EditorStateService.updateElement`, the same channel the inspector's
+ * `SmartArtPropertiesComponent` commits through, so undo/redo + save round-trip
+ * are shared).
+ *
+ * The commit itself reuses the framework-agnostic core op
+ * `updateSmartArtNodeText` (re-exported via `editor-insert.ts`).
+ *
+ * @module angular-viewer/smart-art-inline-edit
+ */
+
+/**
+ * An axis-aligned box in element-local (viewBox) pixel coordinates, used to
+ * position the inline `<textarea>` over a node. Because the SmartArt `<svg>`
+ * uses a `viewBox` of `0 0 width height` matching the element's pixel size and
+ * fills the element 100%, these coordinates are also the element-local CSS
+ * pixels for the overlaid editor.
+ */
+interface NodeEditBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The node currently being edited on the canvas, or `null`. */
+interface InlineEditState {
+    /** SmartArt data-model node id (matches `PptxSmartArtNode.id`). */
+    nodeId: string;
+    /** Positioned editor box in element-local pixels. */
+    box: NodeEditBox;
+    /** Seed text shown when the editor opens (the node's current text). */
+    text: string;
+}
+
 /**
  * SmartArtRendererComponent: Angular SmartArt renderer.
  *
@@ -4039,6 +4465,27 @@ declare class SmartArtRendererComponent {
     /** The smartArt element to render. Must be `type === 'smartArt'`. */
     readonly element: _angular_core.InputSignal<PptxElement>;
     readonly zIndex: _angular_core.InputSignal<number>;
+    /**
+     * Whether inline on-canvas node-text editing is enabled. False in
+     * presentation / read-only / thumbnail contexts (mirrors the table renderer's
+     * `editable` input). Double-clicking a node only enters edit mode when true.
+     */
+    readonly editable: _angular_core.InputSignal<boolean>;
+    /**
+     * The editor state layer. Optional: the renderer is also used outside the
+     * editing viewer (thumbnails, export), where this service is not provided.
+     * Inline editing commits through `updateElement` here, the exact channel the
+     * inspector's SmartArt panel uses, so undo/redo + save round-trip are shared.
+     */
+    private readonly editor;
+    private readonly injector;
+    /** The node currently being edited on the canvas, or null. */
+    protected readonly editState: _angular_core.WritableSignal<InlineEditState | null>;
+    /** The mounted `<textarea>` for the active node edit, if any. */
+    private readonly nodeEditor;
+    /** Whether node double-click / Enter enters inline edit (editable + has editor). */
+    readonly canEditNodes: _angular_core.Signal<boolean>;
+    constructor();
     private readonly smartArtData;
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly chromeStyle: _angular_core.Signal<StyleMap>;
@@ -4054,15 +4501,44 @@ declare class SmartArtRendererComponent {
     readonly renderedShapes: _angular_core.Signal<RenderedShape[]>;
     readonly layout: _angular_core.Signal<SmartArtLayoutResult>;
     readonly hasLayout: _angular_core.Signal<boolean>;
+    /**
+     * Screen-reader metadata for the whole diagram, derived by the shared
+     * `buildSmartArtA11y`. The container SVG gets `role="img"` + this `label`;
+     * each node gets a per-node `aria-label` + `<title>` resolved by node id.
+     */
+    readonly a11y: _angular_core.Signal<SmartArtA11y | undefined>;
+    /** Map of node id -> accessibility label (for per-node `<title>` lookup). */
+    private readonly a11yLabelById;
+    /** Resolve the accessibility label for a rendered node (by parsed node id). */
+    nodeAriaLabel(node: RenderedNode): string | null;
+    /**
+     * Polite live-region message announcing the most recent node-text commit.
+     * Empty between commits so assistive tech only speaks on change.
+     */
+    readonly liveMessage: _angular_core.WritableSignal<string>;
     /** Narrow a `RenderedNode` to a circle, or `undefined`. */
     asCircle(node: RenderedNode): RenderedCircleNode | undefined;
     /** Narrow a `RenderedNode` to a polygon, or `undefined`. */
     asPolygon(node: RenderedNode): RenderedPolygonNode | undefined;
     /** Narrow a `RenderedNode` to a rect, or `undefined`. */
     asRect(node: RenderedNode): RenderedRectNode | undefined;
+    /** Double-click a node enters inline edit mode (when editable). */
+    onNodeDblClick(event: Event, node: RenderedNode): void;
+    /** Enter / F2 on a focused node enters inline edit mode (when editable). */
+    onNodeKeydown(event: KeyboardEvent, node: RenderedNode): void;
+    /** Commit the current edit (called on blur). */
+    commitEdit(event: Event): void;
+    /** Enter commits (Shift+Enter inserts a newline); Escape cancels. */
+    onEditorKeydown(event: KeyboardEvent): void;
+    /** Resolve the node id + geometry and open the editor seeded with full text. */
+    private enterEdit;
+    /** The node's full (untruncated) data-model text, falling back to rendered text. */
+    private rawNodeText;
+    /** Commit edited text through the shared editor state (one history entry). */
+    private applyCommit;
     readonly isEmpty: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartArtRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartArtRendererComponent, "pptx-smart-art-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartArtRendererComponent, "pptx-smart-art-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -4109,25 +4585,46 @@ declare class InkRendererComponent {
 }
 
 /**
- * Pure, framework-agnostic helpers for OLE renderer.
+ * OLE renderer helpers for the Angular binding.
  *
- * Ported from:
- *   - packages/react/src/viewer/components/elements/InkGroupRenderers.tsx
- *     (resolveOleType, getOleTypeColor, getOleTypeLabel, getOleAriaLabel)
- *   - packages/vue/src/viewer/components/OleRenderer.vue
- *     (placeholder style, badge label, display name)
+ * The pure type-resolution helpers (resolveOleType / getOleType* / aria / badge /
+ * display name / placeholder style) and the size/MIME helpers (formatBytes /
+ * isBrowserOpenableMime) now live in `pptx-viewer-shared` and are re-exported
+ * here so the component (and tests) keep importing them from one local module.
  *
- * All functions are pure (no Angular dependencies) so they can be unit-tested
- * with plain vitest without TestBed or the Angular compiler.
+ * The presentational action-model builders below stay local for now; they are
+ * pure but small and binding-shaped. They build on the shared helpers.
  */
 
+/** A single descriptive info row for the OLE caption / overlay. */
+interface OleInfoRow {
+    /** Stable key for `@for` tracking (e.g. `'type'`, `'file'`). */
+    key: string;
+    /** Display label (e.g. `'Application'`). */
+    label: string;
+    /** Display value (e.g. `'Excel.Sheet.12'`). */
+    value: string;
+}
 /**
- * Resolved OLE application type, narrowed from the raw `OleObjectType` union.
- *
- * `package` and `unknown` from the core type both collapse to `'unknown'` here
- * so that every branch is guaranteed to have a colour and label.
+ * Presentational action model for an OLE element's embedded payload, derived
+ * purely from the core-recovered fields. The binding wires the actual
+ * `<a download>` / new-tab open; this only decides what is offered and with
+ * what attributes.
  */
-type ResolvedOleType = 'excel' | 'word' | 'pdf' | 'visio' | 'mathtype' | 'unknown';
+interface OleActionModel {
+    /** True when an embedded payload data-URL is available to download. */
+    canDownload: boolean;
+    /** True when the payload can additionally be opened in a browser tab. */
+    canOpen: boolean;
+    /** Data-URL for the download anchor `href`, when available. */
+    downloadHref: string | undefined;
+    /** Suggested file name for the download anchor `download` attribute. */
+    downloadFileName: string;
+    /** Human-readable size, when known (e.g. `"2.3 MB"`). */
+    sizeLabel: string | undefined;
+    /** Descriptive info rows (type / file / size / application). */
+    info: OleInfoRow[];
+}
 
 /**
  * OleRendererComponent: Angular port of the React `renderOleElement`
@@ -4170,17 +4667,22 @@ declare class OleRendererComponent {
     readonly ariaLabel: _angular_core.Signal<string>;
     /** Border + background style for the placeholder box. */
     readonly placeholderStyle: _angular_core.Signal<StyleMap>;
+    /**
+     * Download / Open action model derived from the recovered embedded payload.
+     * When the input is not an OLE element, every action is disabled.
+     */
+    readonly actions: _angular_core.Signal<OleActionModel>;
+    /**
+     * Descriptive tooltip for the wrapper: the info rows joined as
+     * "Label: value" pairs (e.g. "Type: Excel Spreadsheet, File: budget.xlsx,
+     * Size: 2.3 KB, Application: Excel.Sheet.12"). Falls back to the aria label
+     * when no rows are available.
+     */
+    readonly infoTitle: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<OleRendererComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<OleRendererComponent, "pptx-ole-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * Pure helpers for `Model3DRendererComponent`.
- *
- * All functions are framework-agnostic (no Angular dependency) so they can be
- * unit-tested without TestBed, following the same pattern as
- * `connector-path.ts`.
- */
 /** Narrowed view-model derived from a `Model3DPptxElement`. */
 interface Model3DViewModel {
     /** Resolved model element, or undefined when the element is not a model3d. */
@@ -4193,26 +4695,58 @@ interface Model3DViewModel {
 }
 
 /**
- * Model3DRendererComponent: Angular port of the Vue `Model3DRenderer.vue`
- * (and the React `Model3DRenderer` / `PosterFallback`), poster-only subset.
+ * Model3DRendererComponent: Angular Model3D renderer with interactive 3D.
  *
- * Interactive 3D rendering (three.js) is intentionally OUT OF SCOPE for the
- * Angular port (see PORTING.md). This component always renders the
- * poster/preview image (`posterImage`, falling back to `imageData`); when
- * neither exists it draws a labelled "3D Model" placeholder, exactly like the
- * React poster fallback.
+ * When the element carries `modelData` and the optional `three` peer dependency
+ * is installed, this mounts the shared, framework-agnostic vanilla-three
+ * controller ({@link MountModel3D} from `pptx-viewer-shared`) into a container
+ * `<div>` for interactive GLB/GLTF rendering (orbit + zoom). The controller's
+ * scene runtime (and `three`) is imported lazily via dynamic `import()` so it
+ * never lands in the main bundle.
  *
- * All non-trivial pure computation lives in `model3d-renderer-helpers.ts` (no
- * Angular dependency) so it can be unit-tested without TestBed.
+ * It falls back to the poster/preview image (`posterImage`, then `imageData`)
+ * when:
+ *  - the element has no `modelData`,
+ *  - `three` is not installed (`mountModel3D` resolves to `THREE_UNAVAILABLE`),
+ *  - or the model fails to load.
+ * When no poster exists either, it draws a labelled "3D Model" placeholder,
+ * exactly like the React poster fallback.
+ *
+ * All non-trivial pure computation (poster selection, blob-url derivation)
+ * lives in `model3d-renderer-helpers.ts` (no Angular dependency) so it can be
+ * unit-tested without TestBed.
  */
-declare class Model3DRendererComponent {
+declare class Model3DRendererComponent implements OnDestroy {
     readonly element: _angular_core.InputSignal<PptxElement>;
     readonly zIndex: _angular_core.InputSignal<number>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
+    /**
+     * Enable interactive orbit controls. `true` (the default) for the viewer /
+     * editor; the root viewer can pass `false` in passive presentation mode.
+     */
+    readonly interactive: _angular_core.InputSignal<boolean>;
+    private readonly sceneRef;
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly vm: _angular_core.Signal<Model3DViewModel>;
+    /** Blob URL for the current model data; recomputed when `modelData` changes. */
+    private readonly blobUrl;
+    /** Lazily-loaded shared mount fn; `null` until the scene runtime resolves. */
+    private readonly mountFn;
+    /** `true` once a model is mountable: render the scene container, not poster. */
+    readonly showScene: _angular_core.Signal<boolean>;
+    /** Set when `three` is missing or the model failed to load: forces poster. */
+    private readonly failed;
+    private handle;
+    /** The blob URL the live handle was mounted with, owned for revocation. */
+    private mountedUrl;
+    constructor();
+    private loadScene;
+    private mount;
+    /** Dispose the live handle and revoke its blob URL. */
+    private teardownHandle;
+    ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Model3DRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Model3DRendererComponent, "pptx-model3d-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Model3DRendererComponent, "pptx-model3d-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -4251,10 +4785,12 @@ interface ZoomViewModel {
  * showing the target slide number. A small "Slide Zoom" / "Section Zoom" badge
  * is drawn in the corner.
  *
- * Navigation (click-to-jump in presentation mode) and live target-slide preview
- * rendering are NOT ported; this is a static link tile only (see PORTING.md).
- * The `slides` array is not threaded through, so the fallback uses the target
- * slide index rather than the real target background.
+ * In presentation mode the overlay provides a {@link ZoomNavigationService}, so
+ * clicking (or Enter/Space) jumps to the target slide. Outside presentation mode
+ * the service is not provided (optional injection yields `null`) and the tile
+ * stays a static link, exactly as before. Live target-slide preview rendering is
+ * still NOT ported; the `slides` array is not threaded through, so the fallback
+ * uses the target slide index rather than the real target background.
  *
  * All non-trivial pure computation lives in `zoom-renderer-helpers.ts` (no
  * Angular dependency) so it can be unit-tested without TestBed.
@@ -4265,6 +4801,18 @@ declare class ZoomRendererComponent {
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly vm: _angular_core.Signal<ZoomViewModel>;
+    /**
+     * Zoom-navigation context, present only inside a running presentation (the
+     * overlay provides it). `null` in the editor tree, where the tile stays
+     * static.
+     */
+    private readonly zoomNavigation;
+    /** Interactive (click-to-jump) only when navigation is available for a zoom. */
+    protected readonly interactive: _angular_core.Signal<boolean>;
+    /** Navigate to the zoom target; no-op when the tile is not interactive. */
+    private activate;
+    protected onClick(event: MouseEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZoomRendererComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZoomRendererComponent, "pptx-zoom-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -4561,6 +5109,12 @@ declare class PresentationOverlayComponent implements OnInit {
     protected readonly playback: AnimationPlaybackService;
     /** Ink-annotation state (pen/highlighter/eraser/laser) for the show. */
     protected readonly annotations: PresentationAnnotationsService;
+    /**
+     * Zoom-navigation context (provided at this component level). The handler is
+     * registered in the constructor so a descendant zoom tile can jump to its
+     * target slide on click. Descendants resolve this same instance.
+     */
+    private readonly zoomNavigation;
     /** Whether the live-caption bar is shown. */
     protected readonly subtitlesVisible: _angular_core.WritableSignal<boolean>;
     /** The slide stage root; animation styles are applied to its elements. */
@@ -4629,6 +5183,13 @@ declare class PresentationOverlayComponent implements OnInit {
     protected onNext(event: MouseEvent): void;
     protected onNextTouch(event: TouchEvent): void;
     private navigate;
+    /**
+     * Jump directly to `index` (clamped to the slide range), committing the same
+     * way `navigate()` does its final step. Used by the zoom-navigation context
+     * for a click-to-jump from a zoom tile: this is a transition-less jump, so it
+     * does NOT replay the target slide's transition.
+     */
+    private goToSlide;
     private emitClosed;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresentationOverlayComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresentationOverlayComponent, "pptx-presentation-overlay", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "startIndex": { "alias": "startIndex"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; }, never, never, true, never>;
@@ -5624,76 +6185,6 @@ interface RecordWebmOptions {
  */
 declare function recordWebm(canvases: HTMLCanvasElement[], opts?: RecordWebmOptions): Promise<Blob>;
 
-/**
- * Pure paragraph bullet / list-marker helpers for the Angular text renderer.
- *
- * No Angular imports: all exports are plain TypeScript functions suitable for
- * use inside computed signals or template helper calls.
- *
- * Numbering schemes follow the OOXML `ST_TextAutonumberScheme` enumeration
- * (ECMA-376 §20.1.10.81). The `autoNumType` strings come from
- * `BulletInfo.autoNumType` as parsed by `pptx-viewer-core`.
- */
-
-/**
- * Render the n-th (1-based) marker for an OOXML auto-numbering scheme.
- *
- * Suffix conventions:
- * - `…Period`    →  `label.`  (e.g. "1.", "a.", "i.")
- * - `…ParenR`    →  `label)`  (e.g. "1)", "a)", "i)")
- * - `…ParenBoth` →  `(label)` (e.g. "(1)", "(a)", "(i)")
- * - `…Plain`     →  `label`   (bare numeral)
- *
- * Unrecognised schemes fall back to `"<n>."`.
- *
- * @param autoNumType - The OOXML auto-number type string (e.g. "arabicPeriod").
- * @param n           - 1-based sequence number to format.
- */
-declare function formatAutoNumber(autoNumType: string | undefined, n: number): string;
-/**
- * Resolved bullet marker for a single paragraph.
- *
- * `marker`     : the text to prepend (e.g. "•", "1.", "a)").
- * `isNumbered` : true for auto-numbered lists; false for character bullets.
- * `color`      : optional explicit bullet colour (hex string from `BulletInfo.color`).
- * `fontFamily` : optional explicit bullet font (from `BulletInfo.fontFamily`).
- */
-interface ParagraphBulletResult {
-    marker: string;
-    isNumbered: boolean;
-    color?: string;
-    fontFamily?: string;
-}
-/**
- * Resolve the bullet marker for the first segment of a paragraph.
- *
- * Returns `undefined` when:
- * - `firstSegment` is undefined or carries no `bulletInfo`.
- * - `bulletInfo.none` is `true` (`a:buNone` explicitly suppresses the bullet).
- * - The paragraph's `listType` is `'none'`.
- * - Neither `char` nor `autoNumType` is present.
- *
- * For auto-numbered bullets the 1-based sequence index is derived from
- * `bulletInfo.autoNumStartAt` (default 1) plus `bulletInfo.paragraphIndex`
- * (0-based paragraph position within the text body).
- *
- * @param firstSegment - The first `TextSegment` of the paragraph (carries `bulletInfo`).
- */
-declare function resolveParagraphBullet(firstSegment: TextSegment | undefined): ParagraphBulletResult | undefined;
-/**
- * Return the left-indent in pixels for the given list nesting level.
- *
- * `level` is the 0-based `paragraphLevel` from `TextSegment` (matches
- * OOXML `a:p/@lvl`). `undefined` or negative values are treated as level 0.
- *
- * @example
- * bulletIndentPx(0)         // 0
- * bulletIndentPx(1)         // 18
- * bulletIndentPx(3)         // 54
- * bulletIndentPx(undefined) // 0
- */
-declare function bulletIndentPx(level: number | undefined): number;
-
 /**
  * EquationRendererComponent: Angular port of the Vue `EquationRenderer.vue`
  * (single-equation variant).
@@ -6063,8 +6554,10 @@ interface PropertiesDraft {
  */
 declare function seedPropertiesDraft(properties: DocumentProperties): PropertiesDraft;
 /**
- * Format a (possibly absent or invalid) ISO timestamp for display. Returns an
- * em-dash for missing values and echoes the raw string for unparseable ones.
+ * Format a (possibly absent or invalid) ISO timestamp for display. Returns the
+ * no-value marker for missing values and echoes the raw string for unparseable
+ * ones. Delegates to the shared `formatIsoDate`; kept under this name for the
+ * existing Angular call sites.
  */
 declare function formatPropertyDate(value: string | undefined): string;
 /**
@@ -6640,27 +7133,25 @@ declare class MobilePresenterViewComponent {
 /**
  * presenter-view-helpers.ts
  *
- * Pure (framework-free) helpers for `PresenterViewComponent`: time/elapsed
- * formatting, notes font-size clamping, rich-notes segment → view-model
- * derivation, and current/next-slide selection.
+ * Helpers for `PresenterViewComponent`: time/elapsed formatting, notes
+ * font-size clamping, rich-notes segment → view-model derivation, timer
+ * progress, and current/next-slide selection.
  *
- * Angular port of the React `components/presenter-view-utils.ts`. The React
- * `renderNotesSegments` produced React nodes; here we instead derive a plain
- * `NotesSegmentViewModel[]` (text + style + break flag) so the logic stays
- * testable without a renderer and the component template owns the markup.
+ * The identical pure helpers (notes font-size constants, `clampNotesFontSize`,
+ * `formatTime`) now live in `pptx-viewer-shared` and are re-exported here from
+ * `../internal/shared` so existing Angular imports of
+ * `./presenter-view-helpers` keep resolving.
+ *
+ * Kept LOCAL (intentionally diverging from shared):
+ *  - `formatElapsed`: clamps negative input to zero (shared's does not).
+ *  - `NotesSegmentViewModel` / `buildNotesSegments`: produce a kebab-case
+ *    `StyleMap` with `px` font sizes for the Angular template, unlike shared's
+ *    camelCase `NotesSpan` (`pt`).
  *
  * Kept TestBed-free (vitest + happy-dom). ng-packagr lib-target constraints:
  * no `String.prototype.replaceAll`, no regex named-capture-groups.
  */
 
-/**
- * Clamp a notes font size value to the allowed range.
- */
-declare function clampNotesFontSize(size: number): number;
-/**
- * Format a Date as a locale time string (HH:MM:SS).
- */
-declare function formatTime(date: Date): string;
 /**
  * Format a millisecond duration as MM:SS, or HH:MM:SS when the elapsed
  * time is one hour or longer. Sub-second values are floored; negative inputs
@@ -6707,57 +7198,6 @@ interface PresenterNotes {
  */
 declare function resolvePresenterNotes(slide: PptxSlide | undefined): PresenterNotes;
 
-/**
- * Shape-geometry clip-path helper.
- *
- * Wires the core geometry APIs into the Angular viewer's shape clipping
- * pipeline. Implements a priority cascade so renderers always pick the
- * highest-fidelity geometry available for a given element:
- *
- *   1. **Adjustment-aware**: if `shapeAdjustments` exist, consult
- *      {@link getAdjustmentAwareShapeClipPath} so shapes like `pie`, `arc`,
- *      `donut`, `blockArc`, and the wedge callouts respond to their
- *      adjustment values.
- *   2. **Spec-correct preset evaluator**: {@link getShapeClipPathFromPreset}
- *      uses the ECMA-376 `pathLst` evaluator to produce a `path('…')`
- *      clip-path for any shape covered by the preset table.
- *   3. **Cloud Bezier path**: {@link getCloudPathForRendering} produces a
- *      DPI-stable cubic-Bezier `path('…')` for `cloud` / `cloudCallout`.
- *   4. **Static polygon table**: {@link getShapeClipPath} (the core preset
- *      table) is the final fallback for shapes none of the higher-fidelity
- *      APIs cover.
- *
- * This module is a plain-TypeScript port of the React package's
- * `viewer/utils/resolved-shape-clip-path.ts`, with no framework imports.
- * It mirrors the Vue port's `viewer/composables/shape-geometry.ts` exactly
- * so the exported function names and signatures are drop-in compatible.
- */
-
-/**
- * Resolve the best available CSS `clip-path` value for a shape type at a
- * given pixel size. Implements the priority cascade described in the module
- * docstring.
- *
- * @param shapeType   The OOXML preset geometry name (case-insensitive).
- * @param width       Element width in pixels (must be > 0 for path output).
- * @param height      Element height in pixels (must be > 0 for path output).
- * @param adjustments Optional `shapeAdjustments` record from the element.
- * @returns A CSS `clip-path` value (`polygon(...)`, `path('…')`, or `inset(...)`),
- *          or `undefined` if no clipping is needed.
- */
-declare function getResolvedShapeClipPathFor(shapeType: string | undefined, width: number, height: number, adjustments?: Record<string, number>): string | undefined;
-/**
- * Element-level convenience wrapper. Pulls `shapeType`, `width`, `height`,
- * and `shapeAdjustments` off a {@link PptxElement} and delegates to
- * {@link getResolvedShapeClipPathFor}.
- *
- * @param element The PPTX element to resolve a clip-path for.
- * @param width   Optional width override (pixels). Defaults to `element.width`.
- * @param height  Optional height override (pixels). Defaults to `element.height`.
- * @returns A CSS `clip-path` value, or `undefined`.
- */
-declare function getResolvedShapeClipPath(element: PptxElement, width?: number, height?: number): string | undefined;
-
 /**
  * SVG path generators for WordArt text warp presets.
  *