pptx-angular-viewer 2.17.9 → 2.18.1

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

@@ -1,6 +1,6 @@
 import * as pptx_viewer_core from 'pptx-viewer-core';
-import { PptxThemePreset, PptxSlide, PptxElement, ShapeStyle, PptxTextWarpPreset, XmlObject, PptxChartSeries, PptxChartData, PptxElementAnimation, PptxAnimationPreset, PptxAnimationSequence, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, ParsedTableStyleMap, PptxThemeColorScheme, PptxThemeFontScheme, TablePptxElement, PptxSection, OlePptxElement, TextSegment, TextStyle, PptxTransitionType, PptxSlideTransition, SmartArtColorScheme, PptxSmartArtChrome, PptxSmartArtDrawingShape, SmartArtStyle, PptxSmartArtData, PptxEmbeddedFont, SmartArtLayout, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, ElementActionType, InkPptxElement, PptxComment, PptxChartType, PptxChartBarDirection, PptxTheme, PptxHandler, PptxData, PptxHeaderFooter, PptxSlideMaster, PptxNotesMaster, PptxHandoutMaster, PptxPresentationProperties, PptxCoreProperties, PptxAppProperties, PptxThemeOption, PptxCustomProperty, PptxTagCollection, ParsedSignature, PptxSaveFormat, PptxTableCell, PptxTableCellStyle, PptxTableRow, PptxTableData, PptxCustomShow, MasterViewTab, SvgExportOptions, Model3DPptxElement, ZoomPptxElement, ChartPptxElement, MediaPptxElement, SmartArtPptxElement, MaterialPresetType, Text3DStyle, BevelPresetType, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartMarker, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, SignatureStatus, ElementAction, PptxImageEffects, MediaBookmark, ColorMapAliasKey, ChartAxisEdit, ChartDataPointLabelEdit, PptxChartLegendPosition, PptxChartStyle, ChartAxisTitleStyleEdit, PptxChartMarkerSymbol, ChartGridlineStyleEdit, PptxSmartArtNode, SmartArtLayoutType, PptxSmartArtNodeStyle, MediaCaptionTrack, PptxMediaType } from 'pptx-viewer-core';
-export { SWITCHABLE_LAYOUT_TYPES, addSmartArtNode, addSmartArtNodeAsChild, chartDataAddCategory, chartDataAddSeries, chartDataChangeType, chartDataRemoveCategory, chartDataRemoveSeries, chartDataUpdatePoint, demoteSmartArtNode, promoteSmartArtNode, removeSmartArtNode, reorderSmartArtNode, switchSmartArtLayout, updateSmartArtNodeText } from 'pptx-viewer-core';
+import { PptxThemePreset, PptxSlide, PptxElement, ShapeStyle, PptxTextWarpPreset, XmlObject, PptxChartSeries, PptxChartData, PptxElementAnimation, PptxAnimationPreset, PptxAnimationSequence, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, ParsedTableStyleMap, PptxThemeColorScheme, PptxThemeFontScheme, TablePptxElement, PptxSection, OlePptxElement, TextSegment, TextStyle, PptxTransitionType, PptxSlideTransition, SmartArtColorScheme, PptxSmartArtChrome, PptxSmartArtDrawingShape, SmartArtStyle, PptxSmartArtData, PptxEmbeddedFont, SmartArtLayout, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, ElementActionType, InkPptxElement, PptxComment, PptxChartType, PptxChartBarDirection, PptxTheme, PptxHandler, PptxData, PptxHeaderFooter, PptxCustomShow, PptxSlideMaster, PptxNotesMaster, PptxHandoutMaster, PptxPresentationProperties, PptxCoreProperties, PptxAppProperties, PptxThemeOption, PptxCustomProperty, PptxTagCollection, ParsedSignature, PptxSaveFormat, PptxTableCell, PptxTableCellStyle, PptxTableRow, PptxTableData, MasterViewTab, SvgExportOptions, Model3DPptxElement, ZoomPptxElement, ChartPptxElement, MediaPptxElement, SmartArtPptxElement, MaterialPresetType, Text3DStyle, BevelPresetType, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartMarker, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, SignatureStatus, ElementAction, PptxImageEffects, MediaBookmark, ColorMapAliasKey, ChartAxisEdit, ChartDataPointLabelEdit, PptxChartLegendPosition, PptxChartStyle, ChartAxisTitleStyleEdit, PptxChartMarkerSymbol, ChartGridlineStyleEdit, PptxSmartArtNode, SmartArtLayoutType, PptxSmartArtNodeStyle, PptxLayoutPreview, MediaCaptionTrack, PptxMediaType } from 'pptx-viewer-core';
+export { GroupResult, SWITCHABLE_LAYOUT_TYPES, UngroupResult, addSmartArtNode, addSmartArtNodeAsChild, chartDataAddCategory, chartDataAddSeries, chartDataChangeType, chartDataRemoveCategory, chartDataRemoveSeries, chartDataUpdatePoint, demoteSmartArtNode, formatAutoNumberMarker as formatAutoNumber, groupElements, promoteSmartArtNode, removeSmartArtNode, reorderSmartArtNode, switchSmartArtLayout, ungroupElements, updateSmartArtNodeText } from 'pptx-viewer-core';
 import * as _angular_core from '@angular/core';
 import { Signal, WritableSignal, OnDestroy, OnInit, AfterViewInit, OnChanges, SimpleChanges, InjectionToken, Provider } from '@angular/core';
 import * as AiSdk from 'ai';
@@ -903,7 +903,7 @@ interface ChartOption<V> {
  *   area / area3D -> polygon fill + polyline
  *   pie / doughnut / pie3D / ofPie -> arc paths
  *   scatter -> circle dots
- *   bubble -> circle dots sized by a 3rd series
+ *   bubble -> circle dots sized by each series' own c:bubbleSize
  *   radar / radar3D -> polar polygons + spokes
  *   combo / stock / surface / treemap / waterfall / regionMap -> sibling modules
  *   funnel / sunburst / histogram / boxWhisker -> sibling modules
@@ -914,7 +914,7 @@ interface ChartOption<V> {
  *   area / area3D -> polygon fill + polyline
  *   pie / doughnut / pie3D / ofPie -> arc paths
  *   scatter -> circle dots
- *   bubble -> circle dots sized by a 3rd series
+ *   bubble -> circle dots sized by each series' own c:bubbleSize
  *   radar / radar3D -> polar polygons + spokes
  *
  * Deferred (fallback box rendered instead):
@@ -1049,6 +1049,14 @@ interface SvgPath {
     strokeWidth?: number;
     opacity?: number;
     part?: ChartPartRef;
+    /**
+     * Hover tooltip / accessible name, projected as an SVG `<title>` child.
+     *
+     * Only the region map sets it today: a choropleth patch carries no label of
+     * its own, so without a tooltip the reader cannot tell which region a colour
+     * belongs to. Projectors that ignore the field simply render no tooltip.
+     */
+    title?: string;
 }
 interface SvgPolyline {
     kind: 'polyline';
@@ -1241,7 +1249,25 @@ interface ScatterDot {
     cx: number;
     cy: number;
 }
-declare function computeScatterDots(values: ReadonlyArray<number>, maxXIndex: number, layout: PlotLayout, range: ValueRange, xValues?: ReadonlyArray<number>): ScatterDot[];
+/**
+ * The x extent a scatter / bubble plot is drawn against.
+ *
+ * Every `CT_ScatterSer` / `CT_BubbleSer` carries its own `c:xVal`, so the
+ * domain has to be computed ACROSS series before any of them is projected;
+ * letting each series derive its own min/span would stretch every series to
+ * fill the plot and destroy the relationship between them.
+ */
+interface ScatterXDomain {
+    min: number;
+    span: number;
+}
+/**
+ * Union x domain of several series' x values. Returns `undefined` when no
+ * series declares a finite x value, in which case callers fall back to
+ * positioning points by index.
+ */
+declare function computeScatterXDomain(seriesXValues: ReadonlyArray<ReadonlyArray<number> | undefined>): ScatterXDomain | undefined;
+declare function computeScatterDots(values: ReadonlyArray<number>, maxXIndex: number, layout: PlotLayout, range: ValueRange, xValues?: ReadonlyArray<number>, xDomain?: ScatterXDomain): ScatterDot[];
 /**
  * Radius of a bubble given its size value, the max size in the chart, and a
  * median radius derived from the plot area. Mirrors `renderBubbleChart` in
@@ -1260,6 +1286,18 @@ declare function computeRadarPoints(values: ReadonlyArray<number>, maxVal: numbe
 /** Points string for a radar gridline ring at radius `rr`. */
 declare function radarRingPoints(cx: number, cy: number, rr: number, catCount: number): string;
 type SupportedChartKind = 'bar' | 'line' | 'area' | 'pie' | 'doughnut' | 'scatter' | 'bubble' | 'radar' | 'combo' | 'stock' | 'surface' | 'treemap' | 'waterfall' | 'regionMap' | 'funnel' | 'sunburst' | 'histogram' | 'boxWhisker';
+/**
+ * The `preserveAspectRatio` a chart kind's `<svg>` must carry.
+ *
+ * Cartesian charts stretch to fill the element box (`none`); the kinds whose
+ * geometry is round or laid out on a fixed-ratio canvas (pie, doughnut, radar,
+ * and the region map's 1000x500 world outline) keep their proportions instead.
+ *
+ * A pure decision function because all five bindings need the same answer and
+ * four of them had written their own copy of the `kind === 'pie' || ...` chain;
+ * one of the copies (React's) disagreed with the rest.
+ */
+declare function chartPreserveAspectRatio(kind: SupportedChartKind | 'unsupported'): 'none' | 'xMidYMid meet';
 declare function resolveChartKind(chartType: string): SupportedChartKind | 'unsupported';
 declare function buildChartViewModel(element: PptxElement): ChartViewModel;
 declare function buildFallbackViewModel(width: number, height: number, label: string): ChartViewModel;
@@ -2198,67 +2236,6 @@ declare function computeDistribute(boxes: readonly AlignBox[], mode: DistributeM
 /** The eight resize handles, named by compass direction. */
 type ResizeHandleId = 'nw' | 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w';
 
-/**
- * group-ops: Pure, immutable group/ungroup operations for the slide element tree.
- *
- * No framework imports. No mutation of inputs. No `any` types. Shared by every
- * binding's editor.
- *
- * Coordinate system (verified from the renderer):
- *   - The group <div> is positioned at (group.x, group.y) in slide space.
- *   - Each child is positioned at (child.x, child.y) RELATIVE to the group's
- *     top-left corner inside that div.
- *
- * Therefore:
- *   - grouping   -> child slide-absolute -> child group-relative:
- *       childRelX = childAbsX - groupX
- *   - ungrouping -> child group-relative -> child slide-absolute:
- *       childAbsX = childRelX + groupX
- */
-
-interface GroupResult {
-    /** New element array for the slide (same length - N + 1). */
-    elements: PptxElement[];
-    /**
-     * The id of the newly-created group element, or `null` when the operation
-     * was a no-op (fewer than 2 matching ids found).
-     */
-    groupId: string | null;
-}
-interface UngroupResult {
-    /** New element array for the slide. */
-    elements: PptxElement[];
-    /** The child ids that were actually applied (one per child, in order). */
-    childIds: string[];
-}
-/**
- * Gather the elements whose `id` is in `ids` (preserving their existing array
- * order), compute the union bounding box, build a new `group` element whose
- * `children` are positioned relative to the group's top-left corner, remove
- * the originals, and insert the group where the topmost (lowest-index) grouped
- * element was.
- *
- * Requires >= 2 ids that actually exist in `elements`; otherwise returns the
- * original array unchanged and `groupId: null`.
- *
- * The caller supplies `groupId` for determinism (the service passes its
- * `newId()` result).
- */
-declare function groupElements(elements: readonly PptxElement[], ids: readonly string[], groupId: string): GroupResult;
-/**
- * Find the group element identified by `groupId` in `elements`. If found and
- * it is a `group`, replace it in-place with its children, each converted back
- * to slide-absolute coordinates (childX + groupX, childY + groupY) and
- * assigned a fresh id from the `childIds` array (one per child, in order).
- *
- * If the element is not found or is not a group, returns the original inputs
- * unchanged.
- *
- * The caller supplies `childIds` for determinism (the service passes one
- * `newId()` result per child).
- */
-declare function ungroupElements(elements: readonly PptxElement[], groupId: string, childIds: readonly string[]): UngroupResult;
-
 /**
  * Slide-background style resolution.
  *
@@ -2785,15 +2762,6 @@ declare function generateTicks(slideLengthPx: number, scale: number, unit: Ruler
  */
 declare function rulerDragToGuidePosition(pointerOffsetPx: number, scale: number, slideLengthPx: number): number | null;
 
-/**
- * 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).
  *
@@ -3177,6 +3145,31 @@ declare function routeOrthogonalConnector(start: RouterPoint, end: RouterPoint,
 /** Convert an array of waypoints to an SVG path `d` string (comma-separated). */
 declare function waypointsToPathD(waypoints: ReadonlyArray<RouterPoint>): string;
 
+/**
+ * `connector-endpoints`: attaching and detaching a connector's ends on canvas.
+ *
+ * `connector-reroute` keeps a BOUND connector following its shapes and
+ * `connector-authoring` turns a site-to-site drag into a new connector. Neither
+ * lets the user change an existing connector's bindings, which is what
+ * PowerPoint's two endpoint handles do: drag one onto a shape and it gains an
+ * `a:stCxn` / `a:endCxn` and starts following that shape; drag it onto empty
+ * canvas and the binding is removed and the end stays where it is dropped.
+ *
+ * That was implemented in no binding at all. React shipped a `ConnectorOverlay`
+ * for the site-to-site creation gesture, but nothing ever passed the
+ * `connectorCreationMode` / `onCreateConnector` props that mount it, so the
+ * whole path was unreachable; the other four had no overlay in the first place.
+ *
+ * Everything here is slide-pixel space and free of framework imports: a binding
+ * supplies pointer positions already converted out of screen space, and applies
+ * the returned descriptor.
+ *
+ * @module render/connector-endpoints
+ */
+
+/** Which end of a connector a gesture is moving. */
+type ConnectorEndpointKind = 'start' | 'end';
+
 /**
  * Arrow-head marker shapes for connectors.
  *
@@ -3295,6 +3288,84 @@ declare function applyFormatToElement(element: PptxElement, format: CopiedFormat
 /** True when an element exposes formatting fields the painter can copy. */
 declare function hasCopyableFormat(element: PptxElement | null | undefined): boolean;
 
+/**
+ * `shape-adjustment-model`: the vocabulary the adjust-handle modules share.
+ *
+ * The `a:ahLst` work is split three ways for the repo's file-size budget:
+ * `shape-adjustment-probe` measures the geometry, `shape-adjustment-handles`
+ * derives the handles from those measurements, and `shape-adjustment-solver`
+ * turns a pointer position back into guide values. All three need these types
+ * and the one rule that operates purely on them, so they live here and the
+ * dependency graph stays a DAG rather than a cycle.
+ *
+ * @module render/shape-adjustment-model
+ */
+/**
+ * How a pointer position becomes a guide value, captured once when the gesture
+ * starts so `pointermove` stays pure arithmetic.
+ */
+interface ShapeAdjustmentSolver {
+    /** `linear`: the handle slides. `angular`: it swings about {@link centerX}. */
+    kind: 'linear' | 'angular';
+    /** Handle position in element-local px at {@link startValue}. */
+    anchorX: number;
+    anchorY: number;
+    /** Element-local px the handle travels per ONE unit of guide value. */
+    dirX: number;
+    dirY: number;
+    /** Pivot for an angular handle (the shape centre). */
+    centerX: number;
+    centerY: number;
+    /** The guide value the anchor was measured at. */
+    startValue: number;
+    /** Guide-space bounds, taken from the preset's own `pin` clamp. */
+    min: number;
+    max: number;
+}
+/** One guide a handle drives. */
+interface AdjustmentAxisSolver {
+    key: string;
+    solver: ShapeAdjustmentSolver;
+}
+
+/**
+ * Shape-adjustment handles: PowerPoint's yellow `a:avLst` diamonds. Pure,
+ * framework-agnostic math shared by all five bindings.
+ *
+ * Owns the adjustment scalar constants and the handle/drag descriptor types so
+ * each binding consumes one copy rather than re-declaring them.
+ *
+ * A preset has ONE handle per adjustable parameter and many presets have
+ * several (`callout3` has eight), so the entry point is
+ * {@link getShapeAdjustmentHandleDescriptors}, returning an array. Placement and
+ * drag scale are measured off the preset geometry by
+ * `shape-adjustment-handles`; this module is the element-level policy around
+ * it (lock check, element type, custom geometry) plus the round-rect helpers
+ * the renderers use for `border-radius`.
+ */
+
+/** Descriptor for one draggable adjustment handle (the amber diamond). */
+interface ShapeAdjustmentHandleDescriptor {
+    /** The `a:avLst` guide name this handle writes (`adj`, `adj1`, ...). */
+    key: string;
+    /** Handle x offset in element-local px (origin = element top-left). */
+    left: number;
+    /** Handle y offset in element-local px. */
+    top: number;
+    /**
+     * Current adjustment value in GUIDE units, not a 0-1 fraction. Most presets
+     * range 0..50000 or 0..100000 and the angular ones run to 21,600,000.
+     */
+    value: number;
+    cursor: string;
+    /**
+     * How this handle's drag resolves, measured off the preset geometry: one
+     * entry per `a:avLst` guide it drives (callouts drive two). Absent only for
+     * a caller that built a descriptor by hand.
+     */
+    solvers?: AdjustmentAxisSolver[];
+}
+
 /**
  * Hyperlink security utilities — URL validation, sanitization, and slide-jump
  * resolution for hyperlink click actions in the viewer. Pure, framework-agnostic
@@ -3757,8 +3828,99 @@ interface SlideTransitionOptionEntry {
     i18nKey: string;
 }
 
+/**
+ * `ribbon-transitions` - the Transitions ribbon tab expressed as a pure
+ * decision function, so a click on a preset means the same thing in all five
+ * bindings.
+ *
+ * WHY shared: the tab is a set of MODIFIERS (duration, advance-on-click,
+ * advance-after, apply-to-all) that only make sense combined with the preset
+ * the user clicked. Every binding had re-decided that combination for itself,
+ * and two of them (react, vue) never decided it at all: their controls wrote
+ * component-local state and nothing reached the deck, so a picked transition
+ * highlighted in the gallery and the saved `.pptx` carried no `p:transition`.
+ * The preset list itself was five hand-copied arrays.
+ *
+ * The shape here is the repo's standard one: shared owns the DRAFT (what the
+ * controls currently say), the READ (what a slide's transition says the
+ * controls should show) and the CHANGE (the `PptxSlideTransition` fields a
+ * commit writes). A binding renders the draft and hands the change to whatever
+ * slide-mutation path it already has.
+ *
+ * @module render/ribbon-transitions
+ */
+
+/** One entry of the ribbon's transition gallery. */
+interface RibbonTransitionPreset {
+    type: PptxTransitionType;
+    labelKey: string;
+}
+/** Everything the Transitions tab's controls currently say. */
+interface RibbonTransitionDraft {
+    /** The highlighted gallery entry. */
+    type: PptxTransitionType;
+    /** Duration field, in seconds. */
+    durationSec: number;
+    /** Advance Slide > On Mouse Click. */
+    advanceOnClick: boolean;
+    /** Advance Slide > After (whether the timed advance is armed at all). */
+    advanceAfter: boolean;
+    /** Advance Slide > After, as the `mm:ss.hh` text the field holds. */
+    advanceAfterText: string;
+}
+
+/**
+ * `ribbon-slide-show-options` - the Slide Show tab's Options cluster as a pure
+ * decision function over `PptxPresentationProperties`.
+ *
+ * WHY shared: all five bindings rendered these four checkboxes hard-coded
+ * `checked` with no change handler, so "Use Timings" claimed to be on whether
+ * or not the deck's `p:showPr/@useTimings` said so, and unticking it did
+ * nothing. Two of them (`@useTimings`, `@showNarration`) are real, saved OOXML
+ * attributes that the playback path already reads; deciding the mapping here
+ * means the checkbox state and the show's behaviour cannot disagree.
+ *
+ * Two entries are declared UNSUPPORTED rather than quietly inert. "Keep Slides
+ * Updated" is a co-authoring/Broadcast feature no binding implements, and
+ * "Show Media Controls" is an application preference PowerPoint does not store
+ * in the package at all and nothing in this viewer reads. A control that cannot
+ * do anything renders disabled, because a checkbox that toggles and changes
+ * nothing is worse than one that admits it is unavailable.
+ *
+ * @module render/ribbon-slide-show-options
+ */
+
+/** The four checkboxes in the Slide Show tab's Options group. */
+type SlideShowOptionId = 'keepUpdated' | 'useTimings' | 'playNarrations' | 'mediaControls';
+/** How a binding should render one Options checkbox. */
+interface SlideShowOptionDescriptor {
+    id: SlideShowOptionId;
+    labelKey: string;
+    /**
+     * No backing state exists, so the control renders disabled. See the module
+     * doc for why each one is here.
+     */
+    unsupported: boolean;
+}
+
+/**
+ * Per-node label styling resolved from `PptxSmartArtNode.style` (the overrides
+ * the inspector's node style bar writes).
+ *
+ * Every field is optional and every field has a documented binding default, so
+ * a renderer that ignores them keeps its historic output:
+ * `fontColor` -> `white`, `fontWeight` / `fontStyle` -> unset.
+ */
+interface RenderedNodeTextStyle {
+    /** Label colour. Default `white`. */
+    fontColor?: string;
+    /** SVG `font-weight` (`700` when the node is bold). Default unset. */
+    fontWeight?: number;
+    /** SVG `font-style`. Default unset. */
+    fontStyle?: 'italic';
+}
 /** A node rendered as an SVG rect (rounded or flat). */
-interface RenderedRectNode {
+interface RenderedRectNode extends RenderedNodeTextStyle {
     kind: 'rect';
     key: string;
     x: number;
@@ -3778,7 +3940,7 @@ interface RenderedRectNode {
     textY: number;
 }
 /** A node rendered as an SVG circle. */
-interface RenderedCircleNode {
+interface RenderedCircleNode extends RenderedNodeTextStyle {
     kind: 'circle';
     key: string;
     cx: number;
@@ -3790,9 +3952,24 @@ interface RenderedCircleNode {
     opacity: number;
     text: string;
     fontSize: number;
+    /**
+     * Label anchor x. Defaults to `cx`; set when the label sits away from the
+     * circle (target leader labels, timeline captions).
+     */
+    textX?: number;
+    /** Label anchor y. Defaults to `cy`. */
+    textY?: number;
+    /** SVG `text-anchor` for the label. Defaults to `middle`. */
+    textAnchor?: 'start' | 'middle' | 'end';
+    /**
+     * How the label block sits relative to `textY`: `middle` centres it (the
+     * default), `bottom` puts the last baseline on `textY` (label above the
+     * node), `top` puts the first line's top on `textY` (label below).
+     */
+    textBaseline?: 'top' | 'middle' | 'bottom';
 }
 /** A node rendered as an SVG polygon (chevron, trapezoid, etc.). */
-interface RenderedPolygonNode {
+interface RenderedPolygonNode extends RenderedNodeTextStyle {
     kind: 'polygon';
     key: string;
     points: string;
@@ -3808,14 +3985,29 @@ interface RenderedPolygonNode {
     textY: number;
 }
 type RenderedNode = RenderedRectNode | RenderedCircleNode | RenderedPolygonNode;
-/** A connector line between two rendered nodes. */
+/**
+ * A connector line between two rendered nodes.
+ *
+ * The paint fields are optional and carry the values every binding already
+ * hardcodes, so a renderer that ignores them is unchanged:
+ * `stroke` -> `#94a3b8`, `strokeWidth` -> `1.5`, `opacity` -> `0.5`,
+ * `dash` -> solid.
+ */
 interface RenderedConnector {
     key: string;
     /** SVG path data string. */
     d: string;
+    /** Stroke colour. Default `#94a3b8`. */
+    stroke?: string;
+    /** Stroke width. Default `1.5`. */
+    strokeWidth?: number;
+    /** Stroke opacity. Default `0.5`. */
+    opacity?: number;
+    /** SVG `stroke-dasharray`. Default solid. */
+    dash?: string;
 }
 /** The layout family applied to a SmartArt element. */
-type LayoutFamily = 'list' | 'process' | 'cycle' | 'hierarchy' | 'matrix' | 'radial' | 'pyramid' | 'venn' | 'funnel' | 'target';
+type LayoutFamily = 'list' | 'process' | 'cycle' | 'hierarchy' | 'matrix' | 'radial' | 'pyramid' | 'venn' | 'funnel' | 'target' | 'gear' | 'timeline' | 'bending';
 /** Complete layout output for a single SmartArt family. */
 interface SmartArtLayoutResult {
     /** Rendered geometry nodes. */
@@ -3879,26 +4071,6 @@ interface SvgTextLine {
     text: string;
     y: number;
 }
-/** Options for {@link centeredSvgTextLines}. */
-interface CenteredSvgTextOptions {
-    /**
-     * Available width. When given, long lines are wrapped to fit it; when
-     * omitted, only authored line breaks split the label.
-     */
-    maxWidth?: number;
-    /** Baseline the block is centred on. Defaults to 0, giving relative offsets. */
-    centerY?: number;
-}
-/**
- * Split a label into lines and centre the block vertically.
- *
- * @param text - The label text; `\n` breaks are always honoured.
- * @param fontSize - Font size in the same user units as the result.
- * @param options - See {@link CenteredSvgTextOptions}.
- * @returns One entry per line. Empty text yields a single empty line so callers
- *   that always emit a `<tspan>` keep their previous single-line geometry.
- */
-declare function centeredSvgTextLines(text: string, fontSize: number, options?: CenteredSvgTextOptions): SvgTextLine[];
 
 /**
  * smartart-drawing.ts: Drawing-shape view-model helpers for the SmartArt
@@ -4026,6 +4198,58 @@ declare function projectDrawingShapes(elementId: string, shapes: PptxSmartArtDra
 /** Drop-shadow filter string for the given style intensity. */
 declare function styleShadowFilter(style: SmartArtStyle): string | undefined;
 
+/**
+ * SmartArt fallback-layout paint decisions: where a node's label sits and how a
+ * connector is stroked.
+ *
+ * `RenderedNode` / `RenderedConnector` carry a set of OPTIONAL paint and
+ * placement fields (`fontColor`, `fontWeight`, `fontStyle`, `textX`, `textY`,
+ * `textAnchor`, `textBaseline`; `stroke`, `strokeWidth`, `opacity`, `dash`).
+ * Every one has a documented binding default, so a renderer that ignored them
+ * kept its historic output - which is exactly what four of the five bindings
+ * did, hardcoding `fill="white"` and parking circle labels on `cx`/`cy`. Target
+ * captions and timeline captions then sat on top of their dot instead of beside
+ * or above it.
+ *
+ * Applying those defaults, and stacking a multi-line label for the three
+ * baseline modes, is arithmetic no binding should own a copy of. This module is
+ * the single pure decision function: it returns a framework-neutral descriptor
+ * and each binding does nothing but map it onto `<text>` / `<tspan>` / `<path>`
+ * attributes.
+ *
+ * @module smartart-node-label
+ */
+
+/** Resolved paint for one fallback-layout connector path. */
+interface SmartArtConnectorPaint {
+    /** SVG path data, copied straight from the descriptor. */
+    d: string;
+    stroke: string;
+    strokeWidth: number;
+    opacity: number;
+    /** SVG `stroke-dasharray`, or `undefined` for a solid line. */
+    dash: string | undefined;
+}
+/** Everything a binding needs to draw one node's label, already decided. */
+interface SmartArtNodeLabel {
+    /** Whether the node has any label at all; `false` means draw no `<text>`. */
+    visible: boolean;
+    /** X of the text block (also the x of every `<tspan>`). */
+    x: number;
+    /** SVG `text-anchor`. */
+    textAnchor: 'start' | 'middle' | 'end';
+    /** SVG `dominant-baseline` for the block. */
+    dominantBaseline: 'auto' | 'hanging' | 'central';
+    /** Absolute-positioned lines: one `<tspan>` per entry, at its own `y`. */
+    lines: SvgTextLine[];
+    fill: string;
+    fontSize: number;
+    /** SVG `font-weight`, or `undefined` to leave it unset. */
+    fontWeight: number | undefined;
+    /** SVG `font-style`, or `undefined` to leave it unset. */
+    fontStyle: 'italic' | undefined;
+}
+
 /**
  * inspector-helpers.ts: Pure (no framework) helpers for the inspector panel.
  *
@@ -4337,6 +4561,134 @@ interface CustomShow {
 declare function generateCustomShowId(): string;
 declare function createCustomShow(name: string, slideIds: readonly string[]): CustomShow;
 
+/**
+ * slide-size.ts: the Design > Slide Size decision function.
+ *
+ * Framework-agnostic: no React, Vue, Angular, Svelte or DOM imports.
+ *
+ * ## Why the dimensions, not the `type`, are the source of truth
+ *
+ * `p:sldSz` carries `@cx`, `@cy` and an optional `@type` (ST_SlideSizeType).
+ * It is tempting to treat `@type` as the selection and the dimensions as a
+ * derived detail. PowerPoint does the opposite. Measured through COM: a deck
+ * whose `p:sldSz` said `type="A4"` while carrying 4:3 dimensions reported
+ * `PageSetup.SlideSize = ppSlideSizeCustom`, and the same deck with A4
+ * dimensions and NO `@type` at all reported `ppSlideSizeA4Paper`. So every
+ * preset below is defined by its EMU pair, and `@type` is written alongside
+ * for fidelity only.
+ *
+ * Each `emuWidth`/`emuHeight` pair here was confirmed by writing it into a
+ * real package and asking PowerPoint what preset it saw (the `ppSlideSize*`
+ * value in the `comValue` field). Two entries are exceptions and say so.
+ */
+type SlideSizeOrientation = 'landscape' | 'portrait';
+interface SlideSizeEmu {
+    widthEmu: number;
+    heightEmu: number;
+    /** ST_SlideSizeType token, or `''` for a size with no preset. */
+    type: string;
+}
+interface SlideSizePreset {
+    /** `p:sldSz/@type` (ST_SlideSizeType). `custom` is the schema default. */
+    readonly type: string;
+    /** i18n key under `pptx.slideSize.presets`. */
+    readonly labelKey: string;
+    /** Landscape width in EMU. Portrait swaps the pair. */
+    readonly widthEmu: number;
+    /** Landscape height in EMU. */
+    readonly heightEmu: number;
+    /**
+     * The `PpSlideSizeType` value PowerPoint reports for these dimensions,
+     * or `undefined` where that could not be confirmed.
+     */
+    readonly comValue?: number;
+}
+interface SlideSizeSelectionDescriptor {
+    /** The effective size, in EMU, that a save should persist. */
+    readonly size: SlideSizeEmu;
+    /** The matching preset, or `undefined` for a custom size. */
+    readonly preset: SlideSizePreset | undefined;
+    readonly orientation: SlideSizeOrientation;
+    /** The canvas size the stage should use for this selection. */
+    readonly canvas: {
+        width: number;
+        height: number;
+    };
+}
+
+/**
+ * presentation-file-kinds: the one place that answers "can the viewer open
+ * this file?" and "what should the saved copy be called?".
+ *
+ * ## Why this is a shared decision and not five allow-lists
+ *
+ * The loader reads more formats than any single UI advertises. Legacy binary
+ * `.ppt` (PowerPoint 97-2003) is the sharp example: `PptxHandler.load()` has
+ * detected the OLE compound-file container and converted the binary deck
+ * through the regular pptx pipeline for some time, but the product kept saying
+ * it was unsupported, and a picker that filters the extension out makes a
+ * working loader unreachable in practice. Whenever the loader learns a format,
+ * exactly one list has to change.
+ *
+ * ## Read many, write one
+ *
+ * Input is a superset of output. We READ `.pptx`, `.ppsx`, `.pptm`, `.potx`,
+ * legacy binary `.ppt` and portable `pptx-viewer-json`; we WRITE only the
+ * OpenXML family. That asymmetry is deliberate (PowerPoint itself does the
+ * same: open a 97-2003 deck and Save As offers `.pptx`), and it is why
+ * {@link savedPresentationFileName} always REPLACES the source extension
+ * rather than keeping it. A deck opened as `report.ppt` and saved as
+ * `report.ppt` would be a file whose bytes and whose name disagree, which is
+ * the kind of thing PowerPoint refuses to open.
+ *
+ * This module deliberately imports nothing, so any layer (render, export, a
+ * binding, a host app) can depend on it without risking an import cycle.
+ *
+ * @module render/presentation-file-kinds
+ */
+/**
+ * Extensions the built-in file picker offers, in the order it offers them.
+ *
+ * `.ppt` is in the list because the loader genuinely handles it, not as a
+ * courtesy: see `packages/core/src/core/ppt/` and the `ppt-import` integration
+ * suite, which asserts a `.ppt` loads to the same model as the `.pptx` it was
+ * exported from.
+ */
+declare const PRESENTATION_OPEN_EXTENSIONS: readonly [".pptx", ".ppsx", ".pptm", ".potx", ".ppt", ".json"];
+/** Comma-separated `accept` attribute for a presentation file input. */
+declare const PPTX_OPEN_ACCEPT: string;
+/**
+ * True when a picked / dropped file's name looks like something the loader can
+ * open. Use this instead of a hand-rolled `endsWith` chain: a drop handler that
+ * disagrees with the picker's `accept` list is a format that is supported by
+ * mouse but not by drag, which is how `.ppt` stayed invisible.
+ *
+ * Extension-only, by design. The real answer comes from the container sniff in
+ * `PptxHandler.load()`; this is only the cheap pre-filter a drop target needs
+ * before it hands bytes to the loader.
+ */
+declare function isSupportedPresentationFile(name: string | null | undefined): boolean;
+/** True for the binary PowerPoint 97-2003 family, which we read but never write. */
+declare function isLegacyBinaryPresentation(name: string | null | undefined): boolean;
+/** The formats the save path can produce. Binary `.ppt` is deliberately absent. */
+type SavedPresentationFormat = 'pptx' | 'ppsx' | 'pptm';
+/**
+ * The stem of a presentation file name: directories and any loadable extension
+ * removed. `C:\decks\report.ppt` becomes `report`; a name with no recognised
+ * extension is kept whole, so `Untitled Presentation` survives intact rather
+ * than losing everything after its last dot.
+ */
+declare function presentationBaseName(sourceName: string | null | undefined, fallback?: string): string;
+/**
+ * The name a saved copy should be offered under: the source stem plus the
+ * extension of the format actually being written.
+ *
+ * This is what turns `report.ppt` into `report.pptx` on Save As. Output is
+ * always an OpenXML package, so keeping the source extension would mislabel
+ * the bytes.
+ */
+declare function savedPresentationFileName(sourceName: string | null | undefined, format?: SavedPresentationFormat): string;
+
 /**
  * Format an epoch-ms timestamp as a short month / day / time label, e.g.
  * "Jun 25, 02:14", for the version-history panels.
@@ -5535,6 +5887,46 @@ interface ShapePresetDef {
     glyphClass: string;
 }
 
+/** Identifies a group so bindings can label and style it. */
+type FontCatalogGroupId = 'theme' | 'embedded' | 'custom' | 'all';
+/** One selectable font. */
+interface FontCatalogEntry {
+    /** The family name written into the run's `fontFamily`. */
+    family: string;
+    /**
+     * Which theme slot this family fills, for the "(Headings)" / "(Body)" hint
+     * PowerPoint shows beside its two theme fonts. Absent for other entries.
+     */
+    themeRole?: 'heading' | 'body';
+}
+/** A headed group of fonts. */
+interface FontCatalogGroup {
+    id: FontCatalogGroupId;
+    /** i18n key for the group heading. */
+    labelKey: string;
+    entries: FontCatalogEntry[];
+}
+
+/** What the "Embed fonts in the file" toggle should look like and do. */
+interface FontEmbeddingDescriptor {
+    /** Distinct typeface names the loaded deck currently embeds. */
+    embeddedFamilies: string[];
+    /**
+     * Whether the toggle accepts input. False when the deck embeds nothing,
+     * because turning it on could not produce an embedded font.
+     */
+    interactive: boolean;
+    /**
+     * The position the toggle must START in so that it describes the file that
+     * would be written right now. A deck that arrived with embedded fonts keeps
+     * them on save, so the switch has to read "on" from the outset; the previous
+     * hardcoded `false` said the opposite of what save actually did.
+     */
+    initialEnabled: boolean;
+    /** Present only when `interactive` is false. */
+    disabledReasonKey?: string;
+}
+
 /**
  * Command-search data for the PowerPoint-style "Tell me what you want to do"
  * search bar. Provides searchable command entries grouped by category, each
@@ -5552,6 +5944,138 @@ interface CommandSearchEntry {
     category: 'format' | 'insert' | 'view' | 'slideShow' | 'design' | 'arrange';
 }
 
+/**
+ * @fileoverview Who decides whether recovery autosave runs, and how often.
+ *
+ * ## The rule: the host prop is a ceiling, the toggle is a preference
+ *
+ * Two things can speak about autosave, and until now each binding invented its
+ * own answer for what happens when both do:
+ *
+ *  - the **host** passes an `autosave` prop. That is a POLICY: the embedder is
+ *    stating what its application permits.
+ *  - the **user** flips the title-bar AutoSave switch, or File > Options > Save
+ *    > AutoSave. That is a PREFERENCE, expressed inside whatever the host allows.
+ *
+ * A preference can never exceed a policy, so:
+ *
+ *  - `autosave={false}` turns recovery autosave OFF and takes the toggle away
+ *    (`toggleAvailable: false`). A user cannot switch on what the application
+ *    forbade, and a switch that silently does nothing is worse than no switch.
+ *  - `autosave={true}`, or the prop omitted entirely, PERMITS autosave. The
+ *    user's toggle then decides, and it defaults to on.
+ *
+ * The prop is therefore only load-bearing when it is `false`. That is
+ * deliberate: crash recovery that is off by default is crash recovery nobody
+ * has, and the shared options schema already declares `save.autoSave: true` as
+ * the user default, so any other prop default would contradict it. Vue, Svelte
+ * and Vanilla previously defaulted to `false` and React and Angular to `true`;
+ * `true` is the answer, and the three that defaulted off now write recovery
+ * snapshots for hosts that never opted in. Pass `autosave={false}` to opt out.
+ *
+ * Two further gates are not negotiable by anyone, because without them there is
+ * nothing to write or nowhere to write it: editing must be possible at all, and
+ * a `filePath` must be set to key the IndexedDB record.
+ *
+ * ## Cadence follows the same rule
+ *
+ * An explicit `autosaveIntervalMs` prop is a policy and is honoured as given.
+ * Otherwise the cadence is the user's own File > Options > Save > "Save
+ * AutoRecover information every N minutes" (default two minutes), which React
+ * and Angular already respected and the other three ignored.
+ *
+ * ## What the two engine shapes must agree on
+ *
+ * React and Angular POLL on a fixed interval; Vue, Svelte and Vanilla DEBOUNCE
+ * on the edit. Both are legitimate, but a plain debounce has a failure mode a
+ * poll does not: a user who keeps editing keeps re-arming the timer, so it can
+ * defer a snapshot forever, and at the two-minute cadence that is an entire
+ * session of lost work. {@link nextAutosaveDelayMs} caps the debounce so both
+ * shapes make the same promise:
+ *
+ *   **a snapshot lands no later than one interval after the first unsaved edit,
+ *   and no more often than once per interval.**
+ *
+ * @module render/autosave-policy
+ */
+/**
+ * Why autosave is not running. `autosave_toggle_off` and `no_file_path` are the
+ * codes the title bar has always understood; the other two are new and fall
+ * back to the generic message in bindings that do not map them.
+ */
+type AutosaveDisabledReason = 'autosave_host_off' | 'autosave_toggle_off' | 'no_file_path' | 'read_only';
+interface AutosaveActivation {
+    /** Whether recovery snapshots should actually be written. */
+    readonly active: boolean;
+    /**
+     * Whether the user's AutoSave toggle can change anything. False only when
+     * the host passed `autosave={false}`; the toggle must then render off and
+     * inert rather than pretending to work.
+     */
+    readonly toggleAvailable: boolean;
+    /** Why it is inactive, for the title bar. `undefined` when active. */
+    readonly reason?: AutosaveDisabledReason;
+}
+
+/**
+ * @fileoverview "Is there a recoverable snapshot for this deck, and what should
+ * the prompt say?"
+ *
+ * Every binding writes crash-recovery snapshots into the shared IndexedDB store
+ * (`./autosave-store`). Until now only React ever looked for one again, and
+ * even it merely popped the Version History panel open, which never says the
+ * word "recover". In the other four the data was there and nothing surfaced it,
+ * so the feature was invisible: the user closed a crashed tab, reopened the
+ * deck, and silently got the pre-crash version back.
+ *
+ * The decision lives here as one pure function so all five ask the same
+ * questions in the same order, and each binding does nothing but render the
+ * descriptor as its own dialog.
+ *
+ * ## Why a "consumed" marker exists
+ *
+ * A host can restore the snapshot itself: `restoreSessionDeck` prefers a newer
+ * autosave snapshot over the bytes a tab was opened with, which is exactly what
+ * the demo apps do on reload. The viewer is then handed the snapshot's own
+ * bytes and must NOT turn round and offer to recover them, or every refresh
+ * mid-edit would raise a dialog about the content already on screen.
+ *
+ * Timestamps cannot settle that on their own: after a genuine crash the fresh
+ * load is also newer than the snapshot, so "the snapshot is older than this
+ * load" would suppress the one prompt that matters. Instead the consumer of a
+ * snapshot records it, per tab, in `sessionStorage`: surviving a reload (where
+ * the host already restored) but not a new tab (where a crash recovery is
+ * exactly what the user wants to be asked about).
+ *
+ * @module render/autosave-recovery
+ */
+
+/** Everything a binding needs to render the recovery dialog, and nothing else. */
+interface AutosaveRecoveryPrompt {
+    /** IndexedDB key the snapshot is stored under (the deck's file path/name). */
+    readonly filePath: string;
+    /** When the snapshot was written (epoch ms). */
+    readonly timestamp: number;
+    /** Snapshot size in bytes. */
+    readonly size: number;
+    /** Whole minutes since it was written, floored at 0. */
+    readonly ageMinutes: number;
+    readonly titleKey: string;
+    readonly messageKey: string;
+    /** `size` is pre-formatted here because byte units are not translated. */
+    readonly messageParams: {
+        readonly file: string;
+        readonly size: string;
+    };
+    /** Relative age, reusing the existing autosave age keys. */
+    readonly ageKey: string;
+    readonly ageParams: {
+        readonly count: number;
+    };
+    readonly restoreKey: string;
+    readonly discardKey: string;
+}
+
 type BackstagePage = 'home' | 'new' | 'open' | 'info' | 'save' | 'saveAs' | 'print' | 'share' | 'export' | 'close' | 'account' | 'options';
 interface BackstageRecentFile {
     key: string;
@@ -5587,6 +6111,92 @@ interface VirtualizedRange {
 /** Score a presentation password from 0 (very weak) to 4 (very strong). */
 declare function getPasswordStrength(password: string): number;
 
+/**
+ * deck-save-encryption: the single place that decides whether a deck save
+ * produces a plain OOXML ZIP or an encrypted OLE/CFB container.
+ *
+ * "Encrypt with Password" (File > Info > Protect Presentation) captures a
+ * secret in every binding. Whether that secret reaches the serialiser used to
+ * be re-decided per binding, and four of the five never decided it at all:
+ * they stored the password, showed a "protected" badge, and wrote a plaintext
+ * `.pptx`. That is a security-facing lie, so the decision now lives here as a
+ * pure function and every binding routes its save through
+ * {@link saveDeckWithPassword}.
+ *
+ * The rule is deliberately trivial: a non-empty password means
+ * `PptxHandler.saveEncrypted` (ECMA-376 agile encryption inside an OLE2
+ * compound file with `EncryptionInfo` + `EncryptedPackage` streams), anything
+ * else means `PptxHandler.save` (a `PK\x03\x04` ZIP). What matters is that it
+ * is decided ONCE.
+ *
+ * The one exception is the save PURPOSE (see {@link DeckSavePurpose}): bytes the
+ * viewer writes only so it can read them back itself - the crash-recovery
+ * autosave snapshot, and the re-serialise-then-reload cycle behind "apply
+ * theme" - are never encrypted, because nothing on the way back in has a
+ * password to offer.
+ */
+
+/**
+ * Why the deck is being serialised, which is a separate question from whether
+ * the user protected it.
+ *
+ * - `user-file` (the default): the bytes leave the viewer as a file. Save,
+ *   Save As, Export, the host-facing `getContent()`. Protection applies.
+ * - `recovery-snapshot`: the bytes exist only so the viewer can read them back.
+ *   The autosave crash-recovery snapshot in IndexedDB, and the internal
+ *   re-serialise-then-reload cycle behind "apply theme". Protection does NOT
+ *   apply: these are always written in the clear.
+ *
+ * ## Why a recovery snapshot must stay plaintext
+ *
+ * Nothing that reads a snapshot back has a password to give it.
+ * `readBackstageRecentFile`, `restoreSessionDeck` and the Version History
+ * panel's Restore all hand `record.data` straight to `PptxHandler.load()` with
+ * no `password` option, and an encrypted package refuses to open without one
+ * (`EncryptedFileError`). So an encrypted snapshot is not an inconvenience, it
+ * is unreadable: the moment the user turns on protection their crash-recovery
+ * data is silently destroyed, which is the exact opposite of what autosave is
+ * for.
+ *
+ * Encrypting it "properly" is not available either. Decrypting on recovery
+ * means the key has to outlive the crash the snapshot exists for, so it would
+ * have to sit in the same IndexedDB / localStorage as the snapshot itself,
+ * next to the ciphertext it unlocks. That is not a security boundary, it is
+ * theatre. Prompting the user instead only works if they remember the password
+ * of a deck they lost, which is precisely the moment they will not.
+ *
+ * ## The tradeoff this accepts (deliberately, not by omission)
+ *
+ * A password-protected deck DOES leave its content in cleartext at rest in the
+ * origin's IndexedDB. Anyone with the browser profile, or any script running on
+ * the origin, can read it. What limits the exposure: snapshots are scoped to
+ * the origin and profile, aged out by the store, and clearable from
+ * File > Account > Storage & Privacy (`clearLocalStorageData`). A user who
+ * cannot accept plaintext at rest should switch AutoSave off, which stops the
+ * snapshot being written at all.
+ *
+ * The rejected alternative was "skip autosave entirely while a password is
+ * set". It removes the plaintext, but it also removes crash recovery without
+ * telling anyone, so a crash loses the whole editing session. Losing data
+ * quietly is the failure mode we are fixing, not a fix for it.
+ */
+type DeckSavePurpose = 'user-file' | 'recovery-snapshot';
+/**
+ * What the Protect-Presentation UI knows at save time. `password` is the secret
+ * the dialog captured; `passwordProtected` is the separate "is protected" flag
+ * some bindings track for the badge. When the flag is explicitly `false` the
+ * deck saves in the clear even if a stale secret is still around, so removing
+ * a password can never leave the next save encrypted.
+ *
+ * `purpose` defaults to `'user-file'`; see {@link DeckSavePurpose} for why
+ * `'recovery-snapshot'` overrides the password.
+ */
+interface DeckSaveIntent {
+    password?: string | null;
+    passwordProtected?: boolean;
+    purpose?: DeckSavePurpose;
+}
+
 /** Framework-neutral viewer preferences surfaced by Settings dialogs. */
 interface ViewerPreferences {
     autoSave: boolean;
@@ -5603,6 +6213,15 @@ interface ShortcutReferenceItem {
 }
 declare const SHORTCUT_REFERENCE_ITEMS: readonly ShortcutReferenceItem[];
 
+/**
+ * An active custom show's membership. Accepts either key the bindings carry:
+ * `slideRIds` (core's parsed `p:custShow`) or `slideIds`.
+ */
+interface ShowOrderCustomShow {
+    readonly slideRIds?: readonly string[];
+    readonly slideIds?: readonly string[];
+}
+
 /** Everything a binding needs to mark one tile. Inert when the slide is visible. */
 interface HiddenSlideCue {
     /** Whether the slide is hidden, for `v-if` / `@if` / `{#if}` gating. */
@@ -5747,6 +6366,15 @@ interface ViewerGeneralOptions {
     userName: string;
     userInitials: string;
     showStartScreen: boolean;
+    /**
+     * Lets the user hand a local font file to the viewer so decks authored
+     * with a font the browser lacks render with the real face.
+     *
+     * Off by default. The registration reads a file the user picks and adds it
+     * to the page's font set for the session, which is a capability a host
+     * embedding the viewer should opt into rather than inherit.
+     */
+    enableCustomFontUpload: boolean;
 }
 interface ViewerProofingOptions {
     autoCorrectTwoInitialCapitals: boolean;
@@ -5763,13 +6391,25 @@ interface ViewerProofingOptions {
     checkSpellingAsYouType: boolean;
     hideSpellingErrors: boolean;
 }
+/**
+ * File > Options > Save.
+ *
+ * Font embedding deliberately has NO entry here. It is owned by the File >
+ * Fonts panel, whose toggle is the one the save path reads (see
+ * `render/font-embedding`: `describeFontEmbedding` decides the toggle's start
+ * position and whether it can do anything at all, `embeddedFontSaveOptions`
+ * turns it into the `PptxHandler.save()` slice). This group used to carry a
+ * second `embedFonts` boolean, plus an `embedAllFontCharacters` companion, and
+ * neither was read by anything: the pane moved a switch that changed no saved
+ * byte, while the panel next door moved the real one. Two switches for one
+ * setting, one of them lying, is worse than one switch in a less
+ * PowerPoint-shaped place.
+ */
 interface ViewerSaveOptions {
     autoSave: boolean;
     autoRecoverIntervalMinutes: number;
     keepLastAutoRecoveredVersion: boolean;
     defaultExportFormat: DefaultExportFormat;
-    embedFonts: boolean;
-    embedAllFontCharacters: boolean;
     cacheRetentionDays: number;
     clearCacheOnClose: boolean;
 }
@@ -6007,7 +6647,7 @@ interface ViewerOptionsSection {
     /** Optional explanatory paragraph under the section title. */
     descriptionKey?: string;
     /** Marks a bespoke block a binding renders itself (e.g. the theme picker). */
-    special?: 'themePicker' | 'clearCache' | 'shortcutReference';
+    special?: 'themePicker' | 'clearCache' | 'shortcutReference' | 'customFonts';
     controls: readonly ViewerOptionsControl[];
 }
 interface ViewerOptionsTabDefinition {
@@ -6926,6 +7566,43 @@ declare class AiPanelStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<AiPanelStore>;
 }
 
+/** Live host accessors the recovery probe reads (all reactive). */
+interface AutosaveRecoveryHost {
+    /** IndexedDB key of the open deck. Nothing to look up without one. */
+    readonly filePath: () => string | undefined;
+    /** True while the load pipeline is running. */
+    readonly loading: () => boolean;
+    /** Load error, if any. */
+    readonly error: () => string | null | undefined;
+    /** Slides currently rendered. */
+    readonly slideCount: () => number;
+    /**
+     * Whether the host permits autosave at all (`autosave` input not `false`). A
+     * user who merely switched the toggle off is still offered a pre-crash
+     * snapshot; a host that forbade the feature is not.
+     */
+    readonly autosaveAllowed: () => boolean;
+    /** Load the recovered bytes into the viewer. */
+    readonly restore: (bytes: Uint8Array) => void;
+}
+declare class AutosaveRecoveryService {
+    private readonly injector;
+    private readonly destroyRef;
+    /** What the dialog should say, or null when there is nothing to offer. */
+    readonly prompt: _angular_core.WritableSignal<AutosaveRecoveryPrompt | null>;
+    private host;
+    private record;
+    private checked;
+    private destroyed;
+    bind(host: AutosaveRecoveryHost): void;
+    /** The user accepted: load the snapshot bytes. */
+    restore(): void;
+    /** The user declined: drop the snapshot. */
+    discard(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutosaveRecoveryService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AutosaveRecoveryService>;
+}
+
 /** Lifecycle status of the autosave engine (mirrors React's `AutosaveStatus`). */
 type AutosaveStatus = {
     state: 'idle';
@@ -6943,7 +7620,11 @@ type AutosaveStatus = {
 };
 /** Live host accessors the autosave engine reads (all reactive). */
 interface AutosaveHost {
-    /** Whether autosave is enabled (the title-bar AutoSave toggle). */
+    /**
+     * Whether autosave actually runs: the shared `resolveAutosaveActivation`
+     * verdict (the host's `autosave` input as a ceiling, the title-bar toggle as
+     * the user preference inside it), not the raw toggle.
+     */
     readonly enabled: () => boolean;
     /** File path/name keying the recovery snapshot. Autosave is inert when unset. */
     readonly filePath: () => string | undefined;
@@ -6951,8 +7632,28 @@ interface AutosaveHost {
     readonly isDirty: () => boolean;
     /** Serialise the current edited deck to `.pptx` bytes (null skips the write). */
     readonly serialize: () => Promise<Uint8Array | null>;
-    /** Autosave interval in seconds (defaults to {@link AUTOSAVE_DEFAULT_INTERVAL_SECONDS}). */
-    readonly intervalSeconds?: () => number;
+    /**
+     * The resolved cadence in milliseconds (shared `resolveAutosaveIntervalMs`:
+     * host `autosaveIntervalMs` input > File > Options > Save AutoRecover
+     * cadence > 120s default).
+     */
+    readonly intervalMs?: () => number;
+    /**
+     * Why autosave is inactive, straight from the shared activation verdict, so
+     * the title bar names the condition the user would have to change first
+     * instead of always blaming the toggle.
+     */
+    readonly disabledReason?: () => AutosaveDisabledReason | undefined;
+    /**
+     * The values a snapshot is built from, read fresh on each tick.
+     *
+     * The dirty flag stays true from the first edit until the user performs a
+     * real save, so on its own it made this timer re-serialize and rewrite an
+     * identical deck every N seconds forever. Vue, Svelte and Vanilla never had
+     * that problem because they debounce on the slides signal being reassigned;
+     * this is the same trigger. Omit it and every tick writes, as before.
+     */
+    readonly changeSources?: () => readonly unknown[];
 }
 declare class AutosaveService {
     private readonly injector;
@@ -6963,6 +7664,7 @@ declare class AutosaveService {
     private host;
     private timer;
     private saving;
+    private lastSnapshot;
     /**
      * Wire the host accessors (called once from the component constructor). An
      * effect re-establishes the interval whenever `enabled`, `filePath`, or the
@@ -6971,6 +7673,11 @@ declare class AutosaveService {
     bind(host: AutosaveHost): void;
     /** Manually trigger an autosave right now (mirrors React's `triggerAutosave`). */
     triggerAutosave(): Promise<void>;
+    /**
+     * `polled` marks the interval tick, which may be skipped as redundant. An
+     * explicit {@link triggerAutosave} is a request, not a poll, and always
+     * writes.
+     */
     private doAutosave;
     private clearTimer;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutosaveService, never>;
@@ -7142,6 +7849,11 @@ declare function buildSaveSlides(slides: readonly PptxSlide[], templateElementsB
  * - Normal slide elements: follow `baseInteractive` unchanged.
  * - Template (master/layout) elements: interactive only when `baseInteractive`
  *   is set AND `editTemplateMode` is on.
+ * - An element whose authored `a:spLocks/@noSelect` is set is NEVER interactive:
+ *   PowerPoint treats a no-select shape as part of the backdrop, so it must not
+ *   answer a click hit-test nor be swept up by a marquee. Routing that through
+ *   the shared {@link canInteractWithElement} keeps the composition rule
+ *   (`noSelect` subsumes every other lock) in one place for all five bindings.
  */
 declare function isElementInteractive(element: PptxElement, baseInteractive: boolean, editTemplateMode: boolean): boolean;
 /**
@@ -7379,6 +8091,44 @@ declare class EditorStateService {
         height?: number;
         rotation?: number;
     }): void;
+    /**
+     * Recompute the endpoints of every connector bound to one of `movedIds` and
+     * write them back, WITHOUT recording history.
+     *
+     * Called at the end of a drag/resize gesture, whose single history snapshot
+     * was already taken by {@link beginTransform}; routing this through `commit()`
+     * instead would push a second, spurious undo step so undoing a move would
+     * take two presses. Both shared helpers no-op on empty input, and
+     * `applyReroutedConnectors` returns the same array reference when there is
+     * nothing to apply, so calling this unconditionally at every gesture end is
+     * free.
+     */
+    rerouteConnectors(slideIndex: number, movedIds: Iterable<string>): void;
+    /**
+     * Set one `a:avLst` adjustment guide on an element during a live
+     * shape-adjustment drag. Non-history for the same reason as
+     * {@link applyTransform}: the gesture's snapshot was taken at its start.
+     *
+     * Merges into any existing `shapeAdjustments` rather than replacing the map,
+     * so a multi-parameter geometry does not lose its other guides to a drag of
+     * one handle.
+     */
+    applyShapeAdjustment(slideIndex: number, id: string, key: string, value: number): void;
+    /**
+     * Merge a whole `a:avLst` patch. A callout's single diamond drives two
+     * guides, so the drag emits a MAP rather than one key/value pair.
+     */
+    applyShapeAdjustments(slideIndex: number, id: string, adjustments: Record<string, number>): void;
+    /**
+     * Commit a connector whose endpoint was re-bound (or unbound) on canvas.
+     *
+     * The WHOLE element is written, not a patch: a DETACHED end has had its
+     * `a:stCxn` / `a:endCxn` key deleted, and merging only the surviving keys
+     * would leave the stale binding behind and the connector would keep chasing
+     * a shape it no longer touches. Takes a history entry, because unlike the
+     * live drag branches this fires once, on release.
+     */
+    applyConnectorEndpoint(slideIndex: number, id: string, element: PptxElement): void;
     undo(): void;
     redo(): void;
     /** Align the selected elements within their group bounds (one history entry). */
@@ -7586,6 +8336,33 @@ declare class LoadContentService {
     readonly parsedData: _angular_core.WritableSignal<PptxData | undefined>;
     /** Slide canvas size in pixels. */
     readonly canvasSize: _angular_core.WritableSignal<CanvasSize>;
+    /**
+     * `p:sldSz` in EMU, seeded from the loaded deck and rewritten by the SLIDE
+     * SIZE card's preset/orientation controls.
+     *
+     * It is deliberately NOT derived from {@link canvasSize}: the pixel size is
+     * an integer, and Ledger (12179300 EMU = 1278.5px) loses its
+     * `ppSlideSizeLedgerPaper` identity the moment it round-trips through one.
+     * The shared `resolveSlideSizeSelection` decides which of the two wins; see
+     * {@link slideSizeSelection}.
+     */
+    readonly slideSizeEmu: _angular_core.WritableSignal<SlideSizeEmu | undefined>;
+    /**
+     * The deck's custom shows (`p:custShow`), in the package's own key space
+     * (`slideRIds` are RELATIONSHIP ids). Seeded on load and carried through
+     * {@link saveSlides}; {@link ViewerCustomShowsService} is the editing surface
+     * over it. Angular used to start this list empty and never write it back, so
+     * the dialog opened blank on a deck with shows and lost anything created in
+     * it.
+     */
+    readonly customShows: _angular_core.WritableSignal<PptxCustomShow[]>;
+    /**
+     * The shared Slide Size decision for the deck as it stands: the EMU size a
+     * save must persist, the preset it matches (if any), its orientation and the
+     * canvas size the stage should use. Read by the SLIDE SIZE inspector card and
+     * by {@link saveSlides}.
+     */
+    readonly slideSizeSelection: _angular_core.Signal<SlideSizeSelectionDescriptor>;
     /** Resolved presentation theme. */
     readonly theme: _angular_core.WritableSignal<PptxTheme | undefined>;
     /** Resolved colour map for the presentation theme (scheme key → hex). */
@@ -7606,6 +8383,24 @@ declare class LoadContentService {
     readonly mediaDataUrls: _angular_core.WritableSignal<Map<string, string>>;
     /** Embedded font data (name + binary) extracted from the presentation. */
     readonly embeddedFonts: _angular_core.WritableSignal<PptxEmbeddedFont[]>;
+    /**
+     * Shared decision behind File > Fonts > "Embed fonts in the file": whether
+     * the toggle accepts input at all, and which position describes the deck
+     * that is loaded. Surfaced by {@link ViewerDialogsService} to the panel.
+     */
+    readonly fontEmbedding: _angular_core.Signal<FontEmbeddingDescriptor>;
+    /**
+     * The toggle's live position, read by {@link saveSlides}. `false` strips
+     * `p:embeddedFontLst`, the `/font` relationships and the `.fntdata` parts;
+     * `true` keeps whatever the deck arrived with (core's default).
+     *
+     * It lives here, next to the fonts it decides the fate of, rather than in
+     * the dialogs service, so the value save reads is seeded by the LOAD and
+     * cannot depend on whether the Fonts panel was ever rendered. Seeded in
+     * {@link load}; the initial `true` covers "no deck yet", where there is
+     * nothing to strip.
+     */
+    readonly embedFonts: _angular_core.WritableSignal<boolean>;
     /** Core document properties from `docProps/core.xml`. */
     readonly coreProperties: _angular_core.WritableSignal<PptxCoreProperties | undefined>;
     /** Extended application properties from `docProps/app.xml`. */
@@ -7643,8 +8438,13 @@ declare class LoadContentService {
     private renderToken;
     private activeBlobUrls;
     constructor();
-    /** Serialise the current (loaded) presentation back to `.pptx` bytes. */
-    getContent(): Promise<Uint8Array>;
+    /**
+     * Serialise the current (loaded) presentation back to `.pptx` bytes.
+     *
+     * `password` carries the File > Info > Protect Presentation state; when set
+     * the bytes are an encrypted OLE2 container rather than a plain ZIP.
+     */
+    getContent(password?: DeckSaveIntent | string | null): Promise<Uint8Array>;
     /**
      * The loaded presentation's core handler, or `undefined` before a deck is
      * loaded. Exposed for the AI bridge ({@link PptxAiBridge.getHandler}) so the
@@ -7660,7 +8460,7 @@ declare class LoadContentService {
      * survive the save, mirroring React's `useSerialize` save options; core's
      * `PptxDocumentPropertiesUpdater` writes them back into the package.
      */
-    saveSlides(slides: readonly PptxSlide[], outputFormat?: PptxSaveFormat, sections?: readonly PptxSection[]): Promise<Uint8Array>;
+    saveSlides(slides: readonly PptxSlide[], outputFormat?: PptxSaveFormat, sections?: readonly PptxSection[], password?: DeckSaveIntent | string | null): Promise<Uint8Array>;
     /** Parse the supplied `.pptx` bytes into the reactive signals. */
     load(raw: Uint8Array | ArrayBuffer | null | undefined): Promise<void>;
     /**
@@ -8098,6 +8898,13 @@ declare function getImageSrc(el: PptxElement, mediaDataUrls: Map<string, string>
  * with plain vitest without TestBed or the Angular compiler.
  */
 
+/**
+ * Convert a shared `TableCellCss` object (camelCase keys, e.g. from
+ * `cellStyleToCss` or `getTableCellBandStyle`) into an `[ngStyle]`-compatible
+ * kebab-case {@link StyleMap}. Values are stringified so numbers (e.g.
+ * `fontWeight: 700`) apply correctly.
+ */
+declare function cssObjectToStyleMap(css: Record<string, string | number>): StyleMap;
 /** A single styled text run inside a cell paragraph. */
 interface CellTextRun {
     text: string;
@@ -8107,11 +8914,24 @@ interface CellTextRun {
 /** A single paragraph inside a table cell, made up of one or more `CellTextRun`s. */
 type CellParagraph = CellTextRun[];
 /**
- * Convert a `PptxTableCellStyle` object to an `[ngStyle]`-compatible map.
+ * Convert a `PptxTableCellStyle` to an `[ngStyle]`-compatible map.
  *
- * Viewer-first subset: fill (solid + gradient via prebuilt CSS string),
- * text styling, per-edge borders, cell margins, vertical alignment, and
- * vertical text direction. Mirrors `cellStyleToCss` in table-render-helpers.ts.
+ * A thin adapter over the shared `cellStyleToCss`, which React, Vue, Svelte
+ * and Vanilla all render tables from; only the key spelling (kebab-case, for
+ * this binding's `StyleMap`) differs, so nothing but the conversion lives
+ * here.
+ *
+ * This used to be a hand-ported copy of that function, and the copy had
+ * silently lost four of its features: preset PATTERN fills (a hatched cell
+ * painted a flat colour instead of the tile), `a:tcPr/@anchorCtr`
+ * block-centring, `a:tcPr/@horzOverflow="clip"`, and the `a:cell3D` bevel.
+ * All four render in the other four bindings and now render here too.
+ *
+ * One deliberate behaviour change comes with the swap: shared treats a ZERO
+ * cell margin as "nothing authored" (`if (style.marginLeft)`) where the copy
+ * tested `!== undefined`, so a cell authored `marL="0"` now keeps the
+ * renderer's default 4px padding instead of collapsing to 0. That is what the
+ * other four bindings already did.
  */
 declare function cellStyleToStyleMap(style: PptxTableCellStyle | undefined): StyleMap;
 /** Compute the `[ngStyle]` map for a `<col>` from its width fraction (0-1). */
@@ -8131,10 +8951,17 @@ declare function cellRunStyle(style: PptxTableCellStyle | undefined): StyleMap;
 /**
  * Build a list of `CellParagraph` arrays from a `PptxTableCell`.
  *
- * Splits `cell.text` on `\n` (the parser joins paragraphs with newlines) so each
- * paragraph becomes one styled run. Returns an empty array when the cell is
- * completely empty AND unstyled, signalling the template to fall back to the
- * non-breaking-space placeholder (which keeps the row height).
+ * Prefers `cell.textRuns`, the per-run model core parses out of the cell's
+ * `a:txBody`: a cell reading "Revenue **grew 42%**" is two runs with different
+ * weight, size, colour and typeface, and `cell.text` + the single cell-level
+ * `cell.style` cannot express that. Paragraph markers close the current
+ * paragraph; line-break markers become a `<br>` inside it.
+ *
+ * Falls back to splitting the flat `cell.text` on `\n` for cells the parser
+ * produced no runs for (an empty cell, or a programmatically built table).
+ * Returns an empty array when the cell is completely empty AND unstyled,
+ * signalling the template to fall back to the non-breaking-space placeholder
+ * (which keeps the row height).
  */
 declare function buildCellParagraphs(cell: PptxTableCell): CellParagraph[];
 
@@ -8152,13 +8979,6 @@ declare function buildCellParagraphs(cell: PptxTableCell): CellParagraph[];
  *   - packages/react/src/viewer/utils/table-diagonal-borders.tsx (diagonals)
  */
 
-/**
- * Convert a shared `TableCellCss` object (camelCase keys, e.g. from
- * {@link getTableCellBandStyle}) into an `[ngStyle]`-compatible kebab-case
- * {@link StyleMap}. Values are stringified so numbers (e.g. `fontWeight: 700`)
- * apply correctly.
- */
-declare function cssObjectToStyleMap(css: Record<string, string | number>): StyleMap;
 /** A flattened cell descriptor ready for template iteration. */
 interface TableCellViewModel {
     cell: PptxTableCell;
@@ -8246,6 +9066,12 @@ declare class TableRendererComponent {
     private readonly editingCell;
     /** The mounted `<input>` for the active cell edit, if any. */
     private readonly cellInput;
+    /**
+     * `<table>`-level style beyond the font stack: `a:tblPr@rtl` mirrors the
+     * column order for right-to-left decks. Decided in shared so all five
+     * bindings honour the flag identically.
+     */
+    readonly tableRootStyle: _angular_core.Signal<StyleMap>;
     /** Pre-computed `<col>` styles for the colgroup. */
     readonly colStyles: _angular_core.Signal<StyleMap[]>;
     /**
@@ -8364,12 +9190,19 @@ declare class ViewerCanvasEditingService {
     onToggleElementHidden(id: string): void;
     /**
      * Commit a selection-pane inline rename through the history-integrated
-     * update path. `name: undefined` clears the authored name (round-trips as a
-     * dropped `cNvPr/@name` on save).
+     * update path.
+     *
+     * The name is never `undefined`. The save writer reads `undefined` as "the
+     * model has no opinion" and skips `cNvPr/@name` entirely, which is what
+     * stops a plain round-trip from wiping the names of chart / SmartArt /
+     * graphic frames that parse without one - and which also meant a cleared
+     * box did nothing at all. `@name` is required on
+     * `CT_NonVisualDrawingProps`, so it is never dropped; a clear arrives here
+     * as `''` and is written as `name=""`.
      */
     onSelectionPaneRename(event: {
         id: string;
-        name: string | undefined;
+        name: string;
     }): void;
     /**
      * Commit a table cell's inline text edit. Finds the table element on the
@@ -8520,8 +9353,6 @@ declare class ViewerCustomShowsService {
     private readonly loader;
     /** Whether the custom-shows dialog is open. */
     readonly showDialog: _angular_core.WritableSignal<boolean>;
-    /** The list of user-defined custom shows for this session. */
-    readonly shows: _angular_core.WritableSignal<readonly CustomShow[]>;
     /** The id of the currently active custom show, or null. */
     readonly activeId: _angular_core.WritableSignal<string | null>;
     /** Active-slide index of the host viewer (bound from the component). */
@@ -8539,12 +9370,51 @@ declare class ViewerCustomShowsService {
         activeSlideIndex: () => number;
         liveSlides: () => readonly PptxSlide[];
     }): void;
-    /** Custom shows mapped to the core shape consumed by set-up-slide-show. */
+    /** The deck's shows in the dialog's key space (slide ids, not relationship ids). */
+    readonly shows: _angular_core.Signal<readonly CustomShow[]>;
+    /** Custom shows in the core shape consumed by set-up-slide-show and by save. */
     readonly pptxCustomShows: _angular_core.Signal<PptxCustomShow[]>;
-    /** Slides shown in presentation mode: the active custom show, else the full (live) deck. */
+    /**
+     * The running show's membership for the shared show-order rule, or `null`
+     * when the whole deck is playing.
+     */
+    readonly activeCustomShow: _angular_core.Signal<ShowOrderCustomShow | null>;
+    /**
+     * Slides handed to the presentation overlay: always the whole (live) deck.
+     * The custom-show subset is applied by the shared show-order rule, which the
+     * overlay runs against {@link activeCustomShow}.
+     */
     readonly presentationSlides: _angular_core.Signal<PptxSlide[]>;
-    /** Start index into {@link presentationSlides}: first slide of a custom show, else the active slide. */
+    /**
+     * Start index into {@link presentationSlides}: always the editor's active
+     * slide, which the show itself keeps up to date through `indexChange`.
+     *
+     * It must NOT be pinned to the custom show's first slide. `startIndex` is a
+     * live input, not a constructor argument: the overlay re-adopts it whenever
+     * it changes, and an audience display mirrors the presenter through it. While
+     * this returned the show's first slide it never changed, so the overlay's
+     * "adopt a host-pushed index" effect - which re-runs on the overlay's OWN
+     * index too - snapped every advance straight back to slide 1, and Angular
+     * alone could not leave the first slide of a custom show.
+     *
+     * Where a custom show STARTS is a one-shot seed instead, taken as the show
+     * opens; see {@link showEntryIndex}.
+     */
     readonly presentationStartIndex: _angular_core.Signal<number>;
+    /**
+     * The slide a show should OPEN on: the first slide the active custom show
+     * visits, else the active slide. Read once, when the show starts.
+     */
+    showEntryIndex(): number;
+    /**
+     * Adopt the loaded deck's authored show selection.
+     *
+     * `p:showPr/p:custShow/@id` is PowerPoint's "Set Up Slide Show > Custom show"
+     * radio, and it is authored intent. Every binding parsed it and then played
+     * the whole deck anyway. Called once per load; a manual pick made afterwards
+     * simply overwrites {@link activeId} and wins until the next deck arrives.
+     */
+    seedFromDeck(): void;
     onCreate(show: {
         name: string;
         slideIds: string[];
@@ -8555,11 +9425,8 @@ declare class ViewerCustomShowsService {
         name: string;
         slideIds: string[];
     }): void;
-    /**
-     * The active custom show's slides, in its defined order, or null when no show
-     * is active (or it resolves to nothing). Used to filter the presentation.
-     */
-    private resolveActiveShowSlides;
+    /** Write an edited list back into the deck's key space (relationship ids). */
+    private commit;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ViewerCustomShowsService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ViewerCustomShowsService>;
 }
@@ -8589,8 +9456,29 @@ declare class ViewerDialogsService {
     readonly compareResult: _angular_core.WritableSignal<CompareResult | null>;
     /** Font-embedding panel visibility. */
     readonly showFontEmbedding: _angular_core.WritableSignal<boolean>;
-    /** Whether embedding used fonts on save is enabled. */
+    /**
+     * The deck this viewer loaded, when one is provided alongside this service
+     * (it always is on the viewer host). Optional so the isolated service tests
+     * and stubbed injectors keep working.
+     */
+    private readonly loader;
+    /**
+     * Whether the save keeps the deck's embedded font data.
+     *
+     * Deliberately the loader's OWN signal rather than a copy: the flag is read
+     * by `LoadContentService.saveSlides`, and it is seeded there from the loaded
+     * deck, so a second source of truth here would let the panel and the save
+     * path disagree. Previously this was a standalone `signal(false)` that
+     * nothing ever read; wiring THAT to save would have stripped the embedded
+     * fonts of every deck that had them.
+     */
     readonly embedFontsEnabled: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the toggle accepts input, plus the reason when it does not: the
+     * viewer can keep or strip embedded font data, but cannot manufacture it for
+     * a deck that embeds nothing.
+     */
+    readonly fontEmbedding: _angular_core.Signal<FontEmbeddingDescriptor>;
     /** Version-history side panel visibility. */
     readonly showVersionHistory: _angular_core.WritableSignal<boolean>;
     /** Keyboard-shortcuts help overlay visibility. */
@@ -8719,6 +9607,12 @@ interface FileIOHost {
     readonly sections: () => readonly PptxSection[];
     readonly templateElementsBySlideId: () => TemplateElementsBySlideId;
     readonly emitContentChange: (bytes: Uint8Array) => void;
+    /**
+     * File > Info > Protect Presentation state. When it carries a password every
+     * save below serialises through `saveEncrypted`, so the downloaded file is an
+     * encrypted OLE2 container instead of a plain ZIP.
+     */
+    readonly saveIntent: () => DeckSaveIntent;
 }
 declare class ViewerFileIOService {
     private readonly loader;
@@ -9122,7 +10016,6 @@ interface PresentationModeHost {
     readonly applyRehearsalTimings: (timings: Record<number, number>) => void;
 }
 declare class ViewerPresentationModeService {
-    private readonly loader;
     private readonly presenterWindow;
     private readonly customShowsCtl;
     /** Fullscreen presentation-mode overlay visibility. */
@@ -9158,10 +10051,14 @@ declare class ViewerPresentationModeService {
     startRehearsalFromCurrent(): void;
     private startRehearsal;
     /**
-     * Map a presentation-overlay index back to the full-deck `activeSlideIndex`.
-     * The overlay's index is relative to the (possibly custom-show-filtered)
-     * presentation slides, so resolve by slide id to keep the editor selection
-     * correct when the show closes.
+     * Adopt a presentation-overlay index as the editor's `activeSlideIndex`.
+     *
+     * No remap is needed (and none may be done): the overlay is handed the WHOLE
+     * live deck and applies custom-show membership as a navigation rule, so its
+     * index is already a deck index. The id-lookup this used to perform existed
+     * only because Angular pre-filtered the slide array to the show's members,
+     * and it resolved against the PRISTINE loaded deck, so it mislanded whenever
+     * the session had inserted or deleted a slide.
      */
     onPresentationIndexChange(index: number): void;
     toggleRehearsalPause(): void;
@@ -9251,7 +10148,7 @@ declare class ViewerZoomService {
  *  - React theme context / Vue provide-inject → `themeStyle` CSS vars applied to
  *    the root element (app-wide sharing via `provideViewerTheme`).
  */
-declare class PowerPointViewerComponent {
+declare class PowerPointViewerComponent implements PowerPointViewerAPI {
     /** PowerPoint content as Uint8Array (or ArrayBuffer). */
     readonly content: _angular_core.InputSignal<ArrayBuffer | Uint8Array<ArrayBufferLike> | null>;
     /** Licensed fonts supplied by the host application. No fonts are bundled. */
@@ -9306,6 +10203,29 @@ declare class PowerPointViewerComponent {
      * Mirrors React's `fileName` prop.
      */
     readonly fileName: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Recovery autosave: after an edit the deck is re-serialised (always as a
+     * plain, unencrypted package, because recovery has no password) and stashed
+     * in the shared IndexedDB store keyed by {@link filePath}. It is a crash-
+     * safety net and never replaces the user's real Save: the document stays
+     * dirty. On load, a newer snapshot is offered back through a recovery prompt.
+     *
+     * **The input is a policy ceiling; the title-bar AutoSave toggle is the
+     * user's preference inside it.** `false` turns autosave off and makes the
+     * toggle inert (a user cannot switch on what the application forbade).
+     * `true` or omitted permits it, and the toggle decides, defaulting to on.
+     * Identical in all five bindings; see `resolveAutosaveActivation` in
+     * `pptx-viewer-shared`.
+     *
+     * @default true
+     */
+    readonly autosaveInput: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Recovery cadence in milliseconds. An explicit value is a host policy and is
+     * honoured as given; omit it to follow the user's File > Options > Save >
+     * "Save AutoRecover information every N minutes" (two minutes by default).
+     */
+    readonly autosaveIntervalMs: _angular_core.InputSignal<number | undefined>;
     /** Optional real-time collaboration config; when set, connects and shows remote cursors. */
     readonly collaboration: _angular_core.InputSignal<CollaborationConfig | undefined>;
     /**
@@ -9362,7 +10282,7 @@ declare class PowerPointViewerComponent {
     /** Fired when the user edits document properties in the Info dialog. */
     readonly propertiesChange: _angular_core.OutputEmitterRef<Partial<PptxCoreProperties>>;
     /** Fired when the viewer mode changes (preview, edit, present, master). */
-    readonly modeChange: _angular_core.OutputEmitterRef<string>;
+    readonly modeChange: _angular_core.OutputEmitterRef<ViewerMode>;
     /** Fired when the zoom level changes. */
     readonly zoomChange: _angular_core.OutputEmitterRef<number>;
     /** Fired when element selection changes. */
@@ -9383,6 +10303,7 @@ declare class PowerPointViewerComponent {
     protected readonly collab: CollaborationService;
     protected readonly accessibility: AccessibilityService;
     protected readonly autosave: AutosaveService;
+    protected readonly autosaveRecovery: AutosaveRecoveryService;
     protected readonly print: PrintService;
     protected readonly mobile: IsMobileService;
     private readonly smartArt3DSvc;
@@ -9471,6 +10392,11 @@ declare class PowerPointViewerComponent {
     protected readonly rootStyle: _angular_core.Signal<Record<string, string>>;
     /** Slide-sorter grid overlay visibility. */
     protected readonly showSorter: _angular_core.WritableSignal<boolean>;
+    /**
+     * Which face the theme gallery opens on: its preset grid, or the theme
+     * editor that Design > Edit Theme names. Set by the two Design commands.
+     */
+    protected readonly themeEditorRequested: _angular_core.WritableSignal<boolean>;
     /**
      * Reading View visibility: the deck at full window size with the editor
      * chrome cut back to a nav bar. Not the slide show (no fullscreen, no
@@ -9485,8 +10411,32 @@ declare class PowerPointViewerComponent {
     protected readonly activeLayoutIndex: _angular_core.WritableSignal<number | null>;
     /** Whether the left slides panel is collapsed (top-bar sidebar toggle). */
     protected readonly slidesPanelCollapsed: _angular_core.WritableSignal<boolean>;
-    /** Whether periodic autosave is enabled (title-bar AutoSave toggle; default on). */
+    /**
+     * Whether the editor chrome renders at all.
+     *
+     * A running slide show has no editing chrome, exactly as PowerPoint's does
+     * not: no ribbon, no title bar, no slide rail, no inspector, no notes pane
+     * and no status bar. The show overlay is `position: fixed`, so leaving them
+     * mounted LOOKS the same while keeping every one of those controls in the
+     * tab order and the accessibility tree underneath it - a screen-reader user
+     * would still be walked through the whole editor mid-presentation, and the
+     * "Slide Show" button would still be reachable during the show it starts.
+     * React, Svelte and Vanilla already suppress theirs; `e2e/present-mode.spec.ts`
+     * pins the rule for all five.
+     */
+    protected readonly chromeVisible: _angular_core.Signal<boolean>;
+    /**
+     * The user PREFERENCE (title-bar AutoSave toggle; default on). What actually
+     * runs is {@link autosaveActivation}, which folds in the host's `autosave`
+     * input as a ceiling the preference cannot exceed.
+     */
     protected readonly autosaveEnabled: _angular_core.WritableSignal<boolean>;
+    /** The shared verdict: does autosave run, may the toggle move, and if not why. */
+    protected readonly autosaveActivation: _angular_core.Signal<AutosaveActivation>;
+    /** The recovery offer, or null while a slide show is running. */
+    protected readonly visibleRecoveryPrompt: _angular_core.Signal<AutosaveRecoveryPrompt | null>;
+    /** Flip the AutoSave preference, unless the host forbade autosave outright. */
+    protected toggleAutosave(): void;
     /** Active drawing tool (from the ribbon Draw tab). */
     protected readonly activeDrawTool: _angular_core.WritableSignal<"select" | "pen" | "highlighter" | "eraser" | "freeform">;
     /** Active ink stroke colour. */
@@ -9558,11 +10508,37 @@ declare class PowerPointViewerComponent {
      * When editing, this serialises the editor's edited deck so changes persist.
      */
     getContent(): Promise<Uint8Array>;
+    /**
+     * Design > Browse Themes: toggle the gallery on its preset grid. Clearing
+     * the editor request matters when the theme editor was the last face shown.
+     */
+    protected onBrowseThemes(): void;
+    /**
+     * Design > Edit Theme: the real theme editor lives inside the gallery
+     * overlay, so open the gallery already switched to it (it used to open the
+     * Document Properties dialog, which has nothing to do with themes).
+     */
+    protected onEditTheme(): void;
+    /**
+     * Design > Slide Size: the size control is the inspector's SLIDE SIZE card,
+     * which the deck (no-selection) panel renders. Drop the element selection so
+     * that panel is what the format pane shows, then make sure it is open.
+     */
+    protected onOpenSlideSize(): void;
     protected openMasterView(): void;
     protected closeMasterView(): void;
     protected selectMasterTab(tab: MasterViewTab): void;
+    /**
+     * Format Background for whichever master-view part is selected.
+     *
+     * This used to be a hand-rolled tab/layout walk; the routing decision now
+     * lives in `pptx-viewer-shared` alongside the element write path, so the
+     * five bindings cannot disagree about which part a colour lands on.
+     */
     protected setMasterBackground(backgroundColor: string): void;
     protected setHandoutSlidesPerPage(slidesPerPage: number): void;
+    /** Shape-tree edits made on the Slide Master view's Slides tab. */
+    protected updateSlideMasters(masters: PptxSlideMaster[]): void;
     protected updateNotesMaster(master: PptxNotesMaster): void;
     protected updateHandoutMaster(master: PptxHandoutMaster): void;
     goTo(index: number): void;
@@ -9623,9 +10599,9 @@ declare class PowerPointViewerComponent {
     /** Reset zoom to 100%. */
     zoomReset(): void;
     /** Get the current viewer mode. */
-    getMode(): string;
+    getMode(): ViewerMode;
     /** Switch the viewer mode (e.g. 'edit', 'preview', 'present'). */
-    setMode(mode: string): void;
+    setMode(mode: ViewerMode): void;
     /** Get the zero-based active slide index. */
     getActiveSlideIndex(): number;
     /** Get the total number of slides. */
@@ -9711,6 +10687,12 @@ declare class PowerPointViewerComponent {
      * autosave engine skips the write. Distinct from {@link getContent}, this does
      * NOT emit `contentChange` (autosave is a background recovery write, not a
      * host-visible save).
+     *
+     * The `recoverySnapshotIntent` is load-bearing, not decoration: it keeps the
+     * snapshot a plain ZIP even when the deck is password protected, because
+     * recovery reopens it with no password. Angular used to get that right only
+     * by omitting the argument, which is one refactor away from silently writing
+     * an unrecoverable encrypted snapshot (the bug React and Vue shipped).
      */
     private serializeForAutosave;
     /** Review ▸ Compare: pick a `.pptx` and diff it against the current deck. */
@@ -9767,7 +10749,7 @@ declare class PowerPointViewerComponent {
     /** Resolve the live slide-stage element within `<main>`. */
     private stageElement;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PowerPointViewerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerPointViewerComponent, "pptx-viewer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "fontsInput": { "alias": "fonts"; "required": false; "isSignal": true; }; "canEditInput": { "alias": "canEdit"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "defaultThemeKey": { "alias": "defaultThemeKey"; "required": false; "isSignal": true; }; "availableThemes": { "alias": "availableThemes"; "required": false; "isSignal": true; }; "onThemeChange": { "alias": "onThemeChange"; "required": false; "isSignal": true; }; "defaultLocale": { "alias": "defaultLocale"; "required": false; "isSignal": true; }; "availableLocales": { "alias": "availableLocales"; "required": false; "isSignal": true; }; "onLocaleChange": { "alias": "onLocaleChange"; "required": false; "isSignal": true; }; "accountAuth": { "alias": "accountAuth"; "required": false; "isSignal": true; }; "filePath": { "alias": "filePath"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "collaboration": { "alias": "collaboration"; "required": false; "isSignal": true; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; "shareDefaults": { "alias": "shareDefaults"; "required": false; "isSignal": true; }; "onOpenFile": { "alias": "onOpenFile"; "required": false; "isSignal": true; }; "smartArt3D": { "alias": "smartArt3D"; "required": false; "isSignal": true; }; "hiddenActions": { "alias": "hiddenActions"; "required": false; "isSignal": true; }; "ai": { "alias": "ai"; "required": false; "isSignal": true; }; }, { "activeSlideChange": "activeSlideChange"; "dirtyChange": "dirtyChange"; "contentChange": "contentChange"; "propertiesChange": "propertiesChange"; "modeChange": "modeChange"; "zoomChange": "zoomChange"; "selectionChange": "selectionChange"; "slideCountChange": "slideCountChange"; "startCollaboration": "startCollaboration"; "stopCollaboration": "stopCollaboration"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerPointViewerComponent, "pptx-viewer", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "fontsInput": { "alias": "fonts"; "required": false; "isSignal": true; }; "canEditInput": { "alias": "canEdit"; "required": false; "isSignal": true; }; "class": { "alias": "class"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "defaultThemeKey": { "alias": "defaultThemeKey"; "required": false; "isSignal": true; }; "availableThemes": { "alias": "availableThemes"; "required": false; "isSignal": true; }; "onThemeChange": { "alias": "onThemeChange"; "required": false; "isSignal": true; }; "defaultLocale": { "alias": "defaultLocale"; "required": false; "isSignal": true; }; "availableLocales": { "alias": "availableLocales"; "required": false; "isSignal": true; }; "onLocaleChange": { "alias": "onLocaleChange"; "required": false; "isSignal": true; }; "accountAuth": { "alias": "accountAuth"; "required": false; "isSignal": true; }; "filePath": { "alias": "filePath"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "autosaveInput": { "alias": "autosave"; "required": false; "isSignal": true; }; "autosaveIntervalMs": { "alias": "autosaveIntervalMs"; "required": false; "isSignal": true; }; "collaboration": { "alias": "collaboration"; "required": false; "isSignal": true; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; "shareDefaults": { "alias": "shareDefaults"; "required": false; "isSignal": true; }; "onOpenFile": { "alias": "onOpenFile"; "required": false; "isSignal": true; }; "smartArt3D": { "alias": "smartArt3D"; "required": false; "isSignal": true; }; "hiddenActions": { "alias": "hiddenActions"; "required": false; "isSignal": true; }; "ai": { "alias": "ai"; "required": false; "isSignal": true; }; }, { "activeSlideChange": "activeSlideChange"; "dirtyChange": "dirtyChange"; "contentChange": "contentChange"; "propertiesChange": "propertiesChange"; "modeChange": "modeChange"; "zoomChange": "zoomChange"; "selectionChange": "selectionChange"; "slideCountChange": "slideCountChange"; "startCollaboration": "startCollaboration"; "stopCollaboration": "stopCollaboration"; }, never, never, true, never>;
 }
 
 /** A selected chart sub-part, scoped to the chart element that owns it. */
@@ -9788,6 +10770,28 @@ declare class ChartPartSelectionService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ChartPartSelectionService>;
 }
 
+/**
+ * Families the user registered from a local font file this session
+ * (File > Options > Fonts, off by default).
+ *
+ * A service rather than a chain of inputs because two unrelated parts of the
+ * UI need the same list: the Options pane that adds to it and the Home tab's
+ * font dropdown that offers it. It is also deliberately not persisted, so
+ * nothing survives a reload; the font binary is the user's, not ours to store.
+ *
+ * Provided per viewer instance (alongside the other viewer services), so two
+ * viewers on one page keep their own lists.
+ */
+declare class CustomFontsService {
+    private readonly families;
+    /** The registered families, in the order they were added. */
+    readonly registeredFamilies: _angular_core.Signal<readonly string[]>;
+    /** Record a newly registered family, ignoring one already present. */
+    register(family: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomFontsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CustomFontsService>;
+}
+
 declare class EmbeddedFontsService {
     /** The generated `@font-face` stylesheet text (also injected into `<head>`). */
     readonly fontFaceCss: _angular_core.WritableSignal<string>;
@@ -10017,6 +11021,13 @@ interface KeyboardHost {
     readonly canEdit: () => boolean;
     readonly presenting: () => boolean;
     readonly activeSlideIndex: () => number;
+    /**
+     * A Draw-tab tool other than the selection arrow is armed. The shared keymap
+     * stands its whole editing set down while one is, so a pen stroke is not also
+     * a Delete: every other binding passes this flag and Angular did not, which
+     * left Delete, Ctrl+D and the arrow nudges live over an armed pen.
+     */
+    readonly isDrawing?: () => boolean;
     /** Go back one slide (the arrows page the deck when nothing is selected). */
     readonly goPrev?: () => void;
     /** Go forward one slide. */
@@ -10026,10 +11037,21 @@ declare class ViewerKeyboardService {
     private readonly editor;
     private readonly dialogs;
     private readonly formatPainter;
+    private readonly findReplace;
     private host;
     /** Wire the host accessors (called once from the component constructor). */
     bind(host: KeyboardHost): void;
     handleKeyDown(event: KeyboardEvent): void;
+    /**
+     * Ctrl/Cmd+F toggles the find bar. Angular has shipped the bar since the
+     * find-replace port but had no shortcut for it at all, because the chord was
+     * hand-wired in React and Vue instead of living in the shared keymap.
+     *
+     * The full find-and-replace bar counts as "open" for the toggle: pressing the
+     * chord while it is up closes it rather than swapping it for the smaller find
+     * bar, which is what every other binding's single-panel toggle does.
+     */
+    private toggleFind;
     /**
      * Escape unwinds the transient chrome one layer at a time: an armed format
      * painter first (it is modal over the pointer), then the shortcut cheat
@@ -10138,7 +11160,7 @@ declare class ZoomTargetService {
  * `PowerPointViewerComponent`'s children (ribbon, slide canvas, inspector,
  * dialogs, ...) rely on via `inject()`.
  */
-declare const POWER_POINT_VIEWER_PROVIDERS: readonly [typeof LoadContentService, typeof ExportService, typeof EditorStateService, typeof ChartPartSelectionService, typeof TableSelectionService, typeof EmbeddedFontsService, typeof CollaborationService, typeof AccessibilityService, typeof AutosaveService, typeof PrintService, typeof IsMobileService, typeof SmartArt3DService, typeof FieldContextService, typeof ZoomTargetService, typeof AiPanelStore, typeof ViewerDialogsService, typeof ViewerCompareService, typeof ViewerExportService, typeof ViewerFindReplaceService, typeof ViewerCustomShowsService, typeof ViewerCollaborationSessionService, typeof ViewerCanvasEditingService, typeof ViewerCollabCursorService, typeof ViewerDocumentPropertiesService, typeof ViewerFileIOService, typeof ViewerFormatPainterService, typeof ViewerInspectorPanelService, typeof ViewerKeyboardService, typeof ViewerMobileSheetService, typeof ViewerOptionsService, typeof ViewerPresentationModeService, typeof ViewerThemeGalleryService, typeof ViewerTouchGesturesService, typeof ViewerZoomService];
+declare const POWER_POINT_VIEWER_PROVIDERS: readonly [typeof LoadContentService, typeof ExportService, typeof EditorStateService, typeof ChartPartSelectionService, typeof TableSelectionService, typeof EmbeddedFontsService, typeof CollaborationService, typeof CustomFontsService, typeof AccessibilityService, typeof AutosaveService, typeof AutosaveRecoveryService, typeof PrintService, typeof IsMobileService, typeof SmartArt3DService, typeof FieldContextService, typeof ZoomTargetService, typeof AiPanelStore, typeof ViewerDialogsService, typeof ViewerCompareService, typeof ViewerExportService, typeof ViewerFindReplaceService, typeof ViewerCustomShowsService, typeof ViewerCollaborationSessionService, typeof ViewerCanvasEditingService, typeof ViewerCollabCursorService, typeof ViewerDocumentPropertiesService, typeof ViewerFileIOService, typeof ViewerFormatPainterService, typeof ViewerInspectorPanelService, typeof ViewerKeyboardService, typeof ViewerMobileSheetService, typeof ViewerOptionsService, typeof ViewerPresentationModeService, typeof ViewerThemeGalleryService, typeof ViewerTouchGesturesService, typeof ViewerZoomService];
 
 /** Lifecycle of the AI session bootstrap. */
 type AiChatInitState = 'checking' | 'unavailable' | 'ready' | 'error';
@@ -10724,6 +11746,16 @@ declare class RibbonComponent {
     readonly drawToolChange: _angular_core.OutputEmitterRef<DrawToolState>;
     /** Emitted when the user clicks "Browse Themes" in the Design tab. */
     readonly toggleThemeGallery: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted when the user clicks "Edit Theme" in the Design tab. The host
+     * opens the theme gallery straight in its theme-editor (customise) mode.
+     */
+    readonly editTheme: _angular_core.OutputEmitterRef<void>;
+    /**
+     * Emitted when the user clicks "Slide Size" in the Design tab. The host
+     * surfaces the inspector's deck panel, which owns the slide-size card.
+     */
+    readonly openSlideSize: _angular_core.OutputEmitterRef<void>;
     /** Emitted when the user toggles the grid overlay in the View tab. */
     readonly toggleGrid: _angular_core.OutputEmitterRef<void>;
     /** Emitted when the user toggles rulers in the View tab. */
@@ -10773,7 +11805,7 @@ declare class RibbonComponent {
     /** Forward the Review proofing toggle to the viewer-owned live state. */
     protected setSpellCheck(enabled: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonComponent, "pptx-ribbon", never, { "slideIndex": { "alias": "slideIndex"; "required": false; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "selectedElement": { "alias": "selectedElement"; "required": false; "isSignal": true; }; "zoomPercent": { "alias": "zoomPercent"; "required": false; "isSignal": true; }; "formatPainterActive": { "alias": "formatPainterActive"; "required": false; "isSignal": true; }; "canActivateFormatPainter": { "alias": "canActivateFormatPainter"; "required": false; "isSignal": true; }; "exporting": { "alias": "exporting"; "required": false; "isSignal": true; }; "hasMacros": { "alias": "hasMacros"; "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; }; "snapToShape": { "alias": "snapToShape"; "required": false; "isSignal": true; }; "eyedropperActive": { "alias": "eyedropperActive"; "required": false; "isSignal": true; }; "themeGalleryOpen": { "alias": "themeGalleryOpen"; "required": false; "isSignal": true; }; "sidebarCollapsed": { "alias": "sidebarCollapsed"; "required": false; "isSignal": true; }; "inspectorOpen": { "alias": "inspectorOpen"; "required": false; "isSignal": true; }; "commentsOpen": { "alias": "commentsOpen"; "required": false; "isSignal": true; }; "commentCount": { "alias": "commentCount"; "required": false; "isSignal": true; }; "findOpen": { "alias": "findOpen"; "required": false; "isSignal": true; }; "collabConnected": { "alias": "collabConnected"; "required": false; "isSignal": true; }; "connectedCount": { "alias": "connectedCount"; "required": false; "isSignal": true; }; "spellCheckEnabled": { "alias": "spellCheckEnabled"; "required": false; "isSignal": true; }; "showSubtitles": { "alias": "showSubtitles"; "required": false; "isSignal": true; }; "hiddenActions": { "alias": "hiddenActions"; "required": false; "isSignal": true; }; "aiEnabled": { "alias": "aiEnabled"; "required": false; "isSignal": true; }; "aiPanelOpen": { "alias": "aiPanelOpen"; "required": false; "isSignal": true; }; "accountAuth": { "alias": "accountAuth"; "required": false; "isSignal": true; }; "activeSlideHidden": { "alias": "activeSlideHidden"; "required": false; "isSignal": true; }; }, { "prev": "prev"; "next": "next"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "zoomReset": "zoomReset"; "find": "find"; "present": "present"; "presenter": "presenter"; "record": "record"; "presentFromBeginning": "presentFromBeginning"; "rehearseTimings": "rehearseTimings"; "toggleSubtitles": "toggleSubtitles"; "openSubtitleSettings": "openSubtitleSettings"; "recordFromBeginning": "recordFromBeginning"; "recordFromCurrent": "recordFromCurrent"; "spellCheckChange": "spellCheckChange"; "share": "share"; "broadcast": "broadcast"; "openFile": "openFile"; "openRecentFile": "openRecentFile"; "createPresentation": "createPresentation"; "save": "save"; "savePpsx": "savePpsx"; "savePptm": "savePptm"; "packageForSharing": "packageForSharing"; "toggleSidebar": "toggleSidebar"; "toggleAiPanel": "toggleAiPanel"; "signatures": "signatures"; "info": "info"; "print": "print"; "comments": "comments"; "a11y": "a11y"; "link": "link"; "openSorter": "openSorter"; "openReadingView": "openReadingView"; "openOutlineView": "openOutlineView"; "openMasterView": "openMasterView"; "toggleNotes": "toggleNotes"; "toggleFormatPainter": "toggleFormatPainter"; "exportPng": "exportPng"; "exportPdf": "exportPdf"; "exportGif": "exportGif"; "exportVideo": "exportVideo"; "exportJson": "exportJson"; "copySlideAsImage": "copySlideAsImage"; "replace": "replace"; "toggleInspector": "toggleInspector"; "drawToolChange": "drawToolChange"; "toggleThemeGallery": "toggleThemeGallery"; "toggleGrid": "toggleGrid"; "toggleRulers": "toggleRulers"; "toggleGuides": "toggleGuides"; "toggleSelectionPane": "toggleSelectionPane"; "openCustomShows": "openCustomShows"; "toggleSnapToGrid": "toggleSnapToGrid"; "toggleSnapToShape": "toggleSnapToShape"; "addGuide": "addGuide"; "zoomToFit": "zoomToFit"; "toggleEyedropper": "toggleEyedropper"; "openSmartArtDialog": "openSmartArtDialog"; "openTemplateGallery": "openTemplateGallery"; "openEquationDialog": "openEquationDialog"; "openSetUpSlideShow": "openSetUpSlideShow"; "toggleHideSlide": "toggleHideSlide"; "openCompare": "openCompare"; "openPassword": "openPassword"; "openFontEmbedding": "openFontEmbedding"; "openVersionHistory": "openVersionHistory"; "openShortcuts": "openShortcuts"; "openSettings": "openSettings"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonComponent, "pptx-ribbon", never, { "slideIndex": { "alias": "slideIndex"; "required": false; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "selectedElement": { "alias": "selectedElement"; "required": false; "isSignal": true; }; "zoomPercent": { "alias": "zoomPercent"; "required": false; "isSignal": true; }; "formatPainterActive": { "alias": "formatPainterActive"; "required": false; "isSignal": true; }; "canActivateFormatPainter": { "alias": "canActivateFormatPainter"; "required": false; "isSignal": true; }; "exporting": { "alias": "exporting"; "required": false; "isSignal": true; }; "hasMacros": { "alias": "hasMacros"; "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; }; "snapToShape": { "alias": "snapToShape"; "required": false; "isSignal": true; }; "eyedropperActive": { "alias": "eyedropperActive"; "required": false; "isSignal": true; }; "themeGalleryOpen": { "alias": "themeGalleryOpen"; "required": false; "isSignal": true; }; "sidebarCollapsed": { "alias": "sidebarCollapsed"; "required": false; "isSignal": true; }; "inspectorOpen": { "alias": "inspectorOpen"; "required": false; "isSignal": true; }; "commentsOpen": { "alias": "commentsOpen"; "required": false; "isSignal": true; }; "commentCount": { "alias": "commentCount"; "required": false; "isSignal": true; }; "findOpen": { "alias": "findOpen"; "required": false; "isSignal": true; }; "collabConnected": { "alias": "collabConnected"; "required": false; "isSignal": true; }; "connectedCount": { "alias": "connectedCount"; "required": false; "isSignal": true; }; "spellCheckEnabled": { "alias": "spellCheckEnabled"; "required": false; "isSignal": true; }; "showSubtitles": { "alias": "showSubtitles"; "required": false; "isSignal": true; }; "hiddenActions": { "alias": "hiddenActions"; "required": false; "isSignal": true; }; "aiEnabled": { "alias": "aiEnabled"; "required": false; "isSignal": true; }; "aiPanelOpen": { "alias": "aiPanelOpen"; "required": false; "isSignal": true; }; "accountAuth": { "alias": "accountAuth"; "required": false; "isSignal": true; }; "activeSlideHidden": { "alias": "activeSlideHidden"; "required": false; "isSignal": true; }; }, { "prev": "prev"; "next": "next"; "zoomIn": "zoomIn"; "zoomOut": "zoomOut"; "zoomReset": "zoomReset"; "find": "find"; "present": "present"; "presenter": "presenter"; "record": "record"; "presentFromBeginning": "presentFromBeginning"; "rehearseTimings": "rehearseTimings"; "toggleSubtitles": "toggleSubtitles"; "openSubtitleSettings": "openSubtitleSettings"; "recordFromBeginning": "recordFromBeginning"; "recordFromCurrent": "recordFromCurrent"; "spellCheckChange": "spellCheckChange"; "share": "share"; "broadcast": "broadcast"; "openFile": "openFile"; "openRecentFile": "openRecentFile"; "createPresentation": "createPresentation"; "save": "save"; "savePpsx": "savePpsx"; "savePptm": "savePptm"; "packageForSharing": "packageForSharing"; "toggleSidebar": "toggleSidebar"; "toggleAiPanel": "toggleAiPanel"; "signatures": "signatures"; "info": "info"; "print": "print"; "comments": "comments"; "a11y": "a11y"; "link": "link"; "openSorter": "openSorter"; "openReadingView": "openReadingView"; "openOutlineView": "openOutlineView"; "openMasterView": "openMasterView"; "toggleNotes": "toggleNotes"; "toggleFormatPainter": "toggleFormatPainter"; "exportPng": "exportPng"; "exportPdf": "exportPdf"; "exportGif": "exportGif"; "exportVideo": "exportVideo"; "exportJson": "exportJson"; "copySlideAsImage": "copySlideAsImage"; "replace": "replace"; "toggleInspector": "toggleInspector"; "drawToolChange": "drawToolChange"; "toggleThemeGallery": "toggleThemeGallery"; "editTheme": "editTheme"; "openSlideSize": "openSlideSize"; "toggleGrid": "toggleGrid"; "toggleRulers": "toggleRulers"; "toggleGuides": "toggleGuides"; "toggleSelectionPane": "toggleSelectionPane"; "openCustomShows": "openCustomShows"; "toggleSnapToGrid": "toggleSnapToGrid"; "toggleSnapToShape": "toggleSnapToShape"; "addGuide": "addGuide"; "zoomToFit": "zoomToFit"; "toggleEyedropper": "toggleEyedropper"; "openSmartArtDialog": "openSmartArtDialog"; "openTemplateGallery": "openTemplateGallery"; "openEquationDialog": "openEquationDialog"; "openSetUpSlideShow": "openSetUpSlideShow"; "toggleHideSlide": "toggleHideSlide"; "openCompare": "openCompare"; "openPassword": "openPassword"; "openFontEmbedding": "openFontEmbedding"; "openVersionHistory": "openVersionHistory"; "openShortcuts": "openShortcuts"; "openSettings": "openSettings"; }, never, never, true, never>;
 }
 
 /** The eight resize-handle positions around a selection box. */
@@ -10897,6 +11929,41 @@ declare class RulerGuidesService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<RulerGuidesService>;
 }
 
+/**
+ * shape-adjust-handle.ts: the Angular view-mapping for the SHARED shape
+ * adjustment (`a:avLst`) affordance.
+ *
+ * Angular used to render a generic top-left corner handle for EVERY selected
+ * element whose pointerdown just resized from the south-east corner: a decoy
+ * that neither appeared where an adjustment handle belongs nor adjusted
+ * anything. React, Vue, Svelte and Vanilla all consume
+ * `getShapeAdjustmentHandleDescriptors` instead, which answers an EMPTY list
+ * for any geometry with no adjustable parameter (and for a shape whose
+ * `a:spLocks/@noAdjustHandles` is set), so a handle only exists where
+ * PowerPoint puts one, and a preset with several adjustable parameters gets
+ * one diamond for each.
+ *
+ * This module is the thin descriptor -> stage-box mapping, kept out of
+ * `slide-canvas.component.ts` so the component stays view wiring and the maths
+ * stays unit-testable without Angular.
+ *
+ * @module viewer/shape-adjust-handle
+ */
+
+/** One adjustment handle's render box in STAGE (unscaled slide) coordinates. */
+interface AdjustHandleBox {
+    /** The `a:avLst` guide name the drag writes (`shapeAdjustments[key]`). */
+    key: string;
+    left: number;
+    top: number;
+    size: number;
+    cursor: string;
+    /** The element's current adjustment value (guide units), seeding a drag. */
+    value: number;
+    /** The descriptor this box came from; the drag needs its solver. */
+    descriptor: ShapeAdjustmentHandleDescriptor;
+}
+
 /**
  * Slide-scoped DI context: lets leaf renderers (chart, SmartArt) resolve which
  * slide their canvas is displaying without threading an input through every
@@ -11002,6 +12069,18 @@ declare class SlideCanvasComponent implements SlideContext {
      * e2e selectors from matching multiple elements.
      */
     readonly interactive: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), this canvas's elements carry `data-element-id`.
+     *
+     * The miniature surfaces that paint EVERY slide at once (thumbnail rail,
+     * mobile slide sheet, slide sorter, presenter navigator, layout gallery, diff
+     * strip) pass `false`: they otherwise put one node per element PER SLIDE into
+     * the document, so a `[data-element-id]` query resolved a slide that is not
+     * on screen. It is deliberately separate from {@link interactive}, because
+     * the presentation stage is not interactive and still needs its ids (the
+     * morph engine generates keyframe CSS that selects on them).
+     */
+    readonly exposeElementIds: _angular_core.InputSignal<boolean>;
     /**
      * True only for the live presentation stage: slide-content media autoplays.
      * Left false for thumbnails, the sorter and the editor canvas so their media
@@ -11074,6 +12153,34 @@ declare class SlideCanvasComponent implements SlideContext {
         id: string;
         box: Box;
     }>;
+    /**
+     * Emitted once a drag/resize gesture RELEASES, carrying every element id the
+     * gesture moved. The parent uses it to reroute the connectors bound to those
+     * shapes; without it a connector kept pointing at where its shape used to be,
+     * because the drag end simply discarded its state with no model write.
+     */
+    readonly transformEnd: _angular_core.OutputEmitterRef<{
+        ids: readonly string[];
+    }>;
+    /**
+     * Emitted while the shape-adjustment (amber diamond) handle is dragged, with
+     * the `a:avLst` guide name and its new 0..50000 value. Deliberately separate
+     * from {@link transformUpdate}: an adjustment changes the shape's geometry
+     * parameter, never its box.
+     */
+    readonly adjustUpdate: _angular_core.OutputEmitterRef<{
+        id: string;
+        adjustments: Record<string, number>;
+    }>;
+    /**
+     * Emitted when a connector endpoint drag lands: the whole rebuilt connector,
+     * because a DETACHED end has had its `a:stCxn` / `a:endCxn` key deleted and a
+     * merge of the surviving keys would leave the stale one behind.
+     */
+    readonly connectorEndpointUpdate: _angular_core.OutputEmitterRef<{
+        id: string;
+        element: PptxElement;
+    }>;
     /** Emitted on right-click with the element under the cursor (or null). */
     readonly contextMenu: _angular_core.OutputEmitterRef<{
         id: string | null;
@@ -11127,6 +12234,14 @@ declare class SlideCanvasComponent implements SlideContext {
         tableData: PptxTableData;
     }>;
     private drag;
+    /** Live shape-adjustment gesture (amber diamond), or null when idle. */
+    private adjustDrag;
+    /** Live connector-endpoint gesture, in SLIDE px, or null when idle. */
+    protected readonly connectorEndpointDrag: _angular_core.WritableSignal<{
+        kind: ConnectorEndpointKind;
+        x: number;
+        y: number;
+    } | null>;
     private editCancelled;
     private marquee;
     /** Live marquee rectangle (stage coords) while rubber-band selecting. */
@@ -11192,17 +12307,60 @@ declare class SlideCanvasComponent implements SlideContext {
     readonly singleSelected: _angular_core.Signal<(Box & {
         id: string;
     }) | null>;
-    /** Resize-handle render boxes (stage coords) for the single selection. */
+    /** Look an element up by id across the slide + template layers. */
+    private elementById;
+    /** The single selected element itself (not just its box), or null. */
+    private readonly singleSelectedElement;
+    /**
+     * Resize-handle render boxes (stage coords) for the single selection. Empty
+     * for an element whose authored `a:spLocks/@noResize` pins its size.
+     */
     readonly handleBoxes: _angular_core.Signal<pptx_angular_viewer.HandleBox[]>;
-    /** Rotation-handle box (stage coords) above the single selection, or null. */
+    /**
+     * Rotation-handle box (stage coords) above the single selection, or null (also
+     * null when `a:spLocks/@noRotation` is authored on the element).
+     */
     readonly rotateHandle: _angular_core.Signal<pptx_angular_viewer.CornerHandleBox | null>;
     /**
-     * Shape-adjustment-handle box (stage coords) for the single selection, or
-     * null. Sits just outside the top-left corner so it never collides with the
-     * resize/rotate handles. Selection-only + editable-only, so it vanishes in
-     * presentation alongside the rest of the edit chrome.
+     * Shape-adjustment-handle boxes (stage coords) for the single selection.
+     * Position, existence and cursor all come from the SHARED
+     * `getShapeAdjustmentHandleDescriptors`, so a handle appears only for a
+     * geometry that actually has an adjustable parameter, there is ONE per
+     * `a:avLst` guide, and each sits exactly where the other four bindings put
+     * it. Selection-only + editable-only, so they vanish in presentation with
+     * the rest of the chrome.
      */
-    readonly adjustHandle: _angular_core.Signal<pptx_angular_viewer.CornerHandleBox | null>;
+    readonly adjustHandles: _angular_core.Signal<AdjustHandleBox[]>;
+    /** The selected connector, when exactly one connector is selected. */
+    private readonly selectedConnector;
+    /**
+     * The two endpoint handles of the selected connector, in stage coords.
+     *
+     * Angular could DRAW a connector but never bind one: nothing in this binding
+     * ever wrote `a:stCxn` / `a:endCxn`, so `connector-reroute` only ever fired
+     * for connectors that arrived already bound from a `.pptx`.
+     */
+    readonly connectorEndpoints: _angular_core.Signal<{
+        left: number;
+        top: number;
+        size: number;
+        kind: ConnectorEndpointKind;
+        x: number;
+        y: number;
+        attached: boolean;
+    }[]>;
+    /** Candidate connection sites, resolved only while an end is in flight. */
+    readonly connectorSiteCandidates: _angular_core.Signal<{
+        key: string;
+        left: number;
+        top: number;
+        size: number;
+        snapped: boolean;
+    }[]>;
+    /** Begin dragging one end of the selected connector. */
+    onConnectorEndpointPointerDown(event: PointerEvent, kind: ConnectorEndpointKind): void;
+    /** Pointer position in SLIDE px (the stage carries the scale as a transform). */
+    private stagePoint;
     /**
      * Resolve the id of the interactive element under a pointer target, or null.
      * See {@link resolveInteractiveElementId}.
@@ -11227,6 +12385,12 @@ declare class SlideCanvasComponent implements SlideContext {
         height: number;
         text: string;
     } | null>;
+    /**
+     * May inline text editing begin on this element? Honours the authored
+     * `a:spLocks/@noTextEdit`, which Angular ignored entirely while the other four
+     * bindings enforced it: a locked caption opened an editable textarea here.
+     */
+    private canTextEdit;
     onDblClick(event: MouseEvent): void;
     onEditorKeydown(event: KeyboardEvent): void;
     /**
@@ -11249,6 +12413,23 @@ declare class SlideCanvasComponent implements SlideContext {
     onContextMenu(event: MouseEvent): void;
     onHandlePointerDown(event: PointerEvent, handle: ResizeHandle): void;
     onRotatePointerDown(event: PointerEvent): void;
+    /**
+     * Begin a shape-adjustment gesture on the amber diamond. Captures the shared
+     * {@link ShapeAdjustmentDragState} so every subsequent pointer move resolves
+     * through `getDraggedShapeAdjustmentValue` rather than the resize pipeline
+     * this handle used to be wired to.
+     */
+    onAdjustPointerDown(event: PointerEvent, handle: AdjustHandleBox): void;
+    /**
+     * Keyboard resize from a focused handle.
+     *
+     * The step comes from the shared `editorNudgeDelta`, the same function the
+     * arrow keys nudge with, because a hand-rolled copy of it here is how the two
+     * gestures end up disagreeing: this one carried its own `shiftKey ? 10 : 1`
+     * literal, so a change to the shared step (which has already been wrong once,
+     * at 2/20 in two bindings) would have moved the nudge and left the keyboard
+     * resize behind.
+     */
     onResizeHandleKeydown(event: KeyboardEvent, handle: ResizeHandle): void;
     onRotateHandleKeydown(event: KeyboardEvent): void;
     onPointerMove(event: PointerEvent): void;
@@ -11301,7 +12482,7 @@ declare class SlideCanvasComponent implements SlideContext {
     } | null>;
     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; }; "rulerUnit": { "alias": "rulerUnit"; "required": false; "isSignal": true; }; "showGuides": { "alias": "showGuides"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "snapToShape": { "alias": "snapToShape"; "required": false; "isSignal": true; }; "guideCommand": { "alias": "guideCommand"; "required": false; "isSignal": true; }; "spellCheck": { "alias": "spellCheck"; "required": false; "isSignal": true; }; "snapToGuides": { "alias": "snapToGuides"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "transparentBackground": { "alias": "transparentBackground"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "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; }; "aiHighlights": { "alias": "aiHighlights"; "required": false; "isSignal": true; }; "aiActive": { "alias": "aiActive"; "required": false; "isSignal": true; }; "aiActiveSlideIndex": { "alias": "aiActiveSlideIndex"; "required": false; "isSignal": true; }; "aiChangeBatch": { "alias": "aiChangeBatch"; "required": false; "isSignal": true; }; "aiPickMode": { "alias": "aiPickMode"; "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"; "textInput": "textInput"; "textCancel": "textCancel"; "textFormat": "textFormat"; "rotateUpdate": "rotateUpdate"; "marqueeSelect": "marqueeSelect"; "inkStrokeComplete": "inkStrokeComplete"; "eraserHit": "eraserHit"; "cellCommit": "cellCommit"; "tableChange": "tableChange"; }, 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; }; "rulerUnit": { "alias": "rulerUnit"; "required": false; "isSignal": true; }; "showGuides": { "alias": "showGuides"; "required": false; "isSignal": true; }; "snapToGrid": { "alias": "snapToGrid"; "required": false; "isSignal": true; }; "snapToShape": { "alias": "snapToShape"; "required": false; "isSignal": true; }; "guideCommand": { "alias": "guideCommand"; "required": false; "isSignal": true; }; "spellCheck": { "alias": "spellCheck"; "required": false; "isSignal": true; }; "snapToGuides": { "alias": "snapToGuides"; "required": false; "isSignal": true; }; "autoFit": { "alias": "autoFit"; "required": false; "isSignal": true; }; "transparentBackground": { "alias": "transparentBackground"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "exposeElementIds": { "alias": "exposeElementIds"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "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; }; "aiHighlights": { "alias": "aiHighlights"; "required": false; "isSignal": true; }; "aiActive": { "alias": "aiActive"; "required": false; "isSignal": true; }; "aiActiveSlideIndex": { "alias": "aiActiveSlideIndex"; "required": false; "isSignal": true; }; "aiChangeBatch": { "alias": "aiChangeBatch"; "required": false; "isSignal": true; }; "aiPickMode": { "alias": "aiPickMode"; "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"; "transformEnd": "transformEnd"; "adjustUpdate": "adjustUpdate"; "connectorEndpointUpdate": "connectorEndpointUpdate"; "contextMenu": "contextMenu"; "textEditStart": "textEditStart"; "textCommit": "textCommit"; "textInput": "textInput"; "textCancel": "textCancel"; "textFormat": "textFormat"; "rotateUpdate": "rotateUpdate"; "marqueeSelect": "marqueeSelect"; "inkStrokeComplete": "inkStrokeComplete"; "eraserHit": "eraserHit"; "cellCommit": "cellCommit"; "tableChange": "tableChange"; }, never, ["*"], true, never>;
 }
 
 /**
@@ -11319,6 +12500,77 @@ interface SoftEdgeFilterDef {
     radius: number;
 }
 
+/**
+ * Angular's paragraph view model, built from the SHARED `buildParagraphs`.
+ *
+ * This module replaces the ~190-line hand-ported paragraph builder that used to
+ * live inside `element-renderer.component.ts` (self-documented as "hand-ported
+ * from `buildParagraphs`"). That copy had already drifted: it applied a
+ * paragraph's bullet unconditionally, with none of shared's "suppress the
+ * bullet on a paragraph with no visible text" rule, so a whitespace-only or
+ * marker-only paragraph painted a stray bullet here and nothing elsewhere.
+ *
+ * It also replaces the segment walk that used to follow the shared call. Runs
+ * carry their own `hyperlink` and `equation` now (see `text-run-meta`), so the
+ * walk that re-attached those two facts by matching each run's characters back
+ * onto the segment it came from is gone, and Vue, Svelte and Vanilla render
+ * both from the same model instead of dropping them.
+ *
+ * What is left here is a pure rename: shared's neutral field names onto the
+ * ones this binding's template already binds.
+ */
+/** A single rendered run inside an Angular paragraph. */
+interface TextRun {
+    text: string;
+    style: StyleMap;
+    /** Safe `href` when this run carries a renderable hyperlink. */
+    href?: string;
+    /** Hyperlink tooltip / title text. */
+    tooltip?: string;
+    /** Parsed OMML for an inline equation run (rendered as MathML). */
+    equationXml?: Record<string, unknown>;
+    /** Optional equation number for numbered equations. */
+    equationNumber?: string;
+    /** `a:ruby` phonetic guide (furigana / pinyin) rendered above this run. */
+    rubyText?: string;
+    /** `[ngStyle]` map for the `<rt>` annotation (size / family / alignment). */
+    rubyStyle?: StyleMap;
+}
+/** A rendered paragraph: runs plus bullet + indent + spacing metadata. */
+interface Paragraph {
+    runs: TextRun[];
+    /** Bullet / number marker text, when this paragraph is a list item. */
+    bulletMarker?: string;
+    /** Resolved picture marker, or metadata for its accessible glyph fallback. */
+    bulletPicture?: PictureBulletMarker;
+    /** `[ngStyle]` map for the bullet marker (colour / font / hang width). */
+    bulletStyle: StyleMap;
+    /** Left indent in px (hanging-indent layout). */
+    indentPx: number;
+    /** `text-indent` in px (first-line / hanging indent), when authored. */
+    textIndentPx?: number;
+    /**
+     * True when the paragraph has no runs and no bullet: an authored blank line
+     * (`<a:p><a:endParaRPr/></a:p>`), which PowerPoint gives a full line box.
+     * The template renders a `<br>` for it so the gap survives (issue #131).
+     */
+    isEmpty?: boolean;
+    /** Per-paragraph `line-height` from this paragraph's own `a:lnSpc`. */
+    lineHeight?: number | string;
+    /** `margin-top` in px from `a:spcBef` (space before), when overridden. */
+    spaceBeforePx?: number;
+    /** `margin-bottom` in px from `a:spcAft` (space after), when overridden. */
+    spaceAfterPx?: number;
+    /** `font-size` in px re-basing the paragraph's CSS line boxes onto its runs. */
+    strutFontSizePx?: number;
+    /**
+     * This paragraph's own `text-align` / BiDi `direction` / kinsoku line-break
+     * rules, when it overrides the body's. Bound with `[ngStyle]` under the
+     * explicit geometry bindings, which win.
+     */
+    paragraphStyle?: StyleMap;
+}
+
 /**
  * Text-warp (WordArt) descriptor resolver for the Angular viewer.
  *
@@ -11432,53 +12684,6 @@ type TextWarpDef = TextWarpPathDef | TextWarpCssDef;
  */
 declare function getTextWarp(element: PptxElement, fieldContext?: FieldSubstitutionContext): TextWarpDef | undefined;
 
-interface TextRun {
-    text: string;
-    style: StyleMap;
-    /** Safe `href` when this run carries a renderable hyperlink. */
-    href?: string;
-    /** Hyperlink tooltip / title text. */
-    tooltip?: string;
-    /** Parsed OMML for an inline equation run (rendered as MathML). */
-    equationXml?: Record<string, unknown>;
-    /** Optional equation number for numbered equations. */
-    equationNumber?: string;
-}
-interface Paragraph {
-    runs: TextRun[];
-    /** Bullet / number marker text, when this paragraph is a list item. */
-    bulletMarker?: string;
-    /** Resolved picture marker, or metadata for its accessible glyph fallback. */
-    bulletPicture?: PictureBulletMarker;
-    /** `[ngStyle]` map for the bullet marker (colour / font). */
-    bulletStyle: StyleMap;
-    /** Left indent in px derived from the paragraph outline level. */
-    indentPx: number;
-    /** `text-indent` in px (first-line / hanging indent), when authored. */
-    textIndentPx?: number;
-    /**
-     * True when the paragraph has no runs and no bullet: an authored blank line
-     * (`<a:p><a:endParaRPr/></a:p>`), which PowerPoint gives a full line box.
-     * The template renders a `<br>` for it so the gap survives (issue #131).
-     */
-    isEmpty?: boolean;
-    /**
-     * Per-paragraph `line-height` from this paragraph's own `a:lnSpc`: a unitless
-     * multiplier (`a:spcPct`) or a `"<n>pt"` string (`a:spcPts`). Undefined when
-     * the paragraph does not override the body-level line-height.
-     */
-    lineHeight?: number | string;
-    /** `margin-top` in px from `a:spcBef` (space before), when overridden. */
-    spaceBeforePx?: number;
-    /** `margin-bottom` in px from `a:spcAft` (space after), when overridden. */
-    spaceAfterPx?: number;
-    /**
-     * `font-size` in px set on the paragraph so its CSS line boxes are built
-     * from its own runs rather than the text body default. Mirrors the shared
-     * `RenderParagraph.strutFontSizePx`; see `resolveParagraphStrutFontSize`.
-     */
-    strutFontSizePx?: number;
-}
 /**
  * ElementRendererComponent: Angular port of the React `ElementRenderer.tsx`
  * and the Vue `ElementRenderer.vue`.
@@ -11546,6 +12751,27 @@ declare class ElementRendererComponent {
      * element contract", not "editable right now"), matching the other bindings.
      */
     readonly marked: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), the rendered node carries `data-element-id`.
+     *
+     * Turned OFF by the miniature surfaces that paint EVERY slide at once
+     * (thumbnail rail, mobile slide sheet, slide sorter, presenter navigator,
+     * layout gallery, diff strip). Those put one node per element per slide into
+     * the document, so the id of an element on slide 1 was addressable while
+     * slide 3 was on screen, and every framework-neutral `[data-element-id]`
+     * query resolved the wrong slide. React solved the same hazard by giving
+     * thumbnails a separate `StaticElementRenderer` that stamps no id at all
+     * ("exposing their ids there would put two nodes with the same id in the
+     * document"); this input is Angular's equivalent, since it reuses the live
+     * renderer for its miniatures.
+     *
+     * Distinct from {@link interactive}: the presentation stage is not
+     * interactive but MUST keep its ids, because the morph engine's generated
+     * keyframe CSS selects on them.
+     */
+    readonly exposeElementId: _angular_core.InputSignal<boolean>;
+    /** `data-element-id` for this element, or null on a miniature surface. */
+    readonly elementIdAttr: _angular_core.Signal<string | null>;
     /** Whether this element's root carries `data-pptx-element="true"`. */
     readonly elementMarked: _angular_core.Signal<boolean>;
     /**
@@ -11685,10 +12911,15 @@ declare class ElementRendererComponent {
     readonly warpedTextStyle: _angular_core.Signal<StyleMap>;
     readonly children: _angular_core.Signal<PptxElement[]>;
     /**
-     * This group's own fill, handed to `a:grpFill` children as their
-     * `parentGroupFill`. Undefined for non-group elements. Mirrors the shared
-     * `getGroupChildParentFill` helper (inlined here so the Angular binding does
-     * not depend on a shared symbol that is only vendored at build time).
+     * The fill handed to this group's `a:grpFill` children as their
+     * `parentGroupFill`; undefined for non-group elements.
+     *
+     * The shared helper, not a hand-inlined copy: the inlined one returned this
+     * group's own fill only, and `a:grpFill` resolves against the nearest
+     * ANCESTOR that has a fill, so a shape inside a fill-less nested group came
+     * out transparent. (The old copy justified itself with "shared is only
+     * vendored at build time", but this component already imports a dozen shared
+     * symbols from the vendored barrel.)
      */
     readonly childParentGroupFill: _angular_core.Signal<ShapeStyle | undefined>;
     readonly isShapeLike: _angular_core.Signal<boolean>;
@@ -11697,7 +12928,7 @@ declare class ElementRendererComponent {
     readonly hasText: _angular_core.Signal<boolean>;
     readonly placeholderLabel: _angular_core.Signal<any>;
     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; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "fieldContext": { "alias": "fieldContext"; "required": false; "isSignal": true; }; "slideElements": { "alias": "slideElements"; "required": false; "isSignal": true; }; "editTemplateMode": { "alias": "editTemplateMode"; "required": false; "isSignal": true; }; "parentGroupFill": { "alias": "parentGroupFill"; "required": false; "isSignal": true; }; }, { "cellCommit": "cellCommit"; "tableChange": "tableChange"; }, 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; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "exposeElementId": { "alias": "exposeElementId"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "fieldContext": { "alias": "fieldContext"; "required": false; "isSignal": true; }; "slideElements": { "alias": "slideElements"; "required": false; "isSignal": true; }; "editTemplateMode": { "alias": "editTemplateMode"; "required": false; "isSignal": true; }; "parentGroupFill": { "alias": "parentGroupFill"; "required": false; "isSignal": true; }; }, { "cellCommit": "cellCommit"; "tableChange": "tableChange"; }, never, never, true, never>;
 }
 
 /**
@@ -11734,6 +12965,15 @@ declare class ConnectorRendererComponent {
     readonly interactive: _angular_core.InputSignal<boolean>;
     /** Keep the data-pptx-element marker on interaction-locked template elements. */
     readonly marked: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), the rendered node carries `data-element-id`. The
+     * miniature surfaces that paint every slide at once turn it off so one
+     * element id resolves to exactly one node in the document; see
+     * `ElementRendererComponent.exposeElementId`.
+     */
+    readonly exposeElementId: _angular_core.InputSignal<boolean>;
+    /** `data-element-id` for this element, or null on a miniature surface. */
+    readonly elementIdAttr: _angular_core.Signal<string | null>;
     /**
      * Native-animation playback state. When an active `p:animClr` colour animation
      * targets the stroke (`animatesStroke`), the SVG stroke + arrowheads paint
@@ -11767,7 +13007,7 @@ declare class ConnectorRendererComponent {
     readonly connectorSegments: _angular_core.Signal<TextSegment[] | undefined>;
     readonly connectorTextStyle: _angular_core.Signal<TextStyle | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ConnectorRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConnectorRendererComponent, "pptx-connector-renderer", never, { "element": { "alias": "element"; "required": true; "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; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "animationState": { "alias": "animationState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ConnectorRendererComponent, "pptx-connector-renderer", never, { "element": { "alias": "element"; "required": true; "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; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "exposeElementId": { "alias": "exposeElementId"; "required": false; "isSignal": true; }; "animationState": { "alias": "animationState"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 /** One parallel stroke of a (possibly compound) connector line. */
 interface ConnectorStrand {
@@ -11998,7 +13238,7 @@ declare function nodeEditBox(node: RenderedNode): NodeEditBox;
  *                    text). When omitted, falls back to the rendered text.
  * @returns The edit state, or `null` when the node id cannot be resolved.
  */
-declare function beginNodeEdit(node: RenderedNode, elementId: string, rawText?: string): InlineEditState | null;
+declare function beginNodeEdit(node: RenderedNode, elementId: string, rawText?: string, resolvedNodeId?: string | null): InlineEditState | null;
 /**
  * Commit an edited node's text into the SmartArt data model.
  *
@@ -12036,19 +13276,28 @@ declare function findSlideIndexByElementId(slides: readonly PptxSlide[], id: str
  */
 declare function findOwningSlideIndex(slides: readonly PptxSlide[], id: string, templateSlideId: string | null | undefined): number;
 
-/**
- * Pure narrowing and text-layout helpers for SmartArtRendererComponent.
- * Extracted to keep the component file within the per-file line budget.
- * Re-imported as class-property function references so Angular template
- * type-checking continues to work without changes to the template.
- */
-
 /** Narrow a RenderedNode to a circle, or undefined. */
 declare function narrowToCircle(node: RenderedNode): RenderedCircleNode | undefined;
 /** Narrow a RenderedNode to a polygon, or undefined. */
 declare function narrowToPolygon(node: RenderedNode): RenderedPolygonNode | undefined;
 /** Narrow a RenderedNode to a rect, or undefined. */
 declare function narrowToRect(node: RenderedNode): RenderedRectNode | undefined;
+/**
+ * Resolved label descriptors for a layout, index-aligned with `layout.nodes`.
+ *
+ * The template used to hardcode `fill="white"` and anchor circle labels on
+ * `cx`/`cy`, ignoring the descriptor's optional `fontColor` / `fontWeight` /
+ * `fontStyle` / `textX` / `textY` / `textAnchor` / `textBaseline`. The shared
+ * `smartArtNodeLabel` decides all of it; this only maps the array so the
+ * component can expose it as a single `computed()`.
+ */
+declare function layoutNodeLabels(layout: SmartArtLayoutResult): SmartArtNodeLabel[];
+/**
+ * Resolved connector paint for a layout, index-aligned with
+ * `layout.connectors`. The template used to hardcode the grey default, which
+ * flattened the per-node colours target leaders and timeline stems carry.
+ */
+declare function layoutConnectorPaints(layout: SmartArtLayoutResult): SmartArtConnectorPaint[];
 
 /**
  * SmartArtRendererComponent: Angular SmartArt renderer.
@@ -12149,6 +13398,10 @@ declare class SmartArtRendererComponent {
     readonly drawingShapeNodeIds: _angular_core.Signal<(string | undefined)[]>;
     readonly layout: _angular_core.Signal<SmartArtLayoutResult>;
     readonly hasLayout: _angular_core.Signal<boolean>;
+    /** Label descriptors, index-aligned with `layout().nodes`. */
+    readonly layoutLabels: _angular_core.Signal<SmartArtNodeLabel[]>;
+    /** Connector paint, index-aligned with `layout().connectors`. */
+    readonly layoutConnectors: _angular_core.Signal<SmartArtConnectorPaint[]>;
     /**
      * Screen-reader metadata for the whole diagram, derived by the shared
      * `buildSmartArtA11y`. The container SVG gets `role="img"` + this `label`;
@@ -12158,13 +13411,25 @@ declare class SmartArtRendererComponent {
     /** Map of node id -> accessibility label (for per-node `<title>` lookup). */
     private readonly a11yLabelById;
     /**
-     * Parsed data-model node id for a rendered node (or `null` when the key does
-     * not map to one). Exposed as a method so the template can use it: Angular
-     * AOT templates can only call component members, not imported functions.
+     * Source node ids in fallback render order, index-aligned with
+     * `layout().nodes`. The layout engine walks the node tree depth-first, so
+     * flattening it is the mapping every binding uses.
+     *
+     * This component used to parse the id back out of the rendered node's `key`
+     * instead, which broke on any family whose key carries an extra segment: the
+     * gear legend's `<id>-gear-extra-<nodeId>-<i>` resolved to `extra-<nodeId>`,
+     * so its `data-smartart-node-id` did not match any model node and an inline
+     * edit on a legend row committed nowhere.
+     */
+    readonly layoutNodeIds: _angular_core.Signal<(string | undefined)[]>;
+    /**
+     * Data-model node id for the rendered node at `index` (or `null`). Exposed
+     * as a method so the template can use it: Angular AOT templates can only
+     * call component members, not imported functions.
      */
-    nodeKeyId(node: RenderedNode): string | null;
-    /** Resolve the accessibility label for a rendered node (by parsed node id). */
-    nodeAriaLabel(node: RenderedNode): string | null;
+    nodeIdAt(index: number): string | null;
+    /** Resolve the accessibility label for the rendered node at `index`. */
+    nodeAriaLabel(index: number): string | null;
     /**
      * Polite live-region message announcing the most recent node-text commit.
      * Empty between commits so assistive tech only speaks on change.
@@ -12176,11 +13441,10 @@ declare class SmartArtRendererComponent {
     protected readonly asCircle: typeof narrowToCircle;
     protected readonly asPolygon: typeof narrowToPolygon;
     protected readonly asRect: typeof narrowToRect;
-    protected readonly textLines: typeof centeredSvgTextLines;
     /** Double-click a node enters inline edit mode (when editable). */
-    onNodeDblClick(event: Event, node: RenderedNode): void;
+    onNodeDblClick(event: Event, node: RenderedNode, index: number): void;
     /** Enter / F2 on a focused node enters inline edit mode (when editable). */
-    onNodeKeydown(event: KeyboardEvent, node: RenderedNode): void;
+    onNodeKeydown(event: KeyboardEvent, node: RenderedNode, index: number): void;
     /** Commit the current edit (called on blur). */
     commitEdit(event: Event): void;
     /** Enter commits (Shift+Enter inserts a newline); Escape cancels. */
@@ -12275,13 +13539,22 @@ declare class InkRendererComponent {
      * hit-testing slide elements by the marker skips it.
      */
     readonly markElement: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), the rendered node carries `data-element-id`. The
+     * miniature surfaces that paint every slide at once turn it off so one
+     * element id resolves to exactly one node in the document; see
+     * `ElementRendererComponent.exposeElementId`.
+     */
+    readonly exposeElementId: _angular_core.InputSignal<boolean>;
+    /** `data-element-id` for this element, or null on a miniature surface. */
+    readonly elementIdAttr: _angular_core.Signal<string | null>;
     readonly replayKeyframes = "@keyframes pptx-ink-replay {\n  from { stroke-dashoffset: var(--ink-path-length); }\n  to { stroke-dashoffset: 0; }\n}";
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly strokes: _angular_core.Signal<InkStroke[]>;
     readonly replayStyles: _angular_core.Signal<InkStrokeAnimationStyle[]>;
     readonly viewBox: _angular_core.Signal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<InkRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InkRendererComponent, "pptx-ink-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "replay": { "alias": "replay"; "required": false; "isSignal": true; }; "markElement": { "alias": "markElement"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InkRendererComponent, "pptx-ink-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "replay": { "alias": "replay"; "required": false; "isSignal": true; }; "markElement": { "alias": "markElement"; "required": false; "isSignal": true; }; "exposeElementId": { "alias": "exposeElementId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -12487,6 +13760,15 @@ declare class Model3DRendererComponent implements OnDestroy {
      * controls and defaults to `true` even on a thumbnail.
      */
     readonly markElement: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), the rendered node carries `data-element-id`. The
+     * miniature surfaces that paint every slide at once turn it off so one
+     * element id resolves to exactly one node in the document; see
+     * `ElementRendererComponent.exposeElementId`.
+     */
+    readonly exposeElementId: _angular_core.InputSignal<boolean>;
+    /** `data-element-id` for this element, or null on a miniature surface. */
+    readonly elementIdAttr: _angular_core.Signal<string | null>;
     private readonly sceneRef;
     readonly containerStyle: _angular_core.Signal<StyleMap>;
     readonly vm: _angular_core.Signal<Model3DViewModel>;
@@ -12508,7 +13790,7 @@ declare class Model3DRendererComponent implements OnDestroy {
     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; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "markElement": { "alias": "markElement"; "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; }; "markElement": { "alias": "markElement"; "required": false; "isSignal": true; }; "exposeElementId": { "alias": "exposeElementId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /** Resolves a `pptx.*` key, interpolating `{{...}}` params when given. */
@@ -12685,12 +13967,22 @@ declare class AnimationPlaybackService {
     private showWithAnimation;
     private frameRoot;
     private onPlayActionSound;
+    private applyStyles;
     private readonly ctx;
     constructor();
     /** Scope media-command (`p:cmd`) target lookups to a stage root element. */
     setFrameRoot(root: () => HTMLElement | null): void;
     /** Register a host-provided action-sound player (embedded-sound resolution). */
     setActionSoundHandler(handler: ((soundPath: string) => void) | undefined): void;
+    /**
+     * Register the DOM applier that stamps the element states onto the rendered
+     * stage ({@link PresentationStageAnimator.applyAnimationStyles}). It is run
+     * SYNCHRONOUSLY on every playback state change, so a click-advance starts its
+     * entrance in the same task as the key press instead of waiting for Angular's
+     * next change-detection + render pass. Pass an applier that no-ops while the
+     * stage still shows another slide (`onlyWhenStaged`).
+     */
+    setStyleApplier(apply: () => void): void;
     private animationsEnabled;
     /** Clear all pending timers + the in-flight staged-build RAF. */
     clearTimers(): void;
@@ -12860,6 +14152,119 @@ declare class PresentationAnnotationsService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PresentationAnnotationsService>;
 }
 
+/**
+ * presentation-overlay-helpers.ts
+ *
+ * Pure functions used by PresentationOverlayComponent.
+ * Exported separately so they can be unit-tested without TestBed.
+ */
+
+/**
+ * The running custom show, when one is active. Every navigation helper below
+ * takes it and forwards it to `resolveShowSlideIndexes`, because "which slide
+ * comes next" is one rule (membership AND hidden slides), not two: Angular used
+ * to pre-filter the slide array to the show's membership and then ask the
+ * shared rule about the filtered array, which is how a hidden slide inside a
+ * custom show still got presented.
+ */
+type ActiveShow = ShowOrderCustomShow | null | undefined;
+/**
+ * Whether a click/tap/swipe advance must be swallowed instead of moving to the
+ * next slide. A click still steps the current slide's remaining animation
+ * builds, so this only blocks once they are exhausted (`playbackComplete`) and
+ * only when the slide's transition sets advanceOnClick to false. Keyboard and
+ * the on-screen next/prev buttons never consult this.
+ */
+declare function shouldBlockClickAdvance(playbackComplete: boolean, slide: PptxSlide | undefined): boolean;
+/**
+ * Delay in ms before the show steps to the next slide on its own, or
+ * `undefined` when the current slide waits for input.
+ *
+ * The counterpart to {@link shouldBlockClickAdvance}: PowerPoint's
+ * `p:transition/@advTm` ("Advance slide: After <n>"). A slide authored
+ * `advClick="0" advTm="…"` is advanced ONLY by this timer, so honouring the
+ * click gate without also arming the timer strands the show on that slide with
+ * no visible response to any input. Nothing is scheduled once the end-of-show
+ * screen is up, or when the show is set to advance manually.
+ */
+declare function resolveSlideAutoAdvanceMs(slide: PptxSlide | undefined, useTimings: boolean, endOfShow: boolean): number | undefined;
+/**
+ * Attach the show's visibility pause: while the tab is hidden the shared
+ * handler pauses the stage's playing media and the cross-slide persistent
+ * audio, and the binding-provided callbacks cancel / re-arm the timed
+ * auto-advance so the deck does not run on unseen. Returns the detach
+ * function. Kept TestBed-free so the wiring can be unit-tested directly.
+ */
+declare function attachShowVisibilityPause(deps: {
+    /** The overlay root containing the stage; only media inside it is paused. */
+    root: ParentNode | undefined;
+    /** Cancel the pending auto-advance timer (the tab was hidden). */
+    cancelAutoAdvance: () => void;
+    /** Re-arm the auto-advance timer for the current slide (tab visible again). */
+    rearmAutoAdvance: () => void;
+}): () => void;
+/**
+ * The show has ENDED (never a slide change): stop and remove all cross-slide
+ * "play across slides" persistent audio. Called by the host's exit paths
+ * (`closePresentation` / `exitPresenter`), not by the overlay's own destroy,
+ * because swapping to the presenter console destroys the overlay while the
+ * show, and its background audio, carry on.
+ */
+declare function endShowMediaCleanup(): void;
+/**
+ * Clamp `index` to the valid range [0, count - 1].
+ * Returns 0 when `count` is 0 to avoid -1 states.
+ */
+declare function clampIndex(index: number, count: number): number;
+/**
+ * Return the next visible (non-hidden) slide index after `current`.
+ * Wraps around to `current` if no subsequent visible slide exists.
+ *
+ * Thin adapter over the shared show-order rule: Angular used to own this logic
+ * outright, which is exactly why the other four bindings presented hidden
+ * slides. Kept as a named export because the overlay's tests and the navigator
+ * read better in terms of "next visible slide" than raw index lists.
+ */
+declare function nextVisibleIndex(current: number, slides: readonly PptxSlide[], activeShow?: ActiveShow): number;
+/**
+ * Return the previous visible (non-hidden) slide index before `current`.
+ * Returns `current` when no earlier visible slide exists: PowerPoint never
+ * wraps backward off the first slide.
+ */
+declare function prevVisibleIndex(current: number, slides: readonly PptxSlide[], activeShow?: ActiveShow): number;
+/**
+ * Compute the zoom level that fits a canvas of `canvasW × canvasH` pixels
+ * into a viewport of `vw × vh` pixels, preserving aspect ratio.
+ *
+ * Returns 1 as a safe fallback when any dimension is zero or negative.
+ */
+declare function fitZoom(canvasW: number, canvasH: number, vw: number, vh: number): number;
+/**
+ * Whether a visible (non-hidden) slide exists strictly AFTER `current`.
+ *
+ * `nextVisibleIndex` wraps, which would make a show loop for ever. PowerPoint
+ * only loops when "Loop continuously until Esc" is set; otherwise running past
+ * the last slide ends the show. Callers use this to tell "there is a next
+ * slide" from "we just wrapped".
+ */
+declare function hasVisibleSlideAfter(current: number, slides: readonly PptxSlide[], activeShow?: ActiveShow): boolean;
+/** The show's first visible slide (Home), or 0 for an empty deck. */
+declare function firstVisibleIndex(slides: readonly PptxSlide[], activeShow?: ActiveShow): number;
+/** The show's last visible slide (End), or 0 for an empty deck. */
+declare function lastVisibleIndex(slides: readonly PptxSlide[], activeShow?: ActiveShow): number;
+/**
+ * Style record centring the scaled slide stage in the viewport.
+ *
+ * The offsets are computed numerically ((viewport - scaled size) / 2, exactly
+ * how React's PresentationStage centres) rather than with the historical
+ * `left/top: 50%` + `translate(-50%, -50%)`: a transform makes the stage a
+ * stacking context, which trapped every z-index inside it (the ink annotation
+ * overlay in particular) BELOW the sibling blackout sheet, so blackboard
+ * strokes painted invisibly under the black screen. See the shared
+ * `render/presentation-blackboard` module for the layering rules.
+ */
+declare function presentationStageStyle(size: CanvasSize, zoom: number, viewportW: number, viewportH: number): Record<string, string>;
+
 /** Where a navigation request wants to go. */
 type ShowDirection = 'next' | 'prev' | 'first' | 'last';
 /**
@@ -12873,6 +14278,13 @@ interface ActiveSlideTransition {
 /** Everything the navigator needs from its host component. */
 interface ShowNavigatorDeps {
     slides: () => readonly PptxSlide[];
+    /**
+     * The running custom show, when one is active. `slides()` is always the whole
+     * deck: the subset is a navigation rule, not a different slide array, so that
+     * a hidden slide inside the show is still skipped and the editor's index
+     * space never has to be translated.
+     */
+    activeCustomShow?: () => ActiveShow;
     /** The slide at the CURRENT index (a computed over `currentIndex`). */
     currentSlide: () => PptxSlide | undefined;
     showWithAnimation: () => boolean | undefined;
@@ -12982,6 +14394,12 @@ interface PresentationInputDeps {
     presenterWindow: PresenterWindowService;
     /** PowerPoint's Ctrl+M: hide ink markup without discarding the strokes. */
     toggleInkMarkup: () => void;
+    /** PowerPoint's bare `J`: show or hide the live-caption bar. */
+    toggleSubtitles: () => void;
+    /** PowerPoint's Ctrl+H: show or hide the running show's own chrome. */
+    toggleChrome: () => void;
+    /** PowerPoint's Ctrl+S: raise the "See All Slides" navigator. */
+    showAllSlides: () => void;
     /** End the show; the component guards against double-closing. */
     requestClose: () => void;
 }
@@ -13046,6 +14464,13 @@ declare class PresentationOverlayComponent implements OnInit {
     readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
     readonly startIndex: _angular_core.InputSignal<number>;
+    /**
+     * The running custom show, or null for the whole deck. `slides` stays the
+     * FULL deck either way: membership is applied by the shared show-order rule
+     * (see `presentation-overlay-helpers.ts`), so indexes remain deck indexes and
+     * hidden slides inside a show are still skipped.
+     */
+    readonly activeCustomShow: _angular_core.InputSignal<ShowOrderCustomShow | null>;
     readonly showWithAnimation: _angular_core.InputSignal<boolean | undefined>;
     /**
      * Whether authored slide timings (`p:transition/@advTm`) advance the show on
@@ -13100,13 +14525,24 @@ declare class PresentationOverlayComponent implements OnInit {
      * `presentation-input-controller.ts`.
      */
     protected readonly input: PresentationInputController;
+    /** Whether PowerPoint's "See All Slides" navigator is up (Ctrl+S). */
+    protected readonly allSlidesOpen: _angular_core.WritableSignal<boolean>;
     /** Template aliases for the navigator's state. */
     protected readonly currentIndex: _angular_core.WritableSignal<number>;
     protected readonly endOfShow: _angular_core.WritableSignal<boolean>;
     protected readonly activeTransition: _angular_core.WritableSignal<ActiveSlideTransition | null>;
     /** Mirror the host's audience "session ended" flag onto the end screen. */
     private readonly syncSessionEnded;
-    /** Adopt an index the host pushed in (an audience display mirrors one). */
+    /**
+     * Adopt an index the host PUSHED in (an audience display mirrors one).
+     *
+     * `startIndex` is this effect's only dependency, deliberately. `syncFromHost`
+     * reads the navigator's own `currentIndex` to decide whether anything
+     * changed, and tracking that read made the effect re-run on the show's own
+     * advances: any host whose `startIndex` did not follow the show then re-armed
+     * itself and yanked the slide straight back. That is exactly what a running
+     * custom show used to do, and why Angular alone never left its first slide.
+     */
     private readonly syncExternalIndex;
     /**
      * Zoom-navigation context (provided at this component level). The handler is
@@ -13128,6 +14564,8 @@ declare class PresentationOverlayComponent implements OnInit {
      * {@link setupFullscreen}).
      */
     private readonly rootRef;
+    /** The show toolbar, so Ctrl+H can flip the visibility flag it already owns. */
+    private readonly toolbarRef;
     /**
      * Guards against handling the same exit twice: e.g. Escape both reaches our
      * own `keydown` handler AND causes the browser to natively exit fullscreen
@@ -13208,6 +14646,8 @@ declare class PresentationOverlayComponent implements OnInit {
     protected onEndScreenClick(event: MouseEvent): void;
     /** The show toolbar's end button: same exit path as Escape / the close button. */
     protected onToolbarEnd(): void;
+    /** A "See All Slides" tile: jump there and drop the navigator. */
+    protected onNavigatorSelect(index: number): void;
     /**
      * Overlay-chrome buttons (close / previous / next). Each is bound for both
      * `click` and `touchend`: the touch path additionally prevents the browser's
@@ -13220,7 +14660,7 @@ declare class PresentationOverlayComponent implements OnInit {
     private runChromeAction;
     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; }; "showWithAnimation": { "alias": "showWithAnimation"; "required": false; "isSignal": true; }; "useTimings": { "alias": "useTimings"; "required": false; "isSignal": true; }; "subtitlesVisible": { "alias": "subtitlesVisible"; "required": false; "isSignal": true; }; "sessionEnded": { "alias": "sessionEnded"; "required": false; "isSignal": true; }; "endWithBlackSlide": { "alias": "endWithBlackSlide"; "required": false; "isSignal": true; }; "presenterMode": { "alias": "presenterMode"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; "subtitlesChange": "subtitlesChange"; "presenterViewToggle": "presenterViewToggle"; "annotationsExit": "annotationsExit"; }, never, never, true, 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; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "showWithAnimation": { "alias": "showWithAnimation"; "required": false; "isSignal": true; }; "useTimings": { "alias": "useTimings"; "required": false; "isSignal": true; }; "subtitlesVisible": { "alias": "subtitlesVisible"; "required": false; "isSignal": true; }; "sessionEnded": { "alias": "sessionEnded"; "required": false; "isSignal": true; }; "endWithBlackSlide": { "alias": "endWithBlackSlide"; "required": false; "isSignal": true; }; "presenterMode": { "alias": "presenterMode"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; "subtitlesChange": "subtitlesChange"; "presenterViewToggle": "presenterViewToggle"; "annotationsExit": "annotationsExit"; }, never, never, true, never>;
 }
 
 /**
@@ -13253,10 +14693,16 @@ declare class SlideSorterOverlayComponent {
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
     /** Zero-based index of the currently active slide (highlighted in blue). */
     readonly activeIndex: _angular_core.InputSignal<number>;
+    /** Whether the host allows edits; gates the deck-writing shortcuts. */
+    readonly canEdit: _angular_core.InputSignal<boolean>;
     /** Emits the zero-based index of the thumbnail the user clicked. */
     readonly select: _angular_core.OutputEmitterRef<number>;
     /** Emits when the user closes the overlay (✕ button or Escape key). */
     readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Delete the active slide (Delete / Backspace). */
+    readonly deleteSlide: _angular_core.OutputEmitterRef<number>;
+    /** Duplicate the active slide (Ctrl/Cmd+D). */
+    readonly duplicateSlide: _angular_core.OutputEmitterRef<number>;
     /** Zoom level that fits the full canvas width into THUMB_W pixels. */
     readonly thumbZoom: _angular_core.Signal<number>;
     /** Pixel height of the clipping box (aspect-correct). */
@@ -13265,7 +14711,15 @@ declare class SlideSorterOverlayComponent {
     readonly clipStyle: _angular_core.Signal<Record<string, string>>;
     /** ngStyle object for the grid: responsive auto-fill columns. */
     readonly gridStyle: _angular_core.Signal<Record<string, string>>;
-    /** Keyboard handler: Escape closes the overlay. */
+    /**
+     * Keyboard handler, resolved by the shared sorter keymap.
+     *
+     * This used to test for `Escape` and nothing else, so the sorter's Delete and
+     * Ctrl+D were dead in Angular alone. Only the commands this overlay can
+     * perform are dispatched: there is no slide clipboard, no multi-selection and
+     * no thumbnail zoom here, so those chords are left to the host instead of
+     * being swallowed by a branch that would do nothing.
+     */
     onKeydown(event: KeyboardEvent): void;
     /** Clicking the backdrop (outside the panel) closes the overlay. */
     onBackdropClick(event: MouseEvent): void;
@@ -13284,7 +14738,7 @@ declare class SlideSorterOverlayComponent {
      */
     hiddenCue(slide: PptxSlide, index: number): HiddenSlideCue;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideSorterOverlayComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideSorterOverlayComponent, "pptx-slide-sorter-overlay", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "select": "select"; "closed": "closed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideSorterOverlayComponent, "pptx-slide-sorter-overlay", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, { "select": "select"; "closed": "closed"; "deleteSlide": "deleteSlide"; "duplicateSlide": "duplicateSlide"; }, never, never, true, never>;
 }
 
 declare class ReadingViewOverlayComponent implements OnInit, AfterViewInit, OnDestroy {
@@ -13424,7 +14878,12 @@ declare class InspectorPanelComponent {
         textColor: string;
         fontSize: number;
     }>;
-    /** Whether the element has lock flags preventing move/select. */
+    /**
+     * Whether the element carries a lock that stops a canvas gesture, resolved by
+     * the SHARED predicate so all five bindings agree on what "locked" means
+     * (previously a hand-rolled `noMove || noSelect` that omitted `noResize`, so a
+     * resize-locked shape showed as unlocked while the canvas refused the drag).
+     */
     protected readonly isLocked: _angular_core.Signal<boolean>;
     /** Whether the element supports shape-style (fill/stroke) editing. */
     protected readonly hasShape: _angular_core.Signal<boolean>;
@@ -13450,7 +14909,7 @@ declare class InspectorPanelComponent {
      * identically.
      */
     protected onSmartArtDataChange(smartArtData: PptxSmartArtData): void;
-    /** Toggle element lock (noMove + noResize + noSelect). */
+    /** Toggle element lock. Shared owns which flags that writes. */
     protected onLockToggle(): void;
     /** Commit a partial-element patch from an advanced sub-panel as one history entry. */
     protected onPatch(patch: Partial<PptxElement>): void;
@@ -13590,8 +15049,17 @@ declare class SlideSizeCardComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     private readonly loader;
     private readonly editor;
+    protected readonly CUSTOM_PRESET_VALUE = "";
+    protected readonly presets: readonly SlideSizePreset[];
+    protected readonly orientations: readonly SlideSizeOrientation[];
     protected readonly size: _angular_core.WritableSignal<pptx_angular_viewer.CanvasSize>;
+    protected readonly selection: _angular_core.Signal<SlideSizeSelectionDescriptor>;
+    protected readonly selectedPresetValue: _angular_core.Signal<string>;
+    protected onPresetChange(event: Event): void;
+    protected onOrientation(orientation: SlideSizeOrientation): void;
     protected onChange(event: Event, dim: 'width' | 'height'): void;
+    /** Commit an EMU size and the canvas size it implies, together. */
+    private apply;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideSizeCardComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideSizeCardComponent, "pptx-slide-size-card", never, { "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -15971,6 +17439,7 @@ declare class ViewerExtraDialogsComponent {
     readonly themeKeySelect: _angular_core.OutputEmitterRef<string>;
     readonly localeSelect: _angular_core.OutputEmitterRef<string>;
     protected readonly svc: ViewerDialogsService;
+    protected readonly customFonts: CustomFontsService;
     protected readonly viewerOpts: ViewerOptionsService;
     protected readonly compare: ViewerCompareService;
     protected readonly editor: EditorStateService;
@@ -16285,6 +17754,15 @@ declare class FontEmbeddingPanelComponent {
     readonly usedFontFamilies: _angular_core.InputSignal<string[]>;
     /** Font families already embedded in the file. */
     readonly embeddedFonts: _angular_core.InputSignal<string[]>;
+    /**
+     * False when the deck embeds nothing, in which case the switch is inert and
+     * says why. The viewer can keep or strip embedded font data on save, but it
+     * cannot manufacture it: a browser will not hand over the bytes of an
+     * installed system face.
+     */
+    readonly canEmbedFonts: _angular_core.InputSignal<boolean>;
+    /** i18n key for the explanation shown when `canEmbedFonts` is false. */
+    readonly embedUnavailableKey: _angular_core.InputSignal<string | undefined>;
     /** Fired when the dialog is dismissed. */
     readonly close: _angular_core.OutputEmitterRef<void>;
     /** Fired when the embed toggle changes; carries the new checked state. */
@@ -16297,13 +17775,15 @@ declare class FontEmbeddingPanelComponent {
     readonly scanned: _angular_core.WritableSignal<boolean>;
     /** Set view of {@link embeddedFonts} for fast membership checks. */
     readonly embeddedSet: _angular_core.Signal<Set<string>>;
+    /** Line of copy under the switch: what it does, or why it cannot. */
+    readonly toggleNoteKey: _angular_core.Signal<string>;
     /** How many used families failed to resolve in the browser. */
     readonly missingCount: _angular_core.Signal<number>;
     constructor();
     onToggle(event: Event): void;
     private scanFonts;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FontEmbeddingPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FontEmbeddingPanelComponent, "pptx-font-embedding-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "embedFontsEnabled": { "alias": "embedFontsEnabled"; "required": false; "isSignal": true; }; "usedFontFamilies": { "alias": "usedFontFamilies"; "required": false; "isSignal": true; }; "embeddedFonts": { "alias": "embeddedFonts"; "required": false; "isSignal": true; }; }, { "close": "close"; "toggleEmbedFonts": "toggleEmbedFonts"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FontEmbeddingPanelComponent, "pptx-font-embedding-panel", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "embedFontsEnabled": { "alias": "embedFontsEnabled"; "required": false; "isSignal": true; }; "usedFontFamilies": { "alias": "usedFontFamilies"; "required": false; "isSignal": true; }; "embeddedFonts": { "alias": "embeddedFonts"; "required": false; "isSignal": true; }; "canEmbedFonts": { "alias": "canEmbedFonts"; "required": false; "isSignal": true; }; "embedUnavailableKey": { "alias": "embedUnavailableKey"; "required": false; "isSignal": true; }; }, { "close": "close"; "toggleEmbedFonts": "toggleEmbedFonts"; }, never, never, true, never>;
 }
 
 declare class FontEmbeddingListComponent {
@@ -16432,6 +17912,10 @@ declare class SettingsDialogComponent {
     readonly resetOptions: _angular_core.OutputEmitterRef<keyof ViewerOptions | undefined>;
     readonly clearCache: _angular_core.OutputEmitterRef<void>;
     readonly themeKeySelect: _angular_core.OutputEmitterRef<string>;
+    /** Families registered this session via the Fonts section. */
+    readonly customFontFamilies: _angular_core.InputSignal<readonly string[]>;
+    /** A font file was registered; the ribbon adds the family to its list. */
+    readonly customFontRegistered: _angular_core.OutputEmitterRef<string>;
     readonly localeSelect: _angular_core.OutputEmitterRef<string>;
     readonly close: _angular_core.OutputEmitterRef<void>;
     protected readonly tabs: readonly ViewerOptionsTabDefinition[];
@@ -16447,7 +17931,7 @@ declare class SettingsDialogComponent {
     /** Escape confirms (keeps edits), mirroring React's dialog. */
     protected onEscape(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsDialogComponent, "pptx-settings-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "themeKey": { "alias": "themeKey"; "required": false; "isSignal": true; }; "availableThemes": { "alias": "availableThemes"; "required": false; "isSignal": true; }; "localeCode": { "alias": "localeCode"; "required": false; "isSignal": true; }; "availableLocales": { "alias": "availableLocales"; "required": false; "isSignal": true; }; "addinStatus": { "alias": "addinStatus"; "required": false; "isSignal": true; }; "aiExportVisible": { "alias": "aiExportVisible"; "required": false; "isSignal": true; }; }, { "optionChange": "optionChange"; "restoreOptions": "restoreOptions"; "ribbonTabHiddenChange": "ribbonTabHiddenChange"; "quickAccessCommandsChange": "quickAccessCommandsChange"; "resetOptions": "resetOptions"; "clearCache": "clearCache"; "themeKeySelect": "themeKeySelect"; "localeSelect": "localeSelect"; "close": "close"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsDialogComponent, "pptx-settings-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; "themeKey": { "alias": "themeKey"; "required": false; "isSignal": true; }; "availableThemes": { "alias": "availableThemes"; "required": false; "isSignal": true; }; "localeCode": { "alias": "localeCode"; "required": false; "isSignal": true; }; "availableLocales": { "alias": "availableLocales"; "required": false; "isSignal": true; }; "addinStatus": { "alias": "addinStatus"; "required": false; "isSignal": true; }; "aiExportVisible": { "alias": "aiExportVisible"; "required": false; "isSignal": true; }; "customFontFamilies": { "alias": "customFontFamilies"; "required": false; "isSignal": true; }; }, { "optionChange": "optionChange"; "restoreOptions": "restoreOptions"; "ribbonTabHiddenChange": "ribbonTabHiddenChange"; "quickAccessCommandsChange": "quickAccessCommandsChange"; "resetOptions": "resetOptions"; "clearCache": "clearCache"; "themeKeySelect": "themeKeySelect"; "customFontRegistered": "customFontRegistered"; "localeSelect": "localeSelect"; "close": "close"; }, never, never, true, never>;
 }
 
 declare class SettingsAppearanceTabComponent {
@@ -16472,7 +17956,7 @@ declare class AccountPageComponent {
     readonly accountAuth: _angular_core.InputSignal<AccountAuthConfig | undefined>;
     private readonly translate;
     protected readonly swatches: readonly string[];
-    protected readonly version = "2.17.8";
+    protected readonly version = "2.18.0";
     protected readonly profile: _angular_core.WritableSignal<ViewerProfile>;
     protected readonly initial: _angular_core.Signal<string>;
     protected readonly usage: _angular_core.WritableSignal<LocalStorageUsageSummary | null>;
@@ -16502,6 +17986,20 @@ declare class KeepAnnotationsDialogComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<KeepAnnotationsDialogComponent, "pptx-keep-annotations-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "annotationCount": { "alias": "annotationCount"; "required": false; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; }, { "keep": "keep"; "discard": "discard"; }, never, never, true, never>;
 }
 
+declare class AutosaveRecoveryDialogComponent {
+    private readonly translate;
+    /** The shared descriptor to render, or null to render nothing. */
+    readonly prompt: _angular_core.InputSignal<AutosaveRecoveryPrompt | null>;
+    /** The user accepted: load the snapshot. */
+    readonly restore: _angular_core.OutputEmitterRef<void>;
+    /** The user declined (also on dismiss): drop the snapshot. */
+    readonly discard: _angular_core.OutputEmitterRef<void>;
+    /** "Autosaved 5 min ago", built from the two keys the descriptor names. */
+    protected readonly savedLabel: _angular_core.Signal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutosaveRecoveryDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutosaveRecoveryDialogComponent, "pptx-autosave-recovery-dialog", never, { "prompt": { "alias": "prompt"; "required": false; "isSignal": true; }; }, { "restore": "restore"; "discard": "discard"; }, never, never, true, never>;
+}
+
 declare class SignatureStrippedDialogComponent {
     /** Whether the dialog is visible. */
     readonly open: _angular_core.InputSignal<boolean>;
@@ -16811,7 +18309,13 @@ declare class PresentationToolbarComponent {
         readonly swatchBar: "absolute bottom-0.5 left-1/2 -translate-x-1/2 w-3 h-0.5 rounded-full";
     };
     protected readonly openPalette: _angular_core.WritableSignal<OpenPalette>;
-    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    /**
+     * Whether the bar is faded in. Public because PowerPoint's Ctrl+H toggles it
+     * from the show's key handler, which owns no visibility state of its own:
+     * auto-hide and the shortcut have to drive ONE flag or the bar disagrees with
+     * itself the moment the presenter moves the mouse.
+     */
+    readonly visible: _angular_core.WritableSignal<boolean>;
     private readonly mountedAt;
     private readonly now;
     protected readonly counterLabel: _angular_core.Signal<string>;
@@ -16831,6 +18335,8 @@ declare class PresentationToolbarComponent {
      * back on the next twitch.
      */
     protected onDocumentMouseMove(event: MouseEvent): void;
+    /** PowerPoint's Ctrl+H: flip the show chrome, auto-hide countdown and all. */
+    toggleVisible(): void;
     protected onMouseEnter(): void;
     protected onMouseLeave(): void;
     /** A press outside the bar dismisses whichever colour palette is open. */
@@ -17026,6 +18532,12 @@ declare class PresenterViewComponent {
     protected readonly NOTES_FONT_SIZE_MAX = 32;
     readonly slides: _angular_core.InputSignal<PptxSlide[]>;
     readonly currentSlideIndex: _angular_core.InputSignal<number>;
+    /**
+     * The running custom show, or null for the whole deck. The "next slide"
+     * preview MUST honour it: while a show is playing, the slide the next
+     * forward press lands on is the show's next member, not `index + 1`.
+     */
+    readonly activeCustomShow: _angular_core.InputSignal<ShowOrderCustomShow | null>;
     readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
     readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
@@ -17100,7 +18612,7 @@ declare class PresenterViewComponent {
     protected onSwapDisplays(): void;
     private withTemplate;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<PresenterViewComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresenterViewComponent, "pptx-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; "isAudienceWindowOpen": { "alias": "isAudienceWindowOpen"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; "openAudienceWindow": "openAudienceWindow"; "closeAudienceWindow": "closeAudienceWindow"; "navigateToSlide": "navigateToSlide"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PresenterViewComponent, "pptx-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; "isAudienceWindowOpen": { "alias": "isAudienceWindowOpen"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; "openAudienceWindow": "openAudienceWindow"; "closeAudienceWindow": "closeAudienceWindow"; "navigateToSlide": "navigateToSlide"; }, never, never, true, never>;
 }
 
 /**
@@ -17123,6 +18635,12 @@ declare class PresenterViewComponent {
 declare class MobilePresenterViewComponent {
     readonly slides: _angular_core.InputSignal<PptxSlide[]>;
     readonly currentSlideIndex: _angular_core.InputSignal<number>;
+    /**
+     * The running custom show, or null for the whole deck. The "next slide"
+     * preview MUST honour it: while a show is playing, the slide the next
+     * forward press lands on is the show's next member, not `index + 1`.
+     */
+    readonly activeCustomShow: _angular_core.InputSignal<ShowOrderCustomShow | null>;
     readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
     readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
@@ -17148,7 +18666,7 @@ declare class MobilePresenterViewComponent {
     }>;
     private withTemplate;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MobilePresenterViewComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobilePresenterViewComponent, "pptx-mobile-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MobilePresenterViewComponent, "pptx-mobile-presenter-view", never, { "slides": { "alias": "slides"; "required": true; "isSignal": true; }; "currentSlideIndex": { "alias": "currentSlideIndex"; "required": true; "isSignal": true; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; "templateElements": { "alias": "templateElements"; "required": false; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "presentationStartTime": { "alias": "presentationStartTime"; "required": false; "isSignal": true; }; }, { "movePresentationSlide": "movePresentationSlide"; "exit": "exit"; }, never, never, true, never>;
 }
 
 /**
@@ -17426,6 +18944,18 @@ declare function computeSingleSelected(elements: readonly PptxElement[], selecte
 declare function computeHandleBoxes(box: (Box & {
     id: string;
 }) | null, editable: boolean, handleScreenPx: number, zoom: number): HandleBox[];
+/**
+ * Resize-handle boxes for the single selection, suppressed entirely when the
+ * element's authored `a:spLocks` forbids resizing.
+ *
+ * The lock question is asked HERE rather than in the component so the rule is
+ * unit-testable without Angular, and so the render gate and the pointer-down
+ * gate ({@link canInteractWithElement}) can never disagree: a handle the user
+ * cannot see is also a handle the pointer path refuses.
+ */
+declare function computeResizeHandleBoxes(element: PptxElement | null | undefined, box: (Box & {
+    id: string;
+}) | null, editable: boolean, handleScreenPx: number, zoom: number): HandleBox[];
 /**
  * A corner handle box (rotate or shape-adjust) offset above/outside the
  * single selection's box by `offsetPx` (screen pixels, scaled by zoom).
@@ -17433,6 +18963,15 @@ declare function computeHandleBoxes(box: (Box & {
 declare function computeCornerHandle(box: (Box & {
     id: string;
 }) | null, editable: boolean, handleScreenPx: number, offsetPx: number, zoom: number, corner: 'top-center' | 'top-left'): CornerHandleBox | null;
+/**
+ * The rotate-knob box for the single selection, or null when the element's
+ * authored `a:spLocks/@noRotation` forbids the gesture. Companion to
+ * {@link computeResizeHandleBoxes}; see that function for why the lock check
+ * lives in this module.
+ */
+declare function computeRotateHandleBox(element: PptxElement | null | undefined, box: (Box & {
+    id: string;
+}) | null, editable: boolean, handleScreenPx: number, offsetPx: number, zoom: number): CornerHandleBox | null;
 /**
  * Resolve the id of the interactive element under a pointer target, or null.
  *
@@ -18178,10 +19717,13 @@ declare class RibbonColorPopoverComponent {
 declare class RibbonDesignSectionComponent {
     readonly themeGalleryOpen: _angular_core.InputSignal<boolean>;
     readonly toggleThemeGallery: _angular_core.OutputEmitterRef<void>;
-    readonly info: _angular_core.OutputEmitterRef<void>;
+    /** "Edit Theme": open the theme gallery already in its customise mode. */
+    readonly editTheme: _angular_core.OutputEmitterRef<void>;
+    /** "Slide Size": surface the inspector deck panel that owns the size card. */
+    readonly openSlideSize: _angular_core.OutputEmitterRef<void>;
     readonly toggleInspector: _angular_core.OutputEmitterRef<void>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonDesignSectionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonDesignSectionComponent, "pptx-ribbon-design-section", never, { "themeGalleryOpen": { "alias": "themeGalleryOpen"; "required": false; "isSignal": true; }; }, { "toggleThemeGallery": "toggleThemeGallery"; "info": "info"; "toggleInspector": "toggleInspector"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonDesignSectionComponent, "pptx-ribbon-design-section", never, { "themeGalleryOpen": { "alias": "themeGalleryOpen"; "required": false; "isSignal": true; }; }, { "toggleThemeGallery": "toggleThemeGallery"; "editTheme": "editTheme"; "openSlideSize": "openSlideSize"; "toggleInspector": "toggleInspector"; }, never, never, true, never>;
 }
 
 declare class RibbonDrawingGroupComponent {
@@ -18300,7 +19842,25 @@ declare class RibbonFontControlsComponent {
     private readonly editor;
     readonly slideIndex: _angular_core.InputSignal<number>;
     readonly selectedElement: _angular_core.InputSignal<PptxElement | null>;
-    protected readonly fontFamilies: string[];
+    private readonly loader;
+    private readonly customFonts;
+    /**
+     * Theme major/minor latin faces. Read from DI rather than taken as inputs
+     * because this component renders in two different ribbon hosts, and both
+     * would otherwise have to thread the same three values down.
+     */
+    protected readonly themeFonts: _angular_core.Signal<{
+        heading: string | undefined;
+        body: string | undefined;
+    }>;
+    /**
+     * The dropdown's contents, grouped the way PowerPoint groups them.
+     *
+     * This component used to carry its own eight-entry family list, so Angular
+     * offered a different set of fonts from the other four bindings. The
+     * grouping and de-duplication now come from `pptx-viewer-shared`.
+     */
+    protected readonly fontGroups: _angular_core.Signal<FontCatalogGroup[]>;
     protected readonly fontSizes: number[];
     protected readonly fontColorPresets: string[];
     protected readonly highlightColorPresets: string[];
@@ -18364,6 +19924,17 @@ declare class RibbonHomeSectionComponent {
     private readonly loader;
     /** Layouts offered by the New Slide split button and the Layout menu. */
     protected readonly layoutOptions: _angular_core.Signal<RibbonLayoutOption[]>;
+    /** `layoutPath` of the active slide, marking the current gallery tile. */
+    protected readonly currentLayoutPath: _angular_core.Signal<string | undefined>;
+    /**
+     * Layout artwork for the gallery thumbnails, keyed by layout path.
+     *
+     * Parsing every layout part is only worth doing once a gallery is opened,
+     * so this stays empty until {@link loadLayoutPreviews} runs. Core memoises
+     * the parse, so reopening a menu costs nothing.
+     */
+    protected readonly layoutPreviews: _angular_core.WritableSignal<ReadonlyMap<string, PptxLayoutPreview>>;
+    constructor();
     readonly slideIndex: _angular_core.InputSignal<number>;
     readonly selectedElement: _angular_core.InputSignal<PptxElement | null>;
     readonly canEdit: _angular_core.InputSignal<boolean>;
@@ -18660,6 +20231,23 @@ declare class RibbonSlideshowSectionComponent {
     readonly toggleSubtitles: _angular_core.OutputEmitterRef<void>;
     readonly openSubtitleSettings: _angular_core.OutputEmitterRef<void>;
     protected readonly toolbar: ToolbarVisibility;
+    private readonly loader;
+    /**
+     * The Options cluster, split across the two columns PowerPoint uses. Both
+     * halves come from the shared descriptor list, so the set and its order stay
+     * identical across bindings.
+     */
+    protected readonly primaryOptions: SlideShowOptionDescriptor[];
+    protected readonly secondaryOptions: SlideShowOptionDescriptor[];
+    /** Whether an Options checkbox reads as ticked for the loaded deck. */
+    protected isOptionChecked(id: SlideShowOptionId): boolean;
+    /**
+     * Commit a tick/untick onto the deck's presentation properties, the same
+     * signal the inspector's PRESENTATION card patches and the show path reads.
+     * Unsupported options return no change from shared and are rendered disabled,
+     * so this is a no-op for them even if a click somehow arrives.
+     */
+    protected onOptionChange(id: SlideShowOptionId, event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonSlideshowSectionComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonSlideshowSectionComponent, "pptx-ribbon-slideshow-section", never, { "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; "showSubtitles": { "alias": "showSubtitles"; "required": false; "isSignal": true; }; "hiddenActions": { "alias": "hiddenActions"; "required": false; "isSignal": true; }; "activeSlideHidden": { "alias": "activeSlideHidden"; "required": false; "isSignal": true; }; }, { "presentFromBeginning": "presentFromBeginning"; "presentFromCurrent": "presentFromCurrent"; "presenter": "presenter"; "broadcast": "broadcast"; "openCustomShows": "openCustomShows"; "openSetUpSlideShow": "openSetUpSlideShow"; "toggleHideSlide": "toggleHideSlide"; "rehearseTimings": "rehearseTimings"; "record": "record"; "toggleSubtitles": "toggleSubtitles"; "openSubtitleSettings": "openSubtitleSettings"; }, never, never, true, never>;
 }
@@ -18679,26 +20267,39 @@ declare function transformSelectedTextCase(editor: EditorStateService, slideInde
 declare class RibbonTransitionsSectionComponent {
     private readonly editor;
     readonly slideIndex: _angular_core.InputSignal<number>;
-    readonly selectedTransition: _angular_core.InputSignal<PptxTransitionType>;
-    readonly transitionDurationSec: _angular_core.InputSignal<number>;
-    readonly present: _angular_core.OutputEmitterRef<void>;
     readonly toggleInspector: _angular_core.OutputEmitterRef<void>;
-    readonly transitionChange: _angular_core.OutputEmitterRef<PptxTransitionType>;
-    readonly durationChange: _angular_core.OutputEmitterRef<number>;
-    protected readonly transitionPresets: readonly {
-        value: PptxTransitionType;
-        labelKey: string;
-    }[];
-    protected readonly advanceOnClick: _angular_core.WritableSignal<boolean>;
-    protected readonly advanceAfter: _angular_core.WritableSignal<boolean>;
-    protected readonly advanceAfterSeconds: _angular_core.WritableSignal<string>;
-    /** Apply the chosen transition to the active slide. */
+    protected readonly transitionPresets: readonly RibbonTransitionPreset[];
+    /**
+     * The draft the user is editing, tagged with the slide it belongs to. Null
+     * until a control is touched, and abandoned as soon as the active slide
+     * changes, which is what makes the tab re-read the new slide.
+     */
+    private readonly edited;
+    /**
+     * What the tab's controls say: the live draft for THIS slide, otherwise the
+     * slide's own transition read back through shared. Keeping the untouched
+     * case derived from the deck is what stops the tab reporting the last preset
+     * the user clicked after they navigate away.
+     */
+    protected readonly draft: _angular_core.Signal<RibbonTransitionDraft>;
+    /** Replay the active slide's transition on the stage. Never writes. */
+    protected preview(): void;
+    /** Apply the chosen preset to the active slide. */
     protected setTransition(type: PptxTransitionType): void;
     protected onDurationChange(event: Event): void;
-    /** Apply the current transition to every slide in the deck. */
+    protected onAdvanceOnClick(event: Event): void;
+    protected onAdvanceAfter(event: Event): void;
+    protected onAdvanceAfterText(event: Event): void;
+    /** Apply the current draft to every slide in the deck. */
     protected applyToAll(): void;
+    /**
+     * Merge a control's change into the draft and write the resulting transition
+     * onto every targeted slide, preserving each slide's own direction / spokes /
+     * sound / raw XML through the shared merge.
+     */
+    private commit;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonTransitionsSectionComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonTransitionsSectionComponent, "pptx-ribbon-transitions-section", never, { "slideIndex": { "alias": "slideIndex"; "required": false; "isSignal": true; }; "selectedTransition": { "alias": "selectedTransition"; "required": false; "isSignal": true; }; "transitionDurationSec": { "alias": "transitionDurationSec"; "required": false; "isSignal": true; }; }, { "present": "present"; "toggleInspector": "toggleInspector"; "transitionChange": "transitionChange"; "durationChange": "durationChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonTransitionsSectionComponent, "pptx-ribbon-transitions-section", never, { "slideIndex": { "alias": "slideIndex"; "required": false; "isSignal": true; }; }, { "toggleInspector": "toggleInspector"; }, never, never, true, never>;
 }
 
 declare class RibbonViewSectionComponent {
@@ -18767,110 +20368,6 @@ declare function exitPresentationFullscreen(doc: Document | null | undefined): v
  */
 declare function hasExitedFullscreen(doc: Document | null | undefined): boolean;
 
-/**
- * presentation-overlay-helpers.ts
- *
- * Pure functions used by PresentationOverlayComponent.
- * Exported separately so they can be unit-tested without TestBed.
- */
-
-/**
- * Whether a click/tap/swipe advance must be swallowed instead of moving to the
- * next slide. A click still steps the current slide's remaining animation
- * builds, so this only blocks once they are exhausted (`playbackComplete`) and
- * only when the slide's transition sets advanceOnClick to false. Keyboard and
- * the on-screen next/prev buttons never consult this.
- */
-declare function shouldBlockClickAdvance(playbackComplete: boolean, slide: PptxSlide | undefined): boolean;
-/**
- * Delay in ms before the show steps to the next slide on its own, or
- * `undefined` when the current slide waits for input.
- *
- * The counterpart to {@link shouldBlockClickAdvance}: PowerPoint's
- * `p:transition/@advTm` ("Advance slide: After <n>"). A slide authored
- * `advClick="0" advTm="…"` is advanced ONLY by this timer, so honouring the
- * click gate without also arming the timer strands the show on that slide with
- * no visible response to any input. Nothing is scheduled once the end-of-show
- * screen is up, or when the show is set to advance manually.
- */
-declare function resolveSlideAutoAdvanceMs(slide: PptxSlide | undefined, useTimings: boolean, endOfShow: boolean): number | undefined;
-/**
- * Attach the show's visibility pause: while the tab is hidden the shared
- * handler pauses the stage's playing media and the cross-slide persistent
- * audio, and the binding-provided callbacks cancel / re-arm the timed
- * auto-advance so the deck does not run on unseen. Returns the detach
- * function. Kept TestBed-free so the wiring can be unit-tested directly.
- */
-declare function attachShowVisibilityPause(deps: {
-    /** The overlay root containing the stage; only media inside it is paused. */
-    root: ParentNode | undefined;
-    /** Cancel the pending auto-advance timer (the tab was hidden). */
-    cancelAutoAdvance: () => void;
-    /** Re-arm the auto-advance timer for the current slide (tab visible again). */
-    rearmAutoAdvance: () => void;
-}): () => void;
-/**
- * The show has ENDED (never a slide change): stop and remove all cross-slide
- * "play across slides" persistent audio. Called by the host's exit paths
- * (`closePresentation` / `exitPresenter`), not by the overlay's own destroy,
- * because swapping to the presenter console destroys the overlay while the
- * show, and its background audio, carry on.
- */
-declare function endShowMediaCleanup(): void;
-/**
- * Clamp `index` to the valid range [0, count - 1].
- * Returns 0 when `count` is 0 to avoid -1 states.
- */
-declare function clampIndex(index: number, count: number): number;
-/**
- * Return the next visible (non-hidden) slide index after `current`.
- * Wraps around to `current` if no subsequent visible slide exists.
- *
- * Thin adapter over the shared show-order rule: Angular used to own this logic
- * outright, which is exactly why the other four bindings presented hidden
- * slides. Kept as a named export because the overlay's tests and the navigator
- * read better in terms of "next visible slide" than raw index lists.
- */
-declare function nextVisibleIndex(current: number, slides: readonly PptxSlide[]): number;
-/**
- * Return the previous visible (non-hidden) slide index before `current`.
- * Returns `current` when no earlier visible slide exists: PowerPoint never
- * wraps backward off the first slide.
- */
-declare function prevVisibleIndex(current: number, slides: readonly PptxSlide[]): number;
-/**
- * Compute the zoom level that fits a canvas of `canvasW × canvasH` pixels
- * into a viewport of `vw × vh` pixels, preserving aspect ratio.
- *
- * Returns 1 as a safe fallback when any dimension is zero or negative.
- */
-declare function fitZoom(canvasW: number, canvasH: number, vw: number, vh: number): number;
-/**
- * Whether a visible (non-hidden) slide exists strictly AFTER `current`.
- *
- * `nextVisibleIndex` wraps, which would make a show loop for ever. PowerPoint
- * only loops when "Loop continuously until Esc" is set; otherwise running past
- * the last slide ends the show. Callers use this to tell "there is a next
- * slide" from "we just wrapped".
- */
-declare function hasVisibleSlideAfter(current: number, slides: readonly PptxSlide[]): boolean;
-/** The show's first visible slide (Home), or 0 for an empty deck. */
-declare function firstVisibleIndex(slides: readonly PptxSlide[]): number;
-/** The show's last visible slide (End), or 0 for an empty deck. */
-declare function lastVisibleIndex(slides: readonly PptxSlide[]): number;
-/**
- * Style record centring the scaled slide stage in the viewport.
- *
- * The offsets are computed numerically ((viewport - scaled size) / 2, exactly
- * how React's PresentationStage centres) rather than with the historical
- * `left/top: 50%` + `translate(-50%, -50%)`: a transform makes the stage a
- * stacking context, which trapped every z-index inside it (the ink annotation
- * overlay in particular) BELOW the sibling blackout sheet, so blackboard
- * strokes painted invisibly under the black screen. See the shared
- * `render/presentation-blackboard` module for the layering rules.
- */
-declare function presentationStageStyle(size: CanvasSize, zoom: number, viewportW: number, viewportH: number): Record<string, string>;
-
 /**
  * touch-gestures.ts: thin Angular adapter over the framework-agnostic
  * `createTouchGestureRecognizer` from `pptx-viewer-shared`.
@@ -19117,6 +20614,15 @@ declare class MediaRendererComponent {
     readonly interactive: _angular_core.InputSignal<boolean>;
     /** Keep the data-pptx-element marker on interaction-locked template elements. */
     readonly marked: _angular_core.InputSignal<boolean>;
+    /**
+     * When true (default), the rendered node carries `data-element-id`. The
+     * miniature surfaces that paint every slide at once turn it off so one
+     * element id resolves to exactly one node in the document; see
+     * `ElementRendererComponent.exposeElementId`.
+     */
+    readonly exposeElementId: _angular_core.InputSignal<boolean>;
+    /** `data-element-id` for this element, or null on a miniature surface. */
+    readonly elementIdAttr: _angular_core.Signal<string | null>;
     /**
      * `pointer-events: none` while not interactive, mirroring React's
      * `pointer-events-none` class. {@link marked} keeps the element findable via
@@ -19178,7 +20684,7 @@ declare class MediaRendererComponent {
     readonly captionTracks: _angular_core.Signal<ResolvedCaptionTrack[]>;
     readonly clrChangeParams: _angular_core.Signal<ClrChangeParams | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<MediaRendererComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MediaRendererComponent, "pptx-media-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "required": false; "isSignal": true; }; "placeholderLabel": { "alias": "placeholderLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MediaRendererComponent, "pptx-media-renderer", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "mediaDataUrls": { "alias": "mediaDataUrls"; "required": false; "isSignal": true; }; "zIndex": { "alias": "zIndex"; "required": false; "isSignal": true; }; "interactive": { "alias": "interactive"; "required": false; "isSignal": true; }; "marked": { "alias": "marked"; "required": false; "isSignal": true; }; "exposeElementId": { "alias": "exposeElementId"; "required": false; "isSignal": true; }; "presenting": { "alias": "presenting"; "required": false; "isSignal": true; }; "placeholderLabel": { "alias": "placeholderLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 /**
@@ -19388,10 +20894,10 @@ declare class RemoteSelectionOverlayComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RemoteSelectionOverlayComponent, "pptx-remote-selection-overlay", never, { "presences": { "alias": "presences"; "required": false; "isSignal": true; }; "elements": { "alias": "elements"; "required": false; "isSignal": true; }; "activeSlideIndex": { "alias": "activeSlideIndex"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/** Payload of `renameElement`: `undefined` clears the element's name. */
+/** Payload of `renameElement`: an empty `name` clears the element's name. */
 interface SelectionPaneRename {
     id: string;
-    name: string | undefined;
+    name: string;
 }
 declare class SelectionPaneComponent {
     /** All elements on the active slide. */
@@ -19406,7 +20912,7 @@ declare class SelectionPaneComponent {
     readonly sendBackward: _angular_core.OutputEmitterRef<string>;
     /** Emits the id of the element whose hidden flag should be toggled. */
     readonly toggleHidden: _angular_core.OutputEmitterRef<string>;
-    /** Emits the rename commit; `name: undefined` clears the element's name. */
+    /** Emits the rename commit; an empty `name` clears the element's name. */
     readonly renameElement: _angular_core.OutputEmitterRef<SelectionPaneRename>;
     /** Elements reversed so the topmost (last in array) appears first in the list. */
     protected readonly reversedElements: _angular_core.Signal<readonly PptxElement[]>;
@@ -19439,6 +20945,13 @@ declare class ThemeGalleryComponent {
      */
     readonly activeName: _angular_core.InputSignal<string | undefined>;
     readonly theme: _angular_core.InputSignal<PptxTheme | undefined>;
+    /**
+     * Which face the gallery opens on: the preset grid (false) or the theme
+     * editor (true). Design > Edit Theme names the editor, so it opens straight
+     * into it rather than making the user find the footer's customise button.
+     * Only consulted as the overlay opens; the footer button still flips freely.
+     */
+    readonly startCustomizing: _angular_core.InputSignal<boolean>;
     /** Emitted when the user confirms a selection. */
     readonly applyTheme: _angular_core.OutputEmitterRef<PptxThemePreset>;
     readonly applyCustomTheme: _angular_core.OutputEmitterRef<CustomThemeEdit>;
@@ -19448,11 +20961,12 @@ declare class ThemeGalleryComponent {
     /** The currently highlighted (not yet applied) preset, or null. */
     protected readonly selected: _angular_core.WritableSignal<PptxThemePreset | null>;
     protected readonly customizing: _angular_core.WritableSignal<boolean>;
+    constructor();
     protected selectPreset(preset: PptxThemePreset): void;
     protected applySelected(): void;
     protected onBackdropClick(event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeGalleryComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeGalleryComponent, "pptx-theme-gallery", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "activeName": { "alias": "activeName"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; }, { "applyTheme": "applyTheme"; "applyCustomTheme": "applyCustomTheme"; "close": "close"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeGalleryComponent, "pptx-theme-gallery", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "activeName": { "alias": "activeName"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "startCustomizing": { "alias": "startCustomizing"; "required": false; "isSignal": true; }; }, { "applyTheme": "applyTheme"; "applyCustomTheme": "applyCustomTheme"; "close": "close"; }, never, never, true, never>;
 }
 
 declare class TitleBarComponent {
@@ -19633,5 +21147,6 @@ declare function thumbnailHeight(canvasW: number, canvasH: number, thumbW: numbe
  */
 declare function gridColumns(containerW: number, thumbW: number, gap: number, maxCols: number): number;
 
-export { ALIGN_OPTIONS, ANIMATION_PRESET_CATEGORIES, AUDIENCE_HASH, AUDIENCE_NONCE_KEY, AVATAR_COLOR_SWATCHES, AXIS_LABEL_COLOR, AccessibilityPanelComponent, AccessibilityService, AccountPageComponent, ActionSettingsPanelComponent, AdvancedChartEditorComponent, AiChangeOverlayComponent, AiChatPanelComponent, AiChatService, AiComposerComponent, AiFocusBarComponent, AiFocusHighlightOverlayComponent, AiHistoryMenuComponent, AiHistoryService, AiMessageListComponent, AiPanelStore, AiProposalCardComponent, AiSettingsSectionComponent, AiToolCallCardComponent, AnimationAuthorPanelComponent, AnimationPanelComponent, AnimationPlaybackService, AutosaveService, BroadcastDialogComponent, CHART_EDITOR_STYLES, CURSOR_PALETTE, CanvasFitService, ChartAxisOptionsComponent, ChartAxisStyleOptionsComponent, ChartComboTypeOptionsComponent, ChartDataEditorComponent, ChartDataLabelOptionsComponent, ChartDatapointMarkerOptionsComponent, ChartDatapointOptionsComponent, ChartDisplayOptionsComponent, ChartElementViewComponent, ChartErrorBarOptionsComponent, ChartMarkerOptionsComponent, ChartPartSelectionService, ChartPrimitivesComponent, ChartRendererComponent, ChartTrendlineOptionsComponent, CollaborationCursorsComponent, CollaborationService, ColorChangedImageComponent, CommentMarkersOverlayComponent, CommentsPanelComponent, CommentsService, ComparePanelComponent, ConnectorRendererComponent, ConnectorTextOverlayComponent, CustomShowsComponent, DATA_TABLE_HEADER_H, DATA_TABLE_KEY_W, DATA_TABLE_PADDING, DATA_TABLE_ROW_H, DEFAULT_BOUNDS, DEFAULT_BROADCAST_SERVER_URL, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_COLOR_SCHEME, DEFAULT_FILL_COLOR, DEFAULT_LAYOUT, DEFAULT_PALETTE$1 as DEFAULT_PALETTE, DEFAULT_PATTERN_FILL_PRESET, DEFAULT_PRINT_SETTINGS, DEFAULT_SLIDE_BACKGROUND, DEFAULT_STROKE_COLOR, DEFAULT_STYLE, DEFAULT_TABLE_ROW_HEIGHT, DEFAULT_TEXT_COLOR, DEFAULT_VIEWER_PROFILE, DIRECTIONAL_PRESETS, DIRECTION_OPTIONS, DocumentPropertiesCardComponent, EMBEDDED_FONTS_STYLE_ID, EMPHASIS_PRESETS, ENTRANCE_PRESETS, TEMPLATES as EQUATION_TEMPLATES, EXIT_PRESETS, EditorContextMenuComponent, EditorHistory, EditorStateService, EditorToolbarComponent, EffectsPanelComponent, ElementRendererComponent, EmbeddedFontsService, EncryptedFileDialogComponent, EquationEditorDialogComponent, EquationRendererComponent, EquationTemplateGalleryComponent, ExportProgressModalComponent, ExportService, FieldContextService, FindBarComponent, FindReplaceBarComponent, FollowModeBarComponent, FontEmbeddingListComponent, FontEmbeddingPanelComponent, GALLERY_THEME_PRESETS, GRIDLINE_COLOR, GradientPickerComponent, HANDOUT_OPTIONS, HeaderFooterDialogComponent, HyperlinkDialogComponent, ImagePropertiesPanelComponent, InkDrawingService, InkRendererComponent, InsertSmartArtDialogComponent, InspectorPaneHeaderComponent, InspectorPanelComponent, IsMobileService, KeepAnnotationsDialogComponent, LOCALE_CATALOG, LONG_PRESS_DURATION_MS, LONG_PRESS_MOVE_TOLERANCE_PX, LoadContentService, LocalPresencePublisher, MAX_ZOOM_SCALE, MIN_ZOOM_SCALE, MOTION_PATH_COLUMNS, MediaPreviewComponent, MediaPropertiesPanelComponent, MediaRendererComponent, MediaTrimTimelineComponent, MobileBottomBarComponent, MobileMenuSheetComponent, MobilePresenterViewComponent, MobileSheetComponent, MobileSlidesSheetComponent, MobileToolbarComponent, ModalDialogComponent, Model3DRendererComponent, NotesHandoutCardComponent, NotesPanelComponent, NotesToolbarComponent, OleRendererComponent, OutlineViewOverlayComponent, POWER_POINT_VIEWER_PROVIDERS, PRESENTER_CHANNEL_NAME, PRESENTER_MSG_ORIGIN, PRESENTER_TIMER_SEGMENT_MS, PX_PER_CM, PX_PER_INCH, PasswordProtectionDialogComponent, PasswordStrengthMeterComponent, PowerPointViewerComponent, PresentToolbarAutoHide, PresentationAnnotationOverlayComponent, PresentationAnnotationsService, PresentationOverlayComponent, PresentationPropertiesPanelComponent, PresentationSettingsCardComponent, PresentationSubtitleBarComponent, PresentationToolbarComponent, PresentationTransitionOverlayComponent, PresenterViewComponent, PresenterWindowService, PrintDialogComponent, PrintService, PrintSettingsPanelComponent, PropertiesDialogComponent, REPEAT_MODE_OPTIONS, RESIZE_HANDLES, RULER_FONT_SIZE, RULER_THICKNESS, ReadingViewOverlayComponent, RemoteSelectionOverlayComponent, RibbonAnimationGalleryComponent, RibbonAnimationsSectionComponent, RibbonArrangeSectionComponent, RibbonColorPopoverComponent, RibbonComponent, RibbonDesignSectionComponent, RibbonDrawSectionComponent, RibbonDrawingGroupComponent, RibbonEditingSectionComponent, RibbonFileSectionComponent, RibbonFontControlsComponent, RibbonHomeSectionComponent, RibbonHyperlinkButtonComponent, RibbonInsertFieldsComponent, RibbonInsertSectionComponent, RibbonMotionPathGalleryComponent, RibbonParagraphControlsComponent, RibbonPrimaryRowComponent, RibbonReviewSectionComponent, RibbonShapeExtrasComponent, RibbonSlideshowSectionComponent, RibbonTransitionsSectionComponent, RibbonViewSectionComponent, RulerGuidesService, SEQUENCE_OPTIONS, SEVERITY_GROUPS, SEVERITY_LABELS, SHORTCUT_REFERENCE_ITEMS, SLIDE_TRANSITION_KEYFRAMES, DEFAULT_PALETTE as SMARTART_DEFAULT_PALETTE, PALETTES as SMARTART_PALETTES, SMART_ART_COLOR_SCHEMES, SMART_ART_STYLE_OPTIONS, SUB_ITEM_LABEL, SVG_WARP_PRESETS, SWIPE_MAX_VERTICAL_PX, SWIPE_THRESHOLD_PX, SelectionPaneComponent, SetUpSlideShowDialogComponent, SettingsAppearanceTabComponent, SettingsDialogComponent, SettingsLanguageTabComponent, ShareDialogComponent, ShortcutPanelComponent, ShowOptionsFieldsetComponent, ShowSlidesFieldsetComponent, SignatureStrippedDialogComponent, SignaturesPanelComponent, SignaturesService, SlideBackgroundCardComponent, SlideCanvasComponent, SlideDefaultInspectorComponent, SlideDiffChangesComponent, SlideDiffRowComponent, SlideDiffThumbnailsComponent, SlideSizeCardComponent, SlideSorterOverlayComponent, SlideThemeOverridePanelComponent, SlideTransitionCardComponent, SlidesPanelComponent, SmartArt3DRendererComponent, SmartArt3DService, SmartArtPreviewComponent, SmartArtPropertiesComponent, SmartArtRendererComponent, StatusBarComponent, TABLE_STRUCTURE_TOGGLES, TEXT_3D_BOTTOM_BEVEL_KEYS, TEXT_3D_TOP_BEVEL_KEYS, TEXT_DIRECTION_OPTIONS, THEME_CATALOG, TIMING_CURVE_OPTIONS, TRIGGER_OPTIONS, TYPE_LABELS, TableCellAdvancedFillComponent, TableCellFormattingComponent, TableDataEditorComponent, TablePropertiesComponent, TableRendererComponent, TableResizeOverlayComponent, TableSelectionService, TagsCardComponent, Text3DBevelSectionComponent, Text3DPanelComponent, TextAdvancedPanelComponent, ThemeEditorFieldsComponent, ThemeGalleryComponent, ThemeSelectorCardComponent, TitleBarComponent, TitleBarSearchComponent, TransitionDirectionPickerComponent, TransitionPreviewComponent, VALIGN_OPTIONS, VIEWER_THEME, VersionHistoryPanelComponent, ViewerCanvasEditingService, ViewerCollabCursorService, ViewerCollaborationSessionService, ViewerCompareService, ViewerCustomShowsService, ViewerDialogsService, ViewerDocumentPropertiesService, ViewerExportService, ViewerExtraDialogsComponent, ViewerFileIOService, ViewerFindReplaceService, ViewerFormatPainterService, ViewerInspectorPanelService, ViewerKeyboardService, ViewerMobileSheetService, ViewerPresentationModeService, ViewerThemeGalleryService, ViewerTouchGesturesService, ViewerZoomService, WEBM_MIME_CANDIDATES, WriteBackScheduler, ZERO_LINE_COLOR, ZoomNavigationService, ZoomRendererComponent, ZoomTargetService, addCategory, addCommentToList, addGradientStopPatch, addItem, addSeries, addSubItem, advanceStep, affordanceElements, aiToggleVisible, alignPatch, animationFor, animationPresetLabelKey, annotationMapToInkInserts, applyAcceptedDiff, applyAnimationPreset, applyFindReplacements, applyFormatToElement, applyMove, applyResize, applyTableStylePreset, asMediaElement, assignUserColor, attachShowVisibilityPause, attachTouchGestures, axisTickValues, beginNodeEdit, bevelSizePatch, boolFromEvent, bringForward, bringToFront, buildBarActions, buildBroadcastConfig, buildBroadcastViewerUrl, buildCategoryLabels, buildCellParagraphs, buildChartViewModel, buildChatLogExport, buildChatLogMarkdown, buildChromeStyle, buildClearHyperlinkPatch, buildClickGroups, buildColStyles, buildCollaborationConfig, buildComboViewModel, buildCssGradientFromShapeStyle, buildDuotoneFilter, buildDuotoneFilterId, buildEmbeddedFontStyles, buildEquationElement, buildEquationSegment, buildFallbackViewModel, buildFontFaceRule, buildGradientFillCss, buildGridlinesAndLabels, buildHyperlinkPatch, buildInkContainerStyle, buildInkStrokes, buildLegend, buildModel3DContainerStyle, buildModel3DViewModel, buildOleActionModel, buildOleInfoRows, buildPatternFillCss, buildPrintHtmlDocument as buildPrintDocument, buildPropertiesPatch, buildRegionMapViewModel, buildSaveSlides, buildShareUrl, buildSmartArtInsertElement, buildSmartArtNodes, buildStockViewModel, buildSurfaceViewModel, buildTableViewModel, buildTreemapViewModel, buildTrimFragment, buildWaterfallViewModel, buildZeroLine, buildZoomContainerStyle, buildZoomViewModel, bulletIndentPx, canAddTopLevelNode, canGroupSelection, canRemoveTopLevelNode, canSetStrokeWidth, canStartBroadcast, canStartShare, canUngroupSelection, canUseClipboard, captionDisplayText, cellRunStyle, cellStyleToStyleMap, cellTdStyle, changeCountLabel, changeIcon, characterSpacingPatch, checkFontAvailable, clampCursorPosition, clampGifDimensions, clampIndex, clampNotesFontSize, clampScale, clampStep, clearAllLocalViewerData, clearAudienceContent, cn, collectAccessibilityIssues, collectElementText, collectSlideText, collectStoredChats, collectUsedFontFamilies, columnWidthStyle, commitNodeText, computeAlign, computeAxisTitlePrimitives, computeBarRects, computeBubbleRadius, computeCornerHandle, computeDataTablePrimitives, computeDistribute, computeDrawingViewBox, computeErrorBarPrimitives, computeFocusTargets, computeHandleBoxes, computeHandoutLayout, computeIsMobile, computeIsTablet, computeLinePoints, computeLinearRegression, computePageCount, computePieLayout, computePieSlicePath, computePieSlices, computePlotLayout, computeRSquared, computeRadarPoints, computeScatterDots, computeSelectionBoxes, computeSingleSelected, computeSlideIndices, computeSnap, computeStackedBarRects, computeStackedValueRange, computeTrendlinePrimitives, computeValueRange, convertOmmlToMathMl, copyFormatFromElement, countAccessibilityIssues, countAnnotationStrokes, createAngularAiBridge, createCustomShow, createSwipeDismissDrag, createWebrtcBundle, createWebsocketBundle, cssObjectToStyleMap, currentColorScheme, currentLayout, currentStyle, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, deleteVersion as deleteRecoveryVersion, demoteNode, deriveModel3DBlobUrl, derivePresenceList, describeSmartArtBounds, disableGlowPatch, disableInnerShadowPatch, disableOuterShadowPatch, disableReflectionPatch, disableSoftEdgePatch, duplicateElementById, durationOf, effectsStateOf, enableGlowPatch, enableInnerShadowPatch, enableOuterShadowPatch, enableReflectionPatch, enableSoftEdgePatch, encodeGif, endShowMediaCleanup, estimatePageCount, evenColumnWidths, evenRowHeights, exitPresentationFullscreen, exportAiChatLogs, extractPathPoints, eyedropperAvailable, fillColorOf, findInSlides, findOwningSlideIndex, findSlideIndexByElementId, firstVisibleIndex, fitPolynomial, fitZoom, focusTargetChips, fontMimeForFormat, fontSizeOf, forgetSessionDeck, formatAutoNumber, formatAxisValue, formatBytes, formatCursorLabel, formatElapsed, formatFileSize, formatPropertyDate, formatTime, fpsToFrameIntervalMs, generateBroadcastRoomId, generateCommentId, generateCustomShowId, generatePressureCircles, generateTicks, getClrChangeParams, getContainerStyle, getDuotoneFilterDef, getImageSrc, getLocalStorageUsageSummary, getOleAriaLabel, getOleBadgeLabel, getOleDisplayName, getOleDownloadFileName, getOleTypeColor, getOleTypeLabel, getPasswordStrength, getPatternSvg, getPlaceholderStyle, getVersions as getRecoveryVersions, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getSessionTabId, getShapeFillStrokeStyle, getSlideBackgroundStyle, getSlideTransitionAnimations, getSmartArtNodeBounds, getSpeechRecognitionCtor, getTextBlockStyle, getTextWarp, getTouchDistance, getWarpCategory, getWarpPath, gradientStateFromStyle, gradientStateOf, gradientStatePatch, gridColumns, groupElements, groupIssuesBySeverity, hasAnimation, hasCopyableFormat, hasExistingLink, hasExitedFullscreen, hasGradientFill, hasPressureVariation, hasVisibleSlideAfter, headerLabel, imageDimensions, inkViewBox, insertTableElementColumn as insertColumn, insertTableElementRow as insertRow, interpolateWidth, isAudienceTab, isBold, isBrowserOpenableMime, isChildNode, isElementInteractive, isInjectableUrl, isItalic, isPpactionUrl, isPresenterMessage, isSigned, isTextElement, isTwoTableFocus, isUnderline, isUrlSafe, isValidRoomId, isViewportBackgroundPressTarget, isZoomActivationKey, issueTrackKey, issueTypeLabel, keyToLabel, lastVisibleIndex, latexToMathml, linePointsToSvgString, lineSpacingPatch, loadAudienceContent, loadSessionDeck, mediaFallbackFor, mediaSurfaceFor, mergeCaptionResults, mergeDown, mergeRight, mergeSelection, moveElementBy, moveNodeDown, moveNodeUp, msToFrameDelayCs, narrowToCircle, narrowToPolygon, narrowToRect, newChartElement, newEquationElement, newPresetShapeElement, newShapeElement, newSmartArtElement, newTableElement, newTextElement, nextVisibleIndex, nodeBold, nodeEditBox, nodeFillColor, nodeFontColor, nodeIdFromKey, nodeItalic, nodeStyle, normalizeFontFormat, normalizeSlidesPerPage, normalizeValue, numFromEvent, ommlToMathml, ooxmlDashToCssBorderStyle, openNativeEyeDropper, overallStatus, paletteColor, parseAudienceNonce, parseNodeTextarea, partitionSlides, patchChartData, patchChartStyle, patchTableData, patchTextStyle, patternPresetOptions, pendingElementStyles, pickColorByClickFallback, pickFile, pickSupportedMimeType, planGifFrames, planVideoSegments, pointsToSvgPathD, presenceToCursors, presentationStageStyle, presenterTimerProgress, presetByLayout, presetsForCategory, pressuresToWidths, prevVisibleIndex, projectDrawingShapes, promoteNode, provideViewerTheme, radarAngle, radarRingPoints, readAsDataUrl, recordWebm, redistributeColumnWidth, registerCrossSlideAudio, rememberSessionDeck, removeAnimation, removeCategory, removeTableElementColumn as removeColumn, removeCommentFromList, removeElementAnimation, removeGradientStopPatch, removeNode, removeTableElementRow as removeRow, removeSeries, renderToCanvas, reorderAnimationDown, reorderAnimationUp, replaceInSlides, replaceMatch, requestPresentationFullscreen, resizeElement, resolveCaptionTracks, resolveChartKind, resolveFontVariant, resolveHyperlinkHref, resolveInteractiveElementId, resolveMediaSrc, resolveOleType, resolveParagraphBullet, resolvePresenterNotes, resolveProfileInitial, resolveRegionCode, resolveSlideAutoAdvanceMs, resolvePalette as resolveSmartArtPalette, resolveThemeCatalogEntry, resolveTransitionDuration, restoreSessionDeck, revealedElementStyles, routeOrthogonalConnector, rowStyle, rulerDragToGuidePosition, rulerHighlight, rulerStripTicks, sampleColorFromSlide, sanitizeColor, sanitizeSlideIndex, sanitizeUserName, saveViewerProfile, scanAvailableFonts, searchSlides, seedBroadcastFields, seedHyperlinkDraft, seedPropertiesDraft, seedShareFields, segmentFrameCount, selectValue, sendBackward, sendToBack, sequentialColorScale, serializeWriteBack, seriesColor, setAnimationEmphasis, setAnimationEntrance, setAnimationExit, setAxis, setAxisLogScale, setAxisTitleStyle, setCategoryLabel, setCellText, setColorScheme, setDataLabels, setDataPointExplosion, setDataPointFill, setDataPointLabel, setDataPointMarker, setDelay, setDirection, setDuration, setElementPosition, setGridlineStyle, setLayout, setLegend, setNodeStyle, setNodeText, setRepeatCount, setRepeatMode, setSequence, setSeriesChartType, setSeriesColor, setSeriesErrorBars, setSeriesMarker, setSeriesName, setSeriesTrendline, setSeriesValue, setStyle, setTimingCurve, setTitle, setTrigger, setTriggerShapeId, shapeStylePatch, sheetAfterNavigate, shouldBlockClickAdvance, shouldUseSvgWarp, showDirectionPicker, showsTemplateAffordance, signatureCountLabel, signatureKey, signatureTimestamp, signerName, statusLabel as slideDiffStatusLabel, slideNumberOf, slidesWithReappliedLayout, smartArtNodes, paletteColour as smartArtPaletteColour, snapToGridStep, splitCursorCell, splitMergedCell, statusKind, statusLabel$1 as statusLabel, storeAudienceContent, stringFromEvent, strokeColorOf, strokeToInkElement, strokeWidthOf, styleShadowFilter, textAdvancedPatch, textAdvancedStateFromStyle, textAdvancedStateOf, textColorOf, textDirectionPatch, textStyleOf, textStylePatch, themeStyle, themeToCssVars, thumbnailHeight, thumbnailZoom, toggleCommentResolvedInList, toggleNodeBold, toggleNodeItalic, toggleSheet, topLevelNodeCount, transformSelectedTextCase, translationsEn, ungroupElements, updateElementById, updateGlowPatch, updateGradientStopPatch, updateInnerShadowPatch, updateOuterShadowPatch, updateReflectionPatch, vAlignPatch, validatePassword, validatePrintSettings, validateRoomId, valueToY, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius, waypointsToPathD, worstStatus, zoomTargetSlideIndex };
-export type { AccessibilityIssueGroup, AccountAuthConfig, ActionDescriptor, AiCanvasHighlight, AiChatInitState, AiHistoryInitDeps, AiLogChat, AiLogExport, AiLogFormat, AiLogMessage, AiPanelSelectionAccessors, AlignBox, AlignMode, AnimationClickGroup, AnimationGroup, AnimationPresetCategory, AnimationPresetEntry, AnimationPresetPick, AnnotationInkInsert, AnnotationStroke, AttachTouchGesturesConfig, AwarenessLike, BarRect, Box, BridgeDeps, BroadcastConfig, BroadcastDefaults, CSSProperties, CanvasSize, CellCoord, CellParagraph, CellTextRun, ChartPartRef, ChartPartSelection, ChartValueDrag, ChartViewModel, ClassValue, ClrChangeParams, CollaborationConfig, CollaborationRole, RouterRect as ConnectorObstacle, RouterPoint as ConnectorPoint, ConnectorRouting, CopiedFormat, CornerHandleBox, CustomShow, CustomThemeEdit, DestroyableYDoc, DiagonalBorderInfo, DistributeMode, DocumentProperties, DrawingViewBox, DuotoneFilterDef, EffectsState, EmbeddedFontStyles, EquationTemplate, EyedropperResult, FindOptions, FindResult, FocusChip, FocusSelectionInput, GifFrame, GifFramePlan, GifPlanOptions, GlowState, GradientState, GradientStop$1 as GradientStop, GroupResult, HandleBox, HandoutSlidesPerPage, HyperlinkDraft, InkPoint, InkStroke, InlineEditState, InnerShadowState, LegendEntry, LinePoint, LinearFit, LocalIdentity, LocalStorageUsageSummary, LocaleCatalogEntry, MobileSheetKey, Model3DViewModel, MotionPathColumn, MotionPathEntry, NodeEditBox, NotesSegmentViewModel, ObjectUrlFactory, OleActionModel, OleInfoRow, OuterShadowState, OutlineCommit, OverallSignatureStatus, PartitionedSlides, PathPoint, PieSliceGeometry, PieSliceOptions, PlotLayout, PlotLayoutOptions, PositionUpdate, PowerPointViewerAPI, PptxAiBridge, PptxAiConfig, PptxAiConnection, PptxAiContextStrategy, PptxAiElementUpdate, PptxAiToolName, PptxAiUIMessage, PptxAiWritePolicy, PresentToolbarAction, PresentationTool, PresenterExitMessage, PresenterMessage, PresenterNotes, PresenterSlideChangeMessage, PresenterTimerProgress, PressureCircle, PrintColorMode, PrintHtmlDocumentOptions as PrintDocumentOptions, PrintOrientation, PrintSettings, PrintSlideRange, PrintWhat, PropertiesDraft, ProposalView, ProviderBundle, ProviderLike, RadarPoint, RecordWebmOptions, RecoveryVersion, ReflectionState, RemoteCursor, SanitizedPresence as RemotePresence, RenderedShape, ReplaceResult, ResizeHandle, ResolvedCaptionTrack, ResolvedFontVariant, ResolvedOleType, RulerUnit, ScatterDot, SelectionBox, SessionDeck, ShapeStyleChanges, ShareDefaults$1 as ShareDefaults, ShareFormFields, ShortcutReferenceItem, SignatureStatusKind, SlideInspectorTab, SlideTransitionAnimations, SmartArtInsertEvent, SmartArtNodeBounds, SnapBox, SnapGuide, SnapResult, SoftEdgeState, SpeechAlternative, SpeechRecognitionCtor, SpeechRecognitionEventLite, SpeechRecognitionLite, SpeechResult, SpeechResultList, SpeechSupportState, StagedProposal, StrokeToInkElementOpts, StyleMap, SupportedChartKind, SvgAreaGradient, SvgCircle, SvgLine, SvgPath, SvgPolygon, SvgPolyline, SvgPrimitive, SvgRect, SvgText, SwipeDismissDrag, TableBooleanFlag, TableCellSelection, TableCellViewModel, TableRowViewModel, TemplateElementsBySlideId, Text3DBevelKeys, TextAdvancedChanges, TextAdvancedState, TextStyleChanges, TextWarpCssDef, TextWarpDef, TextWarpPathDef, ThemeCatalogEntry, Tick, ToolbarActionId, TouchGestureCallbacks, TranslationKey, UngroupResult, ValueRange, VideoPlanOptions, VideoSegmentPlan, ViewerMode, ViewerProfile, ViewerSettings, ViewerTheme, ViewerThemeColors, ZoomTranslate, ZoomViewModel };
+export { ALIGN_OPTIONS, ANIMATION_PRESET_CATEGORIES, AUDIENCE_HASH, AUDIENCE_NONCE_KEY, AVATAR_COLOR_SWATCHES, AXIS_LABEL_COLOR, AccessibilityPanelComponent, AccessibilityService, AccountPageComponent, ActionSettingsPanelComponent, AdvancedChartEditorComponent, AiChangeOverlayComponent, AiChatPanelComponent, AiChatService, AiComposerComponent, AiFocusBarComponent, AiFocusHighlightOverlayComponent, AiHistoryMenuComponent, AiHistoryService, AiMessageListComponent, AiPanelStore, AiProposalCardComponent, AiSettingsSectionComponent, AiToolCallCardComponent, AnimationAuthorPanelComponent, AnimationPanelComponent, AnimationPlaybackService, AutosaveRecoveryDialogComponent, AutosaveService, BroadcastDialogComponent, CHART_EDITOR_STYLES, CURSOR_PALETTE, CanvasFitService, ChartAxisOptionsComponent, ChartAxisStyleOptionsComponent, ChartComboTypeOptionsComponent, ChartDataEditorComponent, ChartDataLabelOptionsComponent, ChartDatapointMarkerOptionsComponent, ChartDatapointOptionsComponent, ChartDisplayOptionsComponent, ChartElementViewComponent, ChartErrorBarOptionsComponent, ChartMarkerOptionsComponent, ChartPartSelectionService, ChartPrimitivesComponent, ChartRendererComponent, ChartTrendlineOptionsComponent, CollaborationCursorsComponent, CollaborationService, ColorChangedImageComponent, CommentMarkersOverlayComponent, CommentsPanelComponent, CommentsService, ComparePanelComponent, ConnectorRendererComponent, ConnectorTextOverlayComponent, CustomShowsComponent, DATA_TABLE_HEADER_H, DATA_TABLE_KEY_W, DATA_TABLE_PADDING, DATA_TABLE_ROW_H, DEFAULT_BOUNDS, DEFAULT_BROADCAST_SERVER_URL, DEFAULT_CANVAS_HEIGHT, DEFAULT_CANVAS_WIDTH, DEFAULT_COLOR_SCHEME, DEFAULT_FILL_COLOR, DEFAULT_LAYOUT, DEFAULT_PALETTE$1 as DEFAULT_PALETTE, DEFAULT_PATTERN_FILL_PRESET, DEFAULT_PRINT_SETTINGS, DEFAULT_SLIDE_BACKGROUND, DEFAULT_STROKE_COLOR, DEFAULT_STYLE, DEFAULT_TABLE_ROW_HEIGHT, DEFAULT_TEXT_COLOR, DEFAULT_VIEWER_PROFILE, DIRECTIONAL_PRESETS, DIRECTION_OPTIONS, DocumentPropertiesCardComponent, EMBEDDED_FONTS_STYLE_ID, EMPHASIS_PRESETS, ENTRANCE_PRESETS, TEMPLATES as EQUATION_TEMPLATES, EXIT_PRESETS, EditorContextMenuComponent, EditorHistory, EditorStateService, EditorToolbarComponent, EffectsPanelComponent, ElementRendererComponent, EmbeddedFontsService, EncryptedFileDialogComponent, EquationEditorDialogComponent, EquationRendererComponent, EquationTemplateGalleryComponent, ExportProgressModalComponent, ExportService, FieldContextService, FindBarComponent, FindReplaceBarComponent, FollowModeBarComponent, FontEmbeddingListComponent, FontEmbeddingPanelComponent, GALLERY_THEME_PRESETS, GRIDLINE_COLOR, GradientPickerComponent, HANDOUT_OPTIONS, HeaderFooterDialogComponent, HyperlinkDialogComponent, ImagePropertiesPanelComponent, InkDrawingService, InkRendererComponent, InsertSmartArtDialogComponent, InspectorPaneHeaderComponent, InspectorPanelComponent, IsMobileService, KeepAnnotationsDialogComponent, LOCALE_CATALOG, LONG_PRESS_DURATION_MS, LONG_PRESS_MOVE_TOLERANCE_PX, LoadContentService, LocalPresencePublisher, MAX_ZOOM_SCALE, MIN_ZOOM_SCALE, MOTION_PATH_COLUMNS, MediaPreviewComponent, MediaPropertiesPanelComponent, MediaRendererComponent, MediaTrimTimelineComponent, MobileBottomBarComponent, MobileMenuSheetComponent, MobilePresenterViewComponent, MobileSheetComponent, MobileSlidesSheetComponent, MobileToolbarComponent, ModalDialogComponent, Model3DRendererComponent, NotesHandoutCardComponent, NotesPanelComponent, NotesToolbarComponent, OleRendererComponent, OutlineViewOverlayComponent, POWER_POINT_VIEWER_PROVIDERS, PPTX_OPEN_ACCEPT, PRESENTATION_OPEN_EXTENSIONS, PRESENTER_CHANNEL_NAME, PRESENTER_MSG_ORIGIN, PRESENTER_TIMER_SEGMENT_MS, PX_PER_CM, PX_PER_INCH, PasswordProtectionDialogComponent, PasswordStrengthMeterComponent, PowerPointViewerComponent, PresentToolbarAutoHide, PresentationAnnotationOverlayComponent, PresentationAnnotationsService, PresentationOverlayComponent, PresentationPropertiesPanelComponent, PresentationSettingsCardComponent, PresentationSubtitleBarComponent, PresentationToolbarComponent, PresentationTransitionOverlayComponent, PresenterViewComponent, PresenterWindowService, PrintDialogComponent, PrintService, PrintSettingsPanelComponent, PropertiesDialogComponent, REPEAT_MODE_OPTIONS, RESIZE_HANDLES, RULER_FONT_SIZE, RULER_THICKNESS, ReadingViewOverlayComponent, RemoteSelectionOverlayComponent, RibbonAnimationGalleryComponent, RibbonAnimationsSectionComponent, RibbonArrangeSectionComponent, RibbonColorPopoverComponent, RibbonComponent, RibbonDesignSectionComponent, RibbonDrawSectionComponent, RibbonDrawingGroupComponent, RibbonEditingSectionComponent, RibbonFileSectionComponent, RibbonFontControlsComponent, RibbonHomeSectionComponent, RibbonHyperlinkButtonComponent, RibbonInsertFieldsComponent, RibbonInsertSectionComponent, RibbonMotionPathGalleryComponent, RibbonParagraphControlsComponent, RibbonPrimaryRowComponent, RibbonReviewSectionComponent, RibbonShapeExtrasComponent, RibbonSlideshowSectionComponent, RibbonTransitionsSectionComponent, RibbonViewSectionComponent, RulerGuidesService, SEQUENCE_OPTIONS, SEVERITY_GROUPS, SEVERITY_LABELS, SHORTCUT_REFERENCE_ITEMS, SLIDE_TRANSITION_KEYFRAMES, DEFAULT_PALETTE as SMARTART_DEFAULT_PALETTE, PALETTES as SMARTART_PALETTES, SMART_ART_COLOR_SCHEMES, SMART_ART_STYLE_OPTIONS, SUB_ITEM_LABEL, SVG_WARP_PRESETS, SWIPE_MAX_VERTICAL_PX, SWIPE_THRESHOLD_PX, SelectionPaneComponent, SetUpSlideShowDialogComponent, SettingsAppearanceTabComponent, SettingsDialogComponent, SettingsLanguageTabComponent, ShareDialogComponent, ShortcutPanelComponent, ShowOptionsFieldsetComponent, ShowSlidesFieldsetComponent, SignatureStrippedDialogComponent, SignaturesPanelComponent, SignaturesService, SlideBackgroundCardComponent, SlideCanvasComponent, SlideDefaultInspectorComponent, SlideDiffChangesComponent, SlideDiffRowComponent, SlideDiffThumbnailsComponent, SlideSizeCardComponent, SlideSorterOverlayComponent, SlideThemeOverridePanelComponent, SlideTransitionCardComponent, SlidesPanelComponent, SmartArt3DRendererComponent, SmartArt3DService, SmartArtPreviewComponent, SmartArtPropertiesComponent, SmartArtRendererComponent, StatusBarComponent, TABLE_STRUCTURE_TOGGLES, TEXT_3D_BOTTOM_BEVEL_KEYS, TEXT_3D_TOP_BEVEL_KEYS, TEXT_DIRECTION_OPTIONS, THEME_CATALOG, TIMING_CURVE_OPTIONS, TRIGGER_OPTIONS, TYPE_LABELS, TableCellAdvancedFillComponent, TableCellFormattingComponent, TableDataEditorComponent, TablePropertiesComponent, TableRendererComponent, TableResizeOverlayComponent, TableSelectionService, TagsCardComponent, Text3DBevelSectionComponent, Text3DPanelComponent, TextAdvancedPanelComponent, ThemeEditorFieldsComponent, ThemeGalleryComponent, ThemeSelectorCardComponent, TitleBarComponent, TitleBarSearchComponent, TransitionDirectionPickerComponent, TransitionPreviewComponent, VALIGN_OPTIONS, VIEWER_THEME, VersionHistoryPanelComponent, ViewerCanvasEditingService, ViewerCollabCursorService, ViewerCollaborationSessionService, ViewerCompareService, ViewerCustomShowsService, ViewerDialogsService, ViewerDocumentPropertiesService, ViewerExportService, ViewerExtraDialogsComponent, ViewerFileIOService, ViewerFindReplaceService, ViewerFormatPainterService, ViewerInspectorPanelService, ViewerKeyboardService, ViewerMobileSheetService, ViewerPresentationModeService, ViewerThemeGalleryService, ViewerTouchGesturesService, ViewerZoomService, WEBM_MIME_CANDIDATES, WriteBackScheduler, ZERO_LINE_COLOR, ZoomNavigationService, ZoomRendererComponent, ZoomTargetService, addCategory, addCommentToList, addGradientStopPatch, addItem, addSeries, addSubItem, advanceStep, affordanceElements, aiToggleVisible, alignPatch, animationFor, animationPresetLabelKey, annotationMapToInkInserts, applyAcceptedDiff, applyAnimationPreset, applyFindReplacements, applyFormatToElement, applyMove, applyResize, applyTableStylePreset, asMediaElement, assignUserColor, attachShowVisibilityPause, attachTouchGestures, axisTickValues, beginNodeEdit, bevelSizePatch, boolFromEvent, bringForward, bringToFront, buildBarActions, buildBroadcastConfig, buildBroadcastViewerUrl, buildCategoryLabels, buildCellParagraphs, buildChartViewModel, buildChatLogExport, buildChatLogMarkdown, buildChromeStyle, buildClearHyperlinkPatch, buildClickGroups, buildColStyles, buildCollaborationConfig, buildComboViewModel, buildCssGradientFromShapeStyle, buildDuotoneFilter, buildDuotoneFilterId, buildEmbeddedFontStyles, buildEquationElement, buildEquationSegment, buildFallbackViewModel, buildFontFaceRule, buildGradientFillCss, buildGridlinesAndLabels, buildHyperlinkPatch, buildInkContainerStyle, buildInkStrokes, buildLegend, buildModel3DContainerStyle, buildModel3DViewModel, buildOleActionModel, buildOleInfoRows, buildPatternFillCss, buildPrintHtmlDocument as buildPrintDocument, buildPropertiesPatch, buildRegionMapViewModel, buildSaveSlides, buildShareUrl, buildSmartArtInsertElement, buildSmartArtNodes, buildStockViewModel, buildSurfaceViewModel, buildTableViewModel, buildTreemapViewModel, buildTrimFragment, buildWaterfallViewModel, buildZeroLine, buildZoomContainerStyle, buildZoomViewModel, bulletIndentPx, canAddTopLevelNode, canGroupSelection, canRemoveTopLevelNode, canSetStrokeWidth, canStartBroadcast, canStartShare, canUngroupSelection, canUseClipboard, captionDisplayText, cellRunStyle, cellStyleToStyleMap, cellTdStyle, changeCountLabel, changeIcon, characterSpacingPatch, chartPreserveAspectRatio, checkFontAvailable, clampCursorPosition, clampGifDimensions, clampIndex, clampNotesFontSize, clampScale, clampStep, clearAllLocalViewerData, clearAudienceContent, cn, collectAccessibilityIssues, collectElementText, collectSlideText, collectStoredChats, collectUsedFontFamilies, columnWidthStyle, commitNodeText, computeAlign, computeAxisTitlePrimitives, computeBarRects, computeBubbleRadius, computeCornerHandle, computeDataTablePrimitives, computeDistribute, computeDrawingViewBox, computeErrorBarPrimitives, computeFocusTargets, computeHandleBoxes, computeHandoutLayout, computeIsMobile, computeIsTablet, computeLinePoints, computeLinearRegression, computePageCount, computePieLayout, computePieSlicePath, computePieSlices, computePlotLayout, computeRSquared, computeRadarPoints, computeResizeHandleBoxes, computeRotateHandleBox, computeScatterDots, computeScatterXDomain, computeSelectionBoxes, computeSingleSelected, computeSlideIndices, computeSnap, computeStackedBarRects, computeStackedValueRange, computeTrendlinePrimitives, computeValueRange, convertOmmlToMathMl, copyFormatFromElement, countAccessibilityIssues, countAnnotationStrokes, createAngularAiBridge, createCustomShow, createSwipeDismissDrag, createWebrtcBundle, createWebsocketBundle, cssObjectToStyleMap, currentColorScheme, currentLayout, currentStyle, defaultCssVars, defaultRadius, defaultThemeColors, deleteElementsByIds, deleteVersion as deleteRecoveryVersion, demoteNode, deriveModel3DBlobUrl, derivePresenceList, describeSmartArtBounds, disableGlowPatch, disableInnerShadowPatch, disableOuterShadowPatch, disableReflectionPatch, disableSoftEdgePatch, duplicateElementById, durationOf, effectsStateOf, enableGlowPatch, enableInnerShadowPatch, enableOuterShadowPatch, enableReflectionPatch, enableSoftEdgePatch, encodeGif, endShowMediaCleanup, estimatePageCount, evenColumnWidths, evenRowHeights, exitPresentationFullscreen, exportAiChatLogs, extractPathPoints, eyedropperAvailable, fillColorOf, findInSlides, findOwningSlideIndex, findSlideIndexByElementId, firstVisibleIndex, fitPolynomial, fitZoom, focusTargetChips, fontMimeForFormat, fontSizeOf, forgetSessionDeck, formatAxisValue, formatBytes, formatCursorLabel, formatElapsed, formatFileSize, formatPropertyDate, formatTime, fpsToFrameIntervalMs, generateBroadcastRoomId, generateCommentId, generateCustomShowId, generatePressureCircles, generateTicks, getClrChangeParams, getContainerStyle, getDuotoneFilterDef, getImageSrc, getLocalStorageUsageSummary, getOleAriaLabel, getOleBadgeLabel, getOleDisplayName, getOleDownloadFileName, getOleTypeColor, getOleTypeLabel, getPasswordStrength, getPatternSvg, getPlaceholderStyle, getVersions as getRecoveryVersions, getResolvedShapeClipPath, getResolvedShapeClipPathFor, getSessionTabId, getShapeFillStrokeStyle, getSlideBackgroundStyle, getSlideTransitionAnimations, getSmartArtNodeBounds, getSpeechRecognitionCtor, getTextBlockStyle, getTextWarp, getTouchDistance, getWarpCategory, getWarpPath, gradientStateFromStyle, gradientStateOf, gradientStatePatch, gridColumns, groupIssuesBySeverity, hasAnimation, hasCopyableFormat, hasExistingLink, hasExitedFullscreen, hasGradientFill, hasPressureVariation, hasVisibleSlideAfter, headerLabel, imageDimensions, inkViewBox, insertTableElementColumn as insertColumn, insertTableElementRow as insertRow, interpolateWidth, isAudienceTab, isBold, isBrowserOpenableMime, isChildNode, isElementInteractive, isInjectableUrl, isItalic, isLegacyBinaryPresentation, isPpactionUrl, isPresenterMessage, isSigned, isSupportedPresentationFile, isTextElement, isTwoTableFocus, isUnderline, isUrlSafe, isValidRoomId, isViewportBackgroundPressTarget, isZoomActivationKey, issueTrackKey, issueTypeLabel, keyToLabel, lastVisibleIndex, latexToMathml, layoutConnectorPaints, layoutNodeLabels, linePointsToSvgString, lineSpacingPatch, loadAudienceContent, loadSessionDeck, mediaFallbackFor, mediaSurfaceFor, mergeCaptionResults, mergeDown, mergeRight, mergeSelection, moveElementBy, moveNodeDown, moveNodeUp, msToFrameDelayCs, narrowToCircle, narrowToPolygon, narrowToRect, newChartElement, newEquationElement, newPresetShapeElement, newShapeElement, newSmartArtElement, newTableElement, newTextElement, nextVisibleIndex, nodeBold, nodeEditBox, nodeFillColor, nodeFontColor, nodeIdFromKey, nodeItalic, nodeStyle, normalizeFontFormat, normalizeSlidesPerPage, normalizeValue, numFromEvent, ommlToMathml, ooxmlDashToCssBorderStyle, openNativeEyeDropper, overallStatus, paletteColor, parseAudienceNonce, parseNodeTextarea, partitionSlides, patchChartData, patchChartStyle, patchTableData, patchTextStyle, patternPresetOptions, pendingElementStyles, pickColorByClickFallback, pickFile, pickSupportedMimeType, planGifFrames, planVideoSegments, pointsToSvgPathD, presenceToCursors, presentationBaseName, presentationStageStyle, presenterTimerProgress, presetByLayout, presetsForCategory, pressuresToWidths, prevVisibleIndex, projectDrawingShapes, promoteNode, provideViewerTheme, radarAngle, radarRingPoints, readAsDataUrl, recordWebm, redistributeColumnWidth, registerCrossSlideAudio, rememberSessionDeck, removeAnimation, removeCategory, removeTableElementColumn as removeColumn, removeCommentFromList, removeElementAnimation, removeGradientStopPatch, removeNode, removeTableElementRow as removeRow, removeSeries, renderToCanvas, reorderAnimationDown, reorderAnimationUp, replaceInSlides, replaceMatch, requestPresentationFullscreen, resizeElement, resolveCaptionTracks, resolveChartKind, resolveFontVariant, resolveHyperlinkHref, resolveInteractiveElementId, resolveMediaSrc, resolveOleType, resolveParagraphBullet, resolvePresenterNotes, resolveProfileInitial, resolveRegionCode, resolveSlideAutoAdvanceMs, resolvePalette as resolveSmartArtPalette, resolveThemeCatalogEntry, resolveTransitionDuration, restoreSessionDeck, revealedElementStyles, routeOrthogonalConnector, rowStyle, rulerDragToGuidePosition, rulerHighlight, rulerStripTicks, sampleColorFromSlide, sanitizeColor, sanitizeSlideIndex, sanitizeUserName, saveViewerProfile, savedPresentationFileName, scanAvailableFonts, searchSlides, seedBroadcastFields, seedHyperlinkDraft, seedPropertiesDraft, seedShareFields, segmentFrameCount, selectValue, sendBackward, sendToBack, sequentialColorScale, serializeWriteBack, seriesColor, setAnimationEmphasis, setAnimationEntrance, setAnimationExit, setAxis, setAxisLogScale, setAxisTitleStyle, setCategoryLabel, setCellText, setColorScheme, setDataLabels, setDataPointExplosion, setDataPointFill, setDataPointLabel, setDataPointMarker, setDelay, setDirection, setDuration, setElementPosition, setGridlineStyle, setLayout, setLegend, setNodeStyle, setNodeText, setRepeatCount, setRepeatMode, setSequence, setSeriesChartType, setSeriesColor, setSeriesErrorBars, setSeriesMarker, setSeriesName, setSeriesTrendline, setSeriesValue, setStyle, setTimingCurve, setTitle, setTrigger, setTriggerShapeId, shapeStylePatch, sheetAfterNavigate, shouldBlockClickAdvance, shouldUseSvgWarp, showDirectionPicker, showsTemplateAffordance, signatureCountLabel, signatureKey, signatureTimestamp, signerName, statusLabel as slideDiffStatusLabel, slideNumberOf, slidesWithReappliedLayout, smartArtNodes, paletteColour as smartArtPaletteColour, snapToGridStep, splitCursorCell, splitMergedCell, statusKind, statusLabel$1 as statusLabel, storeAudienceContent, stringFromEvent, strokeColorOf, strokeToInkElement, strokeWidthOf, styleShadowFilter, textAdvancedPatch, textAdvancedStateFromStyle, textAdvancedStateOf, textColorOf, textDirectionPatch, textStyleOf, textStylePatch, themeStyle, themeToCssVars, thumbnailHeight, thumbnailZoom, toggleCommentResolvedInList, toggleNodeBold, toggleNodeItalic, toggleSheet, topLevelNodeCount, transformSelectedTextCase, translationsEn, updateElementById, updateGlowPatch, updateGradientStopPatch, updateInnerShadowPatch, updateOuterShadowPatch, updateReflectionPatch, vAlignPatch, validatePassword, validatePrintSettings, validateRoomId, valueToY, vermilionDarkColors, vermilionDarkTheme, vermilionLightColors, vermilionLightTheme, vermilionRadius, waypointsToPathD, worstStatus, zoomTargetSlideIndex };
+export type { AccessibilityIssueGroup, AccountAuthConfig, ActionDescriptor, ActiveShow, AiCanvasHighlight, AiChatInitState, AiHistoryInitDeps, AiLogChat, AiLogExport, AiLogFormat, AiLogMessage, AiPanelSelectionAccessors, AlignBox, AlignMode, AnimationClickGroup, AnimationGroup, AnimationPresetCategory, AnimationPresetEntry, AnimationPresetPick, AnnotationInkInsert, AnnotationStroke, AttachTouchGesturesConfig, AwarenessLike, BarRect, Box, BridgeDeps, BroadcastConfig, BroadcastDefaults, CSSProperties, CanvasSize, CellCoord, CellParagraph, CellTextRun, ChartPartRef, ChartPartSelection, ChartValueDrag, ChartViewModel, ClassValue, ClrChangeParams, CollaborationConfig, CollaborationRole, RouterRect as ConnectorObstacle, RouterPoint as ConnectorPoint, ConnectorRouting, CopiedFormat, CornerHandleBox, CustomShow, CustomThemeEdit, DestroyableYDoc, DiagonalBorderInfo, DistributeMode, DocumentProperties, DrawingViewBox, DuotoneFilterDef, EffectsState, EmbeddedFontStyles, EquationTemplate, EyedropperResult, FindOptions, FindResult, FocusChip, FocusSelectionInput, GifFrame, GifFramePlan, GifPlanOptions, GlowState, GradientState, GradientStop$1 as GradientStop, HandleBox, HandoutSlidesPerPage, HyperlinkDraft, InkPoint, InkStroke, InlineEditState, InnerShadowState, LegendEntry, LinePoint, LinearFit, LocalIdentity, LocalStorageUsageSummary, LocaleCatalogEntry, MobileSheetKey, Model3DViewModel, MotionPathColumn, MotionPathEntry, NodeEditBox, NotesSegmentViewModel, ObjectUrlFactory, OleActionModel, OleInfoRow, OuterShadowState, OutlineCommit, OverallSignatureStatus, PartitionedSlides, PathPoint, PieSliceGeometry, PieSliceOptions, PlotLayout, PlotLayoutOptions, PositionUpdate, PowerPointViewerAPI, PptxAiBridge, PptxAiConfig, PptxAiConnection, PptxAiContextStrategy, PptxAiElementUpdate, PptxAiToolName, PptxAiUIMessage, PptxAiWritePolicy, PresentToolbarAction, PresentationTool, PresenterExitMessage, PresenterMessage, PresenterNotes, PresenterSlideChangeMessage, PresenterTimerProgress, PressureCircle, PrintColorMode, PrintHtmlDocumentOptions as PrintDocumentOptions, PrintOrientation, PrintSettings, PrintSlideRange, PrintWhat, PropertiesDraft, ProposalView, ProviderBundle, ProviderLike, RadarPoint, RecordWebmOptions, RecoveryVersion, ReflectionState, RemoteCursor, SanitizedPresence as RemotePresence, RenderedShape, ReplaceResult, ResizeHandle, ResolvedCaptionTrack, ResolvedFontVariant, ResolvedOleType, RulerUnit, SavedPresentationFormat, ScatterDot, ScatterXDomain, SelectionBox, SessionDeck, ShapeStyleChanges, ShareDefaults$1 as ShareDefaults, ShareFormFields, ShortcutReferenceItem, SignatureStatusKind, SlideInspectorTab, SlideTransitionAnimations, SmartArtInsertEvent, SmartArtNodeBounds, SnapBox, SnapGuide, SnapResult, SoftEdgeState, SpeechAlternative, SpeechRecognitionCtor, SpeechRecognitionEventLite, SpeechRecognitionLite, SpeechResult, SpeechResultList, SpeechSupportState, StagedProposal, StrokeToInkElementOpts, StyleMap, SupportedChartKind, SvgAreaGradient, SvgCircle, SvgLine, SvgPath, SvgPolygon, SvgPolyline, SvgPrimitive, SvgRect, SvgText, SwipeDismissDrag, TableBooleanFlag, TableCellSelection, TableCellViewModel, TableRowViewModel, TemplateElementsBySlideId, Text3DBevelKeys, TextAdvancedChanges, TextAdvancedState, TextStyleChanges, TextWarpCssDef, TextWarpDef, TextWarpPathDef, ThemeCatalogEntry, Tick, ToolbarActionId, TouchGestureCallbacks, TranslationKey, ValueRange, VideoPlanOptions, VideoSegmentPlan, ViewerMode, ViewerProfile, ViewerSettings, ViewerTheme, ViewerThemeColors, ZoomTranslate, ZoomViewModel };
+//# sourceMappingURL=pptx-angular-viewer.d.ts.map