pptx-angular-viewer 3.4.0 → 3.5.0

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

@@ -1,5 +1,5 @@
 import * as pptx_viewer_core from 'pptx-viewer-core';
-import { PptxThemePreset, PptxSlide, PptxElement, ShapeStyle, PptxTextWarpPreset, XmlObject, PptxChartSeries, PptxChartLegendTextStyle, PptxChartData, PptxChartDataLabelPosition, PptxChartType, PptxElementAnimation, PptxAnimationPreset, PptxAnimationSequence, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, PptxAfterAnimationAction, ParsedTableStyleMap, PptxThemeColorScheme, PptxThemeFontScheme, TablePptxElement, PptxSection, OlePptxElement, TextSegment, TextStyle, PptxTransitionType, PptxSlideTransition, SmartArtLayoutType, SmartArtColorScheme, PptxSmartArtChrome, PptxSmartArtDrawingShape, SmartArtStyle, PptxSmartArtData, PlaceholderDefaults, PptxEmbeddedFont, SmartArtLayout, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, ElementActionType, InkPptxElement, PptxComment, PptxChartBarDirection, MediaPptxElement, PptxTheme, PptxHandler, PptxData, PptxHeaderFooter, PptxCustomShow, PptxSlideMaster, PptxNotesMaster, PptxHandoutMaster, PptxPresentationProperties, PptxViewProperties, PptxCoreProperties, PptxAppProperties, PptxThemeOption, PptxCustomProperty, PptxTagCollection, ParsedSignature, PptxSaveFormat, PptxTableCell, PptxTableCellStyle, PptxTableRow, PptxTableData, MasterViewTab, SvgExportOptions, PptxGridSpacing, RenderedNode, RenderedCircleNode, RenderedPolygonNode, RenderedRectNode, SmartArtLayoutResult, Model3DPptxElement, ZoomPptxElement, ChartPptxElement, SmartArtPptxElement, PptxAnimationTimelineAnchor, MaterialPresetType, Text3DStyle, BevelPresetType, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartMarker, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, PptxTextStyleLevels, SignatureStatus, ElementAction, PptxImageEffects, MediaBookmark, ColorMapAliasKey, ChartAxisEdit, ChartDataPointLabelEdit, PptxChartLegendPosition, PptxChartStyle, ChartAxisTitleStyleEdit, PptxChartMarkerSymbol, ChartGridlineStyleEdit, PptxSmartArtNode, PptxSmartArtNodeStyle, PptxLayoutPreview, MediaCaptionTrack, PptxMediaType } from 'pptx-viewer-core';
+import { PptxThemePreset, PptxSlide, PptxElement, ShapeStyle, PptxTextWarpPreset, XmlObject, PptxChartSeries, PptxChartLegendTextStyle, PptxChartData, PptxChartDataLabelPosition, PptxChartType, PptxElementAnimation, PptxAnimationPreset, PptxAnimationSequence, PptxAnimationTrigger, PptxAnimationTimingCurve, PptxAnimationRepeatMode, PptxAnimationDirection, PptxAfterAnimationAction, ParsedTableStyleMap, PptxThemeColorScheme, PptxThemeFontScheme, TablePptxElement, PptxSection, OlePptxElement, TextSegment, TextStyle, PptxTransitionType, PptxSlideTransition, SmartArtLayoutType, SmartArtColorScheme, PptxSmartArtChrome, PptxSmartArtDrawingShape, SmartArtStyle, PptxSmartArtData, PlaceholderDefaults, PptxEmbeddedFont, SmartArtLayout, AccessibilityIssueSeverity, AccessibilityIssue, AccessibilityIssueType, AccessibilityCheckOptions, ElementActionType, InkPptxElement, PptxComment, PptxChartBarDirection, MasterViewTab, MediaPptxElement, PptxTheme, PptxHandler, PptxData, PptxModernCommentAuthor, PptxCommentMention, PptxHeaderFooter, PptxCustomShow, PptxSlideMaster, PptxNotesMaster, PptxHandoutMaster, PptxPresentationProperties, PptxViewProperties, PptxCoreProperties, PptxAppProperties, PptxThemeOption, PptxCustomProperty, PptxTagCollection, ParsedSignature, PptxSaveFormat, PptxTableCell, PptxTableCellStyle, PptxTableRow, PptxTableData, SvgExportOptions, PptxGridSpacing, RenderedNode, RenderedCircleNode, RenderedPolygonNode, RenderedRectNode, SmartArtLayoutResult, Model3DPptxElement, ZoomPptxElement, ChartPptxElement, SmartArtPptxElement, PptxAnimationTimelineAnchor, MaterialPresetType, Text3DStyle, BevelPresetType, PptxBar3DShape, PptxChartDataLabelOptions, PptxChartAxisType, PptxChartAxisFormatting, PptxChartMarker, PptxChartDataPoint, PptxChartTrendline, PptxChartErrBars, PptxTextStyleLevels, SignatureStatus, ElementAction, PptxImageEffects, MediaBookmark, ColorMapAliasKey, ChartAxisEdit, ChartDataPointLabelEdit, PptxChartLegendPosition, PptxChartStyle, ChartAxisTitleStyleEdit, PptxChartMarkerSymbol, ChartGridlineStyleEdit, PptxSmartArtNode, PptxSmartArtNodeStyle, PptxLayoutPreview, MediaCaptionTrack, PptxMediaType } from 'pptx-viewer-core';
 export { GroupResult, SWITCHABLE_LAYOUT_TYPES, UngroupResult, addSmartArtNode, addSmartArtNodeAsChild, chartDataChangeType, 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';
@@ -6111,10 +6111,11 @@ declare function issueTrackKey(issue: AccessibilityIssue, index: number): string
  * Settings" inspector panel (PowerPoint's Insert > Action dialog).
  *
  * WHY shared: the mapping from `ElementActionType` to a translation key is
- * plain data that every binding's action panel needs verbatim, and the two
- * types that take an extra input (`url`, `slide`) are a rule, not a rendering
- * decision. Keeping the list here means adding a new action kind updates all
- * five bindings at once instead of five hand-typed copies drifting apart.
+ * plain data that every binding's action panel needs verbatim, and the three
+ * types that take an extra input before they can commit (`url`, `slide`,
+ * `customShow`) are a rule, not a rendering decision. Keeping the list here
+ * means adding a new action kind updates all five bindings at once instead of
+ * five hand-typed copies drifting apart.
  *
  * @module render/element-action-options
  */
@@ -6856,6 +6857,59 @@ interface BackstageTemplate {
 }
 declare function formatBackstageSize(bytes: number): string;
 
+/**
+ * master-view.ts: the framework-neutral rules behind View > Slide Master.
+ *
+ * Every binding had its own copy of "turn the selected master/layout/notes/
+ * handout part into a pseudo-slide the ordinary canvas can paint", and they
+ * had drifted: React and Svelte painted a layout without its master's artwork
+ * behind it, React keyed its pseudo-slide so the save path could never match
+ * it, Angular dropped every edit made on the Slides tab, and Vue offered no
+ * edit at all. The decisions live here instead, and each binding maps the
+ * returned descriptors onto its own state container.
+ *
+ * @module render/master-view
+ */
+
+/** Which part the master view is currently pointed at. */
+interface MasterViewTarget {
+    tab: MasterViewTab;
+    masterIndex: number;
+    /** `null` selects the master itself rather than one of its layouts. */
+    layoutIndex: number | null;
+}
+
+/**
+ * master-view-crud.ts: the decision layer behind PowerPoint's Slide Master
+ * view sidebar commands (Insert/Duplicate/Delete/Rename Layout and Slide
+ * Master).
+ *
+ * Splits into two pure-ish pieces:
+ * - {@link masterViewCrudActions}: a synchronous, framework-neutral
+ *   descriptor of which buttons a binding's sidebar should show, enabled or
+ *   disabled, so no binding re-derives PowerPoint's "can't delete the last
+ *   master" / "can't delete a layout slides still use" rules itself.
+ * - {@link applyMasterViewCrudAction}: the async bridge to
+ *   `pptx-viewer-core`'s `master-layout-crud` module (which performs the
+ *   actual ZIP surgery), returning the master-view selection a binding
+ *   should move to afterwards (the new layout/master it just created, or the
+ *   owning master after a delete).
+ *
+ * @module render/master-view-crud
+ */
+
+/** One Slide Master view sidebar command. */
+type MasterViewCrudActionId = 'addLayout' | 'duplicateLayout' | 'deleteLayout' | 'renameLayout' | 'addMaster' | 'duplicateMaster' | 'deleteMaster' | 'renameMaster';
+/** A framework-neutral descriptor for one sidebar button. */
+interface MasterViewCrudAction {
+    id: MasterViewCrudActionId;
+    /** i18n key for the button label (`pptx.masterView.<id>`). */
+    labelKey: string;
+    enabled: boolean;
+    /** i18n key explaining why the button is disabled, set only when it is. */
+    disabledReasonKey?: string;
+}
+
 /** Framework-neutral virtual-list range used by every thumbnail sidebar. */
 interface VirtualizedRange {
     startIndex: number;
@@ -7320,11 +7374,12 @@ declare function computeHandoutLayout(slideIndices: number[], slidesPerPage: Han
  *
  * No DOM side effects and no `window.print()`: everything is deterministic and
  * the binding writes the returned HTML string into a print window. The handout
- * grid geometry lives in `handout-layout`; this module reuses it.
- *
- * ng-packagr constraint honoured here (the Angular binding inlines this source
- * and compiles it through ng-packagr): NO `String.prototype.replaceAll`
- * (`escapeHtml` uses `.split(x).join(y)` instead).
+ * grid geometry lives in `handout-layout`; this module reuses it. Handout
+ * master "chrome" (background/header/footer/date/page-number/positioned slide
+ * rects) is resolved by `handout-master-chrome.ts` and painted by
+ * `handout-chrome-html.ts`; escaping helpers live in `html-escape.ts` (both
+ * split out to keep this file under this repo's per-file LOC guideline and to
+ * avoid a circular import between the two).
  */
 
 /** What to print. */
@@ -7564,6 +7619,70 @@ declare function canSetStrokeWidth(canEdit: boolean, element: PptxElement | null
 /** The stroke width to show for a selection, defaulted for a shape without one. */
 declare function strokeWidthOf(element: PptxElement | null): number;
 
+/**
+ * slide-size-rescale.ts: what happens to a deck's content when Design > Slide
+ * Size changes the canvas dimensions.
+ *
+ * PowerPoint offers two responses when a slide-size change no longer matches
+ * the existing content's aspect ratio:
+ * - "Maximize": scale content up to fill the new size (by the LARGER of the
+ *   two axis ratios), which can push content outside the new slide bounds.
+ * - "Ensure Fit": scale content down to fit inside the new size (by the
+ *   SMALLER of the two axis ratios), which can leave margins.
+ *
+ * Both scale uniformly (one factor, not independent X/Y stretch) and both
+ * centre the scaled content in the new canvas, which is why every element's
+ * position is re-derived from the same `(scale, offsetX, offsetY)` triple
+ * rather than each axis being handled independently.
+ *
+ * Framework-agnostic: no React, Vue, Angular, Svelte or DOM imports.
+ */
+
+type SlideSizeRescaleMode = 'maximize' | 'ensureFit';
+
+type ReadOnlyRecommendationKind = 'modifyVerifier' | 'markedFinal' | null;
+interface ReadOnlyRecommendation {
+    readonly kind: ReadOnlyRecommendationKind;
+    /** i18n key for the banner/toast a binding shows for this recommendation. */
+    readonly messageKey: string;
+    /** Whether a binding's "read-only" toggle should default to on. */
+    readonly defaultReadOnly: boolean;
+}
+
+interface CompatibilityWarningToast {
+    /** Stable per-code id, since toasts are deduped by code (see module docs). */
+    readonly id: string;
+    readonly code: string;
+    readonly severity: 'info' | 'warning';
+    readonly messageKey: string;
+    /** `{{code}}` for the generic fallback key; `undefined` for a mapped code. */
+    readonly params?: Readonly<Record<string, string>>;
+}
+
+/**
+ * Inspector option lists + pure patch builders for the three OOXML chart
+ * subtype flags parsed/serialized in this wave: bar3D column/bar shape
+ * (`c:bar3DChart/c:shape`), radar chart style (`c:radarChart/c:radarStyle`),
+ * and surface wireframe (`c:surfaceChart|surface3DChart/c:wireframe`).
+ *
+ * Each `*_OPTIONS` list is `{ value, labelKey }` for a picker control, in the
+ * order PowerPoint itself lists them; each `*Patch` function is a pure
+ * decision function returning the minimal `Partial<PptxChartData>` patch an
+ * inspector commits back onto the loaded chart data, following this repo's
+ * "shared decides, binding only maps" shape (CLAUDE.md Rule 2: a shared
+ * decision function, five thin bindings). No binding-specific code lives
+ * here; a binding only renders `*_OPTIONS` as a picker and calls the matching
+ * patch function on selection.
+ *
+ * @module chart-subtype-options
+ */
+
+/** One inspector picker entry: the OOXML value plus its i18n label key. */
+interface ChartSubtypeOption<T extends string> {
+    value: T;
+    labelKey: string;
+}
+
 /**
  * Minimal GIF89a encoder (pure JS, no external dependency) plus pure
  * frame-planning helpers — shared by the React, Vue, and Angular bindings.
@@ -8892,6 +9011,55 @@ declare class CollaborationService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<CollaborationService>;
 }
 
+/** The trimmed text plus the mention spans an add/reply submit carries. */
+interface CommentSubmission {
+    text: string;
+    mentions: PptxCommentMention[];
+}
+declare class CommentsPanelComponent {
+    /** The active slide's comments (already filtered to the active slide). */
+    readonly comments: _angular_core.InputSignal<PptxComment[]>;
+    private readonly translate;
+    /** Display name shown in the compose label ("Commenting as …"). */
+    readonly authorName: _angular_core.InputSignal<string>;
+    /** Office 2021 modern comment authors, for the `@`-mention typeahead. */
+    readonly modernCommentAuthors: _angular_core.InputSignal<readonly PptxModernCommentAuthor[]>;
+    /** Emits the trimmed comment text (+ mentions) the user wants to add. */
+    readonly add: _angular_core.OutputEmitterRef<CommentSubmission>;
+    /** Emits the id of a comment the user wants to remove. */
+    readonly remove: _angular_core.OutputEmitterRef<string>;
+    /** Emits the id of a comment whose resolved flag should toggle. */
+    readonly resolve: _angular_core.OutputEmitterRef<string>;
+    /** Emits the parent comment id + trimmed text (+ mentions) of a threaded reply. */
+    readonly reply: _angular_core.OutputEmitterRef<{
+        parentId: string;
+    } & CommentSubmission>;
+    /** Current text typed into the compose textarea. */
+    readonly draft: _angular_core.WritableSignal<string>;
+    /** `@`-mentions recorded in {@link draft} so far. */
+    readonly draftMentions: _angular_core.WritableSignal<PptxCommentMention[]>;
+    /** Whether the draft has non-whitespace content (enables the submit button). */
+    readonly canAdd: _angular_core.Signal<boolean>;
+    /** Id of the comment whose reply composer is open (one at a time). */
+    readonly replyingTo: _angular_core.WritableSignal<string | null>;
+    /** Current text typed into the open reply composer. */
+    readonly replyDraft: _angular_core.WritableSignal<string>;
+    /** `@`-mentions recorded in {@link replyDraft} so far. */
+    readonly replyMentions: _angular_core.WritableSignal<PptxCommentMention[]>;
+    /** Whether the reply draft has content (enables the reply submit button). */
+    readonly canReply: _angular_core.Signal<boolean>;
+    submit(event: Event): void;
+    /** Localized reply-composer placeholder ("Reply to <author>..."). */
+    replyPlaceholder(comment: PptxComment): string;
+    /** Open the reply composer under `parentId` (closing any other composer). */
+    startReply(parentId: string): void;
+    cancelReply(): void;
+    submitReply(parentId: string): void;
+    formatTimestamp(value: string | undefined): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentsPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentsPanelComponent, "pptx-comments-panel", never, { "comments": { "alias": "comments"; "required": false; "isSignal": true; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; "modernCommentAuthors": { "alias": "modernCommentAuthors"; "required": false; "isSignal": true; }; }, { "add": "add"; "remove": "remove"; "resolve": "resolve"; "reply": "reply"; }, never, never, true, never>;
+}
+
 interface EditorSectionOperations {
     add(afterSlideIndex: number, name: string): void;
     rename(sectionId: string, name: string): void;
@@ -9355,6 +9523,11 @@ declare class LoadContentService {
      * than silently dropped.
      */
     readonly tagCollections: _angular_core.WritableSignal<PptxTagCollection[]>;
+    /**
+     * Office 2021 modern comment authors (`ppt/commentAuthors/`, p188), the
+     * candidate list the comment panel's `@`-mention typeahead matches against.
+     */
+    readonly modernCommentAuthors: _angular_core.WritableSignal<PptxModernCommentAuthor[]>;
     /** Header/footer settings (footer/header/date-time text + format) for field substitution. */
     readonly headerFooter: _angular_core.WritableSignal<PptxHeaderFooter | undefined>;
     /** Whether the presentation contains digital signatures. */
@@ -9413,12 +9586,61 @@ declare class LoadContentService {
      * change is visible to consumers; callers mark the editor dirty.
      */
     setPresentationTheme(themePath: string, applyToAllMasters: boolean): Promise<void>;
+    /**
+     * Adopt a new handler + fully-resolved `PptxData` from a Slide Master view
+     * CRUD action (`applyMasterViewCrudAction`'s insert/duplicate/delete/rename
+     * layout or master). Unlike {@link setPresentationTheme}, those functions
+     * perform ZIP surgery and reload through a FRESH `PptxHandler` (see
+     * `master-layout-crud`'s module doc) rather than mutating this one in
+     * place, so the loaded handler itself must be swapped, not just the
+     * derived signals.
+     *
+     * Media Blob URLs are left untouched: the slide array's own image
+     * references are unaffected by a master/layout CRUD action, and a newly
+     * inserted layout carries no images at all.
+     */
+    adoptMasterViewData(handler: PptxHandler, data: PptxData): void;
     private disposeHandler;
     private revokeBlobUrls;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadContentService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoadContentService>;
 }
 
+declare class LoadNoticesService {
+    /** Optional so isolated service tests and stubbed injectors keep working. */
+    private readonly loader;
+    /** Whether the loaded deck recommends opening read-only, and why. */
+    readonly recommendation: _angular_core.Signal<ReadOnlyRecommendation>;
+    /** Whether the banner has been hidden ("Edit anyway" or "Dismiss") this load. */
+    private readonly bannerHidden;
+    /** Whether "Edit anyway" has lifted the recommendation's editing lock this load. */
+    private readonly lockLifted;
+    /** Whether the read-only banner should render. */
+    readonly bannerActive: _angular_core.Signal<boolean>;
+    /**
+     * Whether the recommendation is still actively locking editing. Gates the
+     * host viewer's `canEdit`, the same way the Protected View lock does.
+     */
+    readonly lockActive: _angular_core.Signal<boolean>;
+    /** "Edit anyway": lifts the recommendation's lock and hides the banner. */
+    editAnyway(): void;
+    /** "Dismiss": hides the banner but leaves any lock in place. */
+    dismissBanner(): void;
+    /** Deck-level plus every slide's compatibility warnings, deduped by code. */
+    readonly toasts: _angular_core.Signal<CompatibilityWarningToast[]>;
+    private readonly dismissedToastIds;
+    /** {@link toasts} with per-toast / dismiss-all dismissals applied. */
+    readonly visibleToasts: _angular_core.Signal<CompatibilityWarningToast[]>;
+    /** Dismiss one toast by id. */
+    dismissToast(id: string): void;
+    /** Dismiss every currently-visible toast. */
+    dismissAllToasts(): void;
+    /** Reset both notices' dismissed/lifted state for a newly loaded deck. */
+    resetForLoad(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadNoticesService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LoadNoticesService>;
+}
+
 /** Which mobile sheet/panel is currently active (highlights its button). */
 type MobileBarSheet = 'slides' | 'inspector' | 'comments' | 'notes' | null;
 /** Internal action descriptor used to build the bar. */
@@ -9580,7 +9802,14 @@ declare class PrintService {
         height: number;
     }>, 
     /** Options > Advanced > "Print hidden slides". Defaults to PowerPoint's own default (excluded). */
-    includeHiddenSlides?: boolean): Promise<boolean>;
+    includeHiddenSlides?: boolean, 
+    /**
+     * The deck's handout master, consumed for its background, header/footer/
+     * date/page-number placeholders, and (when authored) positioned slide
+     * rects, in the `handouts` print mode. Optional and defaulted to
+     * `undefined` so existing callers keep printing the bare grid.
+     */
+    handoutMaster?: PptxHandoutMaster): Promise<boolean>;
     /**
      * Open a print window, write the document, focus, and trigger printing, all
      * in one synchronous call. Used by the outline/slides paths, which never
@@ -9593,6 +9822,25 @@ declare class PrintService {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<PrintService>;
 }
 
+declare class RecentColorsService {
+    private readonly loader;
+    /** Most-recently-used colours, most-recent-first, `#RRGGBB` uppercase. */
+    readonly recent: _angular_core.WritableSignal<string[]>;
+    /** Seed the row from the deck's own `p:clrMru`. Call once per load. */
+    seed(data: Pick<PptxData, 'mruColors'> | undefined): void;
+    /**
+     * Record a newly-picked colour: moves it to the front of {@link recent},
+     * and writes it straight into the loaded deck's `presentationProperties`
+     * (`p:clrMru`), NOT through `EditorStateService`'s undo history: which
+     * colours are "recent" is picker chrome, not an undoable document edit
+     * (the same reasoning `PowerPointViewerComponent` already applies to the
+     * grid/snap/guides toggles).
+     */
+    push(hex: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecentColorsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RecentColorsService>;
+}
+
 /**
  * Duotone SVG `<filter>` descriptor for Angular templates.
  *
@@ -10357,10 +10605,50 @@ declare class ViewerCustomShowsService {
      */
     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.
+     * The slide a show should OPEN on: the active slide when the show (the
+     * active custom show plus the deck's authored `p:showPr/p:sldRg` range, if
+     * any) includes it, else the closest show slide at or after it, else the
+     * show's own first slide. Read once, when the show starts.
+     *
+     * This is "From Current Slide" / the status-bar "Slide show" button /
+     * `setMode('present')`. A deck authored `p:sldRg st="2" end="3"` used to
+     * open on the editor's active slide unconditionally, which put a slide the
+     * author took out of the show on screen first.
+     */
+    showEntryIndex(authoredRange?: AuthoredSlideRange | null): number;
+    /**
+     * The show's own first slide ("From Beginning" / F5), honouring the active
+     * custom show and the deck's authored range the same way {@link showEntryIndex}
+     * does. Unlike `showEntryIndex`, this ignores the current active slide
+     * entirely: PowerPoint's "From Beginning" always opens the show's first
+     * slide, even when the editor is parked somewhere else in (or outside) it.
+     */
+    showFirstIndex(authoredRange?: AuthoredSlideRange | null): number;
+    /**
+     * The show a running `ppaction://customshow?id=<id>[&return=true]` action
+     * left pending: the show + slide to restore once the SUB-show it switched
+     * to runs off its end (PowerPoint's "Resume last slide viewed after showing
+     * this custom show"). `null` when no such action is in flight.
+     */
+    private readonly pendingReturn;
+    /**
+     * Run `ppaction://customshow?id=<id>[&return=true]`: switch the active
+     * custom show to `customShowId` (an id naming no surviving show is a
+     * no-op, returning `null`) and resolve the deck index its show should open
+     * on. When `returnAfter` is true, remembers the origin show + slide so
+     * {@link consumeReturnAfterOnEnd} can restore it once the sub-show ends.
+     *
+     * @returns The deck index to navigate to, or `null` for an unresolvable id.
+     */
+    runCustomShow(customShowId: string, returnAfter: boolean): number | null;
+    /**
+     * The running show just reached its end (`endOfShowChange` from the
+     * overlay). If a `runCustomShow(..., returnAfter: true)` is pending,
+     * restores the origin show and reports the origin slide to navigate back
+     * to; otherwise a no-op (`null`), leaving the ordinary end-of-show screen
+     * up.
      */
-    showEntryIndex(): number;
+    consumeReturnAfterOnEnd(): number | null;
     /**
      * Adopt the loaded deck's authored show selection.
      *
@@ -11001,6 +11289,8 @@ interface PresentationModeHost {
     readonly canEdit: () => boolean;
     readonly promptKeepAnnotations: (map: SlideAnnotationMap) => void;
     readonly applyRehearsalTimings: (timings: Record<number, number>) => void;
+    /** The deck's authored `p:showPr/p:sldRg` range, or null for the whole deck. */
+    readonly authoredRange: () => AuthoredSlideRange | null;
 }
 declare class ViewerPresentationModeService {
     private readonly presenterWindow;
@@ -11026,11 +11316,25 @@ declare class ViewerPresentationModeService {
     bind(host: PresentationModeHost): void;
     private requireHost;
     /**
-     * Open the presentation overlay from the current slide. The overlay itself
+     * Open the presentation overlay at `startIndex`, deselecting first so no
+     * edit chrome (selection outline / resize + rotate "Adjust shape" handles)
+     * leaks over the slideshow. The overlay itself
      * (`PresentationOverlayComponent`) requests real browser fullscreen once it
      * mounts as a result of `presenting` flipping true.
      */
+    private openShow;
+    /**
+     * Open the presentation overlay from the current slide ("From Current
+     * Slide", the status-bar "Slide show" button, `setMode('present')`). Opens
+     * on the active slide when the show (active custom show + the deck's
+     * authored `p:showPr/p:sldRg` range) includes it, else the closest show
+     * slide at or after it, else the show's own first slide.
+     */
     present(): void;
+    /**
+     * "From Beginning" / F5: always opens the show's own first slide, ignoring
+     * where the editor is currently parked.
+     */
     presentFromBeginning(): void;
     presentFromCurrent(): void;
     toggleSubtitles(): void;
@@ -11338,6 +11642,7 @@ declare class PowerPointViewerComponent implements PowerPointViewerAPI {
     /** Fired when the collaboration/broadcast session stops. Mirrors React/Vue. */
     readonly stopCollaboration: _angular_core.OutputEmitterRef<void>;
     protected readonly loader: LoadContentService;
+    protected readonly loadNotices: LoadNoticesService;
     protected readonly editor: EditorStateService;
     private readonly fonts;
     private readonly googleWebfonts;
@@ -11362,6 +11667,7 @@ declare class PowerPointViewerComponent implements PowerPointViewerAPI {
     protected readonly xport: ViewerExportService;
     protected readonly findReplace: ViewerFindReplaceService;
     protected readonly customShowsCtl: ViewerCustomShowsService;
+    protected readonly recentColors: RecentColorsService;
     /**
      * The `p:showPr/p:sldRg` slide-range restriction, when the deck is authored
      * to open into a range (`showSlidesMode === 'range'`) rather than the whole
@@ -11403,9 +11709,11 @@ declare class PowerPointViewerComponent implements PowerPointViewerAPI {
     protected readonly protectedViewDismissed: _angular_core.WritableSignal<boolean>;
     /**
      * Effective edit permission: the host's `canEdit` input gated by Trust
-     * Center > "Open presentations in Protected View", which forces the deck
-     * read-only while enabled (File > Options wiring, mirrors PowerPoint),
-     * unless the user has lifted it via `enableEditing()` for this document.
+     * Center > "Open presentations in Protected View" (forces the deck
+     * read-only while enabled, mirrors PowerPoint, unless the user has lifted
+     * it via `enableEditing()` for this document) and by the deck's own
+     * read-only recommendation (`p:modifyVerifier` / "Mark as Final"; lifted by
+     * the read-only banner's "Edit anyway", see {@link LoadNoticesService}).
      */
     protected readonly canEdit: _angular_core.Signal<boolean>;
     /** Whether the Protected View banner should show: host allows editing, the option still blocks it, and the user hasn't dismissed it yet. */
@@ -11615,6 +11923,42 @@ declare class PowerPointViewerComponent implements PowerPointViewerAPI {
     protected openMasterView(): void;
     protected closeMasterView(): void;
     protected selectMasterTab(tab: MasterViewTab): void;
+    /**
+     * `ppaction://customshow?id=<id>[&return=true]` clicked during a running
+     * show: switch to the named custom show and open its resolved entry slide.
+     * An id naming no surviving show is a no-op (`resolveCustomShowEntry`
+     * returns `null`).
+     */
+    protected onPresentationCustomShow(event: {
+        customShowId: string;
+        returnAfter: boolean;
+    }): void;
+    /**
+     * The presentation overlay's end-of-show flag changed. Only relevant on the
+     * rising edge: if a `ppaction://customshow ... &return=true` is pending,
+     * restore the origin show and slide instead of leaving the black end
+     * screen up (`syncFromHost`'s host-forced jump clears it once the new
+     * index lands).
+     */
+    protected onPresentationEndOfShow(isEnd: boolean): void;
+    /** The Slide Master view sidebar's current selection, in `master-view-crud`'s shape. */
+    protected readonly masterViewTarget: _angular_core.Signal<MasterViewTarget>;
+    /** The Insert/Duplicate/Delete/Rename Layout+Master sidebar commands for the current selection. */
+    protected readonly masterViewCrudActionsList: _angular_core.Signal<MasterViewCrudAction[]>;
+    /**
+     * Run one Slide Master view sidebar CRUD command.
+     *
+     * rename* prompts for a name first (`window.prompt`, matching the pattern
+     * `SlidesPanelComponent`'s section-rename already uses); every command then
+     * runs through `applyMasterViewCrudAction` and, on success, adopts the
+     * returned handler + data through `LoadContentService.adoptMasterViewData`
+     * (that helper reloads through a FRESH `PptxHandler`, so it cannot be
+     * applied as a plain signal patch) and moves the sidebar selection to the
+     * returned target. A failure is surfaced with `window.alert`: Angular has
+     * no generic toast/notice channel for an arbitrary action failure (the
+     * compat-toast stack is load-diagnostics only).
+     */
+    protected onMasterViewCrudAction(id: MasterViewCrudActionId): Promise<void>;
     /**
      * Format Background for whichever master-view part is selected.
      *
@@ -11811,17 +12155,26 @@ declare class PowerPointViewerComponent implements PowerPointViewerAPI {
      * back to Options > General > "User name" before the generic "You".
      */
     private commentAuthorName;
-    /** Append a comment to the active slide (one history entry). */
-    onCommentAdd(text: string): void;
+    /**
+     * Append a comment to the active slide (one history entry).
+     *
+     * `addCommentToList` (shared) has no `mentions` parameter, so the `@`-mention
+     * spans the typeahead recorded are patched onto the newly-appended comment
+     * (the array's last element) here, rather than in the shared helper.
+     */
+    onCommentAdd(submission: CommentSubmission): void;
     /** Remove a comment from the active slide. */
     onCommentRemove(id: string): void;
     /** Toggle a comment's resolved flag on the active slide. */
     onCommentResolve(id: string): void;
-    /** Append a threaded reply under a top-level comment on the active slide. */
+    /**
+     * Append a threaded reply under a top-level comment on the active slide.
+     * See {@link onCommentAdd}: `mentions` is patched on afterwards, since
+     * `replyToCommentInList` (shared) has no `mentions` parameter.
+     */
     onCommentReply(event: {
         parentId: string;
-        text: string;
-    }): void;
+    } & CommentSubmission): void;
     /**
      * Insert a new SmartArt element built from the dialog's chosen preset + item
      * texts. The element id is left empty so `EditorStateService.addElement`
@@ -12238,6 +12591,7 @@ declare class ViewerKeyboardService {
     private readonly dialogs;
     private readonly formatPainter;
     private readonly findReplace;
+    private readonly presentationMode;
     private host;
     /** Wire the host accessors (called once from the component constructor). */
     bind(host: KeyboardHost): void;
@@ -12360,7 +12714,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 GoogleWebfontsService, typeof CollaborationService, typeof CustomFontsService, typeof AccessibilityService, typeof AutosaveService, typeof AutosaveRecoveryService, typeof PrintService, typeof IsMobileService, typeof SmartArt3DService, typeof SurfaceChart3DService, typeof BarChart3DService, typeof LineChart3DService, typeof AreaChart3DService, typeof PieChart3DService, 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 LoadNoticesService, typeof ExportService, typeof EditorStateService, typeof ChartPartSelectionService, typeof TableSelectionService, typeof EmbeddedFontsService, typeof GoogleWebfontsService, typeof CollaborationService, typeof CustomFontsService, typeof AccessibilityService, typeof AutosaveService, typeof AutosaveRecoveryService, typeof PrintService, typeof IsMobileService, typeof SmartArt3DService, typeof SurfaceChart3DService, typeof BarChart3DService, typeof LineChart3DService, typeof AreaChart3DService, typeof PieChart3DService, typeof FieldContextService, typeof RecentColorsService, 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';
@@ -12756,9 +13110,16 @@ declare class RibbonDrawSectionComponent {
     readonly drawingColor: _angular_core.InputSignal<string>;
     readonly drawingWidth: _angular_core.InputSignal<number>;
     readonly drawToolChange: _angular_core.OutputEmitterRef<DrawToolState>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly drawTools: readonly DrawToolDef[];
     protected selectTool(tool: DrawTool$1): void;
     protected onColorInput(event: Event): void;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * pen colour into the shared "Recent colours" list.
+     */
+    protected onColorCommit(event: Event): void;
     protected onWidthInput(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonDrawSectionComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonDrawSectionComponent, "pptx-ribbon-draw-section", never, { "activeTool": { "alias": "activeTool"; "required": false; "isSignal": true; }; "drawingColor": { "alias": "drawingColor"; "required": false; "isSignal": true; }; "drawingWidth": { "alias": "drawingWidth"; "required": false; "isSignal": true; }; }, { "drawToolChange": "drawToolChange"; }, never, never, true, never>;
@@ -15617,10 +15978,9 @@ interface ShowNavigatorDeps {
      */
     activeCustomShow?: () => ActiveShow;
     /**
-     * The `p:showPr/p:sldRg` slide-range restriction, when the deck is authored
-     * to open into a range rather than the whole deck or a custom show. Applied
-     * the same way `activeCustomShow` is: a filter on the navigable order, not a
-     * pre-filtered slide array.
+     * The `p:showPr/p:sldRg` range, when the deck opens into a range rather than
+     * the whole deck or a custom show. Applied like `activeCustomShow`: a filter
+     * on the navigable order, not a pre-filtered slide array.
      */
     authoredRange?: () => AuthoredRange;
     /** The slide at the CURRENT index (a computed over `currentIndex`). */
@@ -15633,16 +15993,14 @@ interface ShowNavigatorDeps {
     /** Ask the host to end the show; the host guards against double-closing. */
     requestClose: () => void;
     /**
-     * File > Options > Advanced > "End with black slide". PowerPoint's default
-     * is ON: running past the last slide raises a black "End of slide show"
-     * screen and only the NEXT forward input ends the show. Turning it off ends
-     * the show immediately instead. Undefined means the PowerPoint default.
+     * File > Options > Advanced > "End with black slide". PowerPoint's default is
+     * ON: running past the last slide raises a black end screen and only the NEXT
+     * forward input ends the show; off ends the show immediately instead.
      */
     endWithBlackSlide?: () => boolean | undefined;
     /**
-     * Set Up Slide Show > "Loop continuously until 'Esc'". When true, running
-     * past the last slide wraps back to the show's first slide instead of
-     * raising the end-of-show screen (or exiting, per `endWithBlackSlide`).
+     * Set Up Slide Show > "Loop continuously until 'Esc'": wraps to the show's
+     * first slide instead of raising the end screen (or exiting).
      */
     loopContinuously?: () => boolean | undefined;
 }
@@ -15651,27 +16009,26 @@ declare class PresentationShowNavigator {
     /** Zero-based index into `slides()`. */
     readonly currentIndex: _angular_core.WritableSignal<number>;
     /**
-     * True once the show has run past its last slide and the black "End of slide
-     * show" screen is up. It MUST be surfaced: while it is up the next input
-     * either goes nowhere (backward) or ends the show (forward), so a deck that
-     * kept painting its last slide looked stuck and swallowed every advance.
+     * True once the show has run past its last slide and the black end screen is
+     * up: while it is up the next input either goes nowhere (backward) or ends
+     * the show (forward), so a stuck deck must surface this rather than swallow
+     * every advance.
      */
     readonly endOfShow: _angular_core.WritableSignal<boolean>;
     /** Active slide-transition animation, or null when none is playing. */
     readonly activeTransition: _angular_core.WritableSignal<ActiveSlideTransition | null>;
     /**
-     * Set just before a BACKWARD slide change so the host's slide effect seeds the
+     * Set just before a BACKWARD change so the host's slide effect seeds the
      * incoming slide as fully built. Read-and-cleared via
      * {@link takePendingCompletedEntry}.
      */
     private pendingCompletedEntry;
     /** Pending `p:transition/@advTm` auto-advance timer for the current slide. */
     private autoAdvanceTimer;
+    /** Deck index before each committed change; backs {@link goToLastViewed}. */
+    private previousIndex;
     constructor(deps: ShowNavigatorDeps);
-    /**
-     * Consume the "entered backward" flag. The host's per-slide effect asks once
-     * per slide change, so this both reads and clears it.
-     */
+    /** Consume the "entered backward" flag: reads and clears it in one call. */
     takePendingCompletedEntry(): boolean;
     /**
      * Adopt an index pushed in by the host (its `startIndex` input, which an
@@ -15680,30 +16037,29 @@ declare class PresentationShowNavigator {
      */
     syncFromHost(requestedIndex: number): void;
     /**
-     * (Re)arm PowerPoint's "Advance slide: After <n>" timer, cancelling whatever
-     * was pending. Always cancelling first is load-bearing: a manual advance must
-     * never leave a stale timer running that then skips the slide the presenter
-     * just moved to.
+     * Jump back to the slide the show was on immediately before the current one
+     * (`ppaction://hlinkshowjump?jump=lastslideviewed`). A no-op before any
+     * navigation has happened yet.
+     */
+    goToLastViewed(): void;
+    /**
+     * (Re)arm PowerPoint's "Advance slide: After <n>" timer, always cancelling
+     * whatever was pending first: a manual advance must never leave a stale
+     * timer running that skips the slide the presenter just moved to.
      */
     armAutoAdvance(delayMs: number | undefined): void;
     /** Cancel any pending timed auto-advance (also called on teardown). */
     clearAutoAdvance(): void;
     navigate(direction: ShowDirection): void;
     /**
-     * Jump directly to `index` (clamped to the slide range). Used by zoom tiles
-     * and by on-slide Action Settings (`ppaction://hlinksldjump`).
-     *
-     * A jump ENTERS the target slide, so PowerPoint plays that slide's
-     * transition exactly as a forward step does. Committing with `null` here is
-     * why a deck navigated by clicking its own on-slide links showed no morph at
-     * all while the same transition played fine on PageDown.
+     * Jump directly to `index` (clamped). Used by zoom tiles and by on-slide
+     * Action Settings (`ppaction://hlinksldjump`); ENTERS the target slide, so
+     * PowerPoint plays its transition exactly as a forward step does.
      */
     goToSlide(index: number): void;
     /**
      * The single place a slide change becomes visible: set the transition, move
-     * the index, retarget the annotation layer, and tell the host. Both entry
-     * points share it so a change to one can never silently skip a step in the
-     * other (they had drifted apart as four repeated statements before).
+     * the index, retarget the annotation layer, and tell the host.
      */
     private commit;
 }
@@ -15754,6 +16110,13 @@ interface PresentationInputDeps {
      * with the option off.
      */
     confirmExternalHyperlink?: (href: string) => boolean;
+    /**
+     * `ppaction://customshow?id=<id>[&return=true]`: run the named custom show.
+     * The host resolves `customShowId` against its own custom-show registry (an
+     * id naming no surviving show is a no-op) and, when `returnAfter` is true,
+     * restores the origin show + slide once the sub-show runs off its end.
+     */
+    runCustomShow?: (customShowId: string, returnAfter: boolean) => void;
 }
 declare class PresentationInputController {
     private readonly deps;
@@ -15889,6 +16252,24 @@ declare class PresentationOverlayComponent implements OnInit {
      * host can offer the keep/discard prompt (mirrors React's exit flow).
      */
     readonly annotationsExit: _angular_core.OutputEmitterRef<SlideAnnotationMap>;
+    /**
+     * `ppaction://customshow?id=<id>[&return=true]`: the host resolves the id
+     * against its own custom-show registry (this overlay only knows the
+     * CURRENTLY active show's membership, via `activeCustomShow`) and, when
+     * `returnAfter` is true, restores the origin show + slide once the
+     * sub-show runs off its end (see `endOfShowChange` below).
+     */
+    readonly customShowRequest: _angular_core.OutputEmitterRef<{
+        customShowId: string;
+        returnAfter: boolean;
+    }>;
+    /**
+     * Mirrors the navigator's `endOfShow` flag. The host listens for this to
+     * implement `ppaction://customshow`'s "return after": ending the show while
+     * a return is pending means restore the origin instead of raising the
+     * black end screen (which `syncFromHost`'s host-forced jump then clears).
+     */
+    readonly endOfShowChange: _angular_core.OutputEmitterRef<boolean>;
     /** PowerPoint's Ctrl+M: hide ink markup without discarding the strokes. */
     protected readonly inkMarkupVisible: _angular_core.WritableSignal<boolean>;
     /** Click-stepped element-animation playback for the current slide. */
@@ -16056,7 +16437,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; }; "activeCustomShow": { "alias": "activeCustomShow"; "required": false; "isSignal": true; }; "authoredRange": { "alias": "authoredRange"; "required": false; "isSignal": true; }; "loopContinuously": { "alias": "loopContinuously"; "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; }; "showMenuOnRightClick": { "alias": "showMenuOnRightClick"; "required": false; "isSignal": true; }; "showPopupToolbar": { "alias": "showPopupToolbar"; "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; }; "authoredRange": { "alias": "authoredRange"; "required": false; "isSignal": true; }; "loopContinuously": { "alias": "loopContinuously"; "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; }; "showMenuOnRightClick": { "alias": "showMenuOnRightClick"; "required": false; "isSignal": true; }; "showPopupToolbar": { "alias": "showPopupToolbar"; "required": false; "isSignal": true; }; }, { "indexChange": "indexChange"; "closed": "closed"; "subtitlesChange": "subtitlesChange"; "presenterViewToggle": "presenterViewToggle"; "annotationsExit": "annotationsExit"; "customShowRequest": "customShowRequest"; "endOfShowChange": "endOfShowChange"; }, never, never, true, never>;
 }
 
 /**
@@ -16267,6 +16648,8 @@ declare class InspectorPanelComponent {
     protected readonly editor: EditorStateService;
     /** Reactive viewport / pointer flags (drives the bottom-sheet layout). */
     protected readonly mobile: IsMobileService;
+    /** "Recent colours" row backing the fill/stroke/text colour pickers below. */
+    protected readonly recentColors: RecentColorsService;
     /**
      * Root class list: gains the `is-mobile` modifier under the mobile
      * breakpoint so the panel becomes a full-width, touch-sized bottom sheet.
@@ -16350,8 +16733,17 @@ declare class InspectorPanelComponent {
     protected onRotationChange(event: Event): void;
     protected onOpacityChange(event: Event): void;
     protected onFillColorChange(event: Event): void;
+    /** Recent-colours row pick: commits through the same path as the native picker. */
+    protected onFillColorPick(color: string): void;
+    private commitFillColor;
     protected onStrokeColorChange(event: Event): void;
+    /** Recent-colours row pick: commits through the same path as the native picker. */
+    protected onStrokeColorPick(color: string): void;
+    private commitStrokeColor;
     protected onTextColorChange(event: Event): void;
+    /** Recent-colours row pick: commits through the same path as the native picker. */
+    protected onTextColorPick(color: string): void;
+    private commitTextColor;
     protected onFontSizeChange(event: Event): void;
     protected onBoldToggle(): void;
     protected onItalicToggle(): void;
@@ -16393,14 +16785,15 @@ declare class SlideDefaultInspectorComponent {
     readonly selectedElement: _angular_core.InputSignal<PptxElement | null>;
     /** The active slide's comments (host-owned; history-aware writes stay there). */
     readonly comments: _angular_core.InputSignal<PptxComment[]>;
+    /** Office 2021 modern comment authors, for the `@`-mention typeahead. */
+    readonly modernCommentAuthors: _angular_core.InputSignal<readonly PptxModernCommentAuthor[]>;
     /** Re-emitted comments-panel events (the host owns the comment writes). */
-    readonly commentAdd: _angular_core.OutputEmitterRef<string>;
+    readonly commentAdd: _angular_core.OutputEmitterRef<CommentSubmission>;
     readonly commentRemove: _angular_core.OutputEmitterRef<string>;
     readonly commentResolve: _angular_core.OutputEmitterRef<string>;
     readonly commentReply: _angular_core.OutputEmitterRef<{
         parentId: string;
-        text: string;
-    }>;
+    } & CommentSubmission>;
     protected readonly editor: EditorStateService;
     protected readonly canvasEditing: ViewerCanvasEditingService;
     protected readonly inspectorPanel: ViewerInspectorPanelService;
@@ -16415,7 +16808,7 @@ declare class SlideDefaultInspectorComponent {
      */
     protected readonly layerRows: _angular_core.Signal<LayerRow[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlideDefaultInspectorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideDefaultInspectorComponent, "pptx-slide-default-inspector", never, { "slideIndex": { "alias": "slideIndex"; "required": true; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "selectedElement": { "alias": "selectedElement"; "required": false; "isSignal": true; }; "comments": { "alias": "comments"; "required": false; "isSignal": true; }; }, { "commentAdd": "commentAdd"; "commentRemove": "commentRemove"; "commentResolve": "commentResolve"; "commentReply": "commentReply"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlideDefaultInspectorComponent, "pptx-slide-default-inspector", never, { "slideIndex": { "alias": "slideIndex"; "required": true; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; "selectedElement": { "alias": "selectedElement"; "required": false; "isSignal": true; }; "comments": { "alias": "comments"; "required": false; "isSignal": true; }; "modernCommentAuthors": { "alias": "modernCommentAuthors"; "required": false; "isSignal": true; }; }, { "commentAdd": "commentAdd"; "commentRemove": "commentRemove"; "commentResolve": "commentResolve"; "commentReply": "commentReply"; }, never, never, true, never>;
 }
 
 declare class PresentationPropertiesPanelComponent {
@@ -16474,17 +16867,36 @@ declare class SlideSizeCardComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     private readonly loader;
     private readonly editor;
+    private readonly translate;
     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>;
+    /**
+     * A confirmed size that differs from the current one and has at least one
+     * element to rescale, awaiting the user's Maximize/Ensure-Fit choice. `null`
+     * once answered (or when no prompt was needed) so the inline prompt hides.
+     */
+    protected readonly pendingResize: _angular_core.WritableSignal<SlideSizeEmu | null>;
     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. */
+    /**
+     * PowerPoint's Maximize/Ensure-Fit prompt: choosing a mode rescales every
+     * slide's elements (one undoable history entry via
+     * `EditorStateService.applyReplacement`) before the new size itself commits.
+     */
+    protected onRescaleChoice(pending: SlideSizeEmu, mode: SlideSizeRescaleMode): void;
+    /**
+     * Commit a confirmed size, prompting first (PowerPoint's Maximize/Ensure
+     * Fit) when it differs from the current size AND the deck has at least one
+     * element anywhere to rescale; an empty deck commits directly, as before.
+     */
     private apply;
+    /** Commit an EMU size and the canvas size it implies, together. */
+    private commit;
     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>;
 }
@@ -16544,6 +16956,8 @@ declare class SlideBackgroundCardComponent {
     private readonly editor;
     private readonly loader;
     private readonly translate;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly imageAccept = "image/png,image/jpeg,image/gif,image/webp,image/svg+xml";
     protected readonly slide: _angular_core.Signal<PptxSlide | undefined>;
     /** Stable per-slide key so the colour input reseeds only on slide change. */
@@ -16681,6 +17095,8 @@ declare class GradientPickerComponent {
      * EditorStateService.updateElement(slideIndex, element().id, patch).
      */
     readonly patch: _angular_core.OutputEmitterRef<Partial<PptxElement>>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     /** Derived gradient state from the current element. */
     protected readonly state: _angular_core.Signal<GradientState>;
     /** CSS gradient string for the preview strip. */
@@ -16705,6 +17121,8 @@ declare class EffectsPanelComponent {
      * The orchestrator should call EditorStateService.updateElement(slideIndex, element().id, patch).
      */
     readonly patch: _angular_core.OutputEmitterRef<Partial<PptxElement>>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     /** Derived EffectsState from the current element. */
     protected readonly state: _angular_core.Signal<EffectsState>;
     /** Stable key for keying inputs to the current element (prevents caret-reset). */
@@ -16769,6 +17187,8 @@ declare class Text3DPanelComponent {
     readonly element: _angular_core.InputSignal<PptxElement>;
     /** A partial-element patch for the orchestrator to commit (one history entry). */
     readonly patch: _angular_core.OutputEmitterRef<Partial<PptxElement>>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly materialPresets: readonly {
         value: MaterialPresetType | "";
         label: string;
@@ -16953,6 +17373,8 @@ declare class TableCellFormattingComponent {
     /** Emits the fully-updated element after any edit. */
     readonly elementChange: _angular_core.OutputEmitterRef<TablePptxElement>;
     private readonly selection;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly textToggles: ReadonlyArray<{
         key: 'bold' | 'italic' | 'underline';
         label: string;
@@ -16980,6 +17402,11 @@ declare class TableCellFormattingComponent {
     protected widthOf(key: NumKey): number;
     protected toggle(key: 'bold' | 'italic' | 'underline'): void;
     protected onColor(key: ColorKey, event: Event): void;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     protected onNumber(key: NumKey, event: Event): void;
     /** Merge a style patch into the selected cell and emit the updated element. */
     protected updateStyle(patch: Partial<PptxTableCellStyle>): void;
@@ -17013,6 +17440,8 @@ declare class TableCellAdvancedFillComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     /** Emits a partial style patch to merge into the cell. */
     readonly styleChange: _angular_core.OutputEmitterRef<Partial<PptxTableCellStyle>>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly fillModes: {
         value: "image" | "none" | "solid" | "gradient" | "pattern";
         i18nKey: string;
@@ -17049,6 +17478,11 @@ declare class TableCellAdvancedFillComponent {
     protected onPatternFg(event: Event): void;
     protected onPatternBg(event: Event): void;
     protected onMargin(key: 'marginTop' | 'marginBottom' | 'marginLeft' | 'marginRight', event: Event): void;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     private updateStop;
     private emitGradient;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableCellAdvancedFillComponent, never>;
@@ -17098,6 +17532,8 @@ declare class ChartDataEditorComponent {
     private readonly viewerOpts;
     private readonly host;
     private readonly injector;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     /**
      * File > Options > Advanced > "Properties follow chart data point for
      * current workbook". Falls back to PowerPoint's own default (`true`) when
@@ -17137,6 +17573,11 @@ declare class ChartDataEditorComponent {
     protected onAddSeries(): void;
     protected onRemoveLastSeries(): void;
     protected onRemoveSeries(seriesIndex: number): void;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * series colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     protected onAddCategory(): void;
     protected onRemoveLastCategory(): void;
     protected onRemoveCategory(catIndex: number): void;
@@ -17179,7 +17620,14 @@ declare class ChartDisplayOptionsComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     readonly elementChange: _angular_core.OutputEmitterRef<ChartPptxElement>;
     protected readonly legendPositions: readonly ChartOption<string>[];
+    protected readonly bar3DShapeOptions: readonly ChartSubtypeOption<PptxBar3DShape>[];
+    protected readonly radarStyleOptions: readonly ChartSubtypeOption<NonNullable<"marker" | "standard" | "filled" | undefined>>[];
+    protected readonly surfaceWireframeOptions: readonly ChartSubtypeOption<"true" | "false">[];
     protected readonly style: _angular_core.Signal<pptx_viewer_core.PptxChartStyle>;
+    protected readonly chartData: _angular_core.Signal<PptxChartData | undefined>;
+    protected readonly isBar3D: _angular_core.Signal<boolean>;
+    protected readonly isRadar: _angular_core.Signal<boolean>;
+    protected readonly isSurface: _angular_core.Signal<boolean>;
     /**
      * Read from the primary value axis's `majorGridlines`, matching what the
      * cartesian renderer actually draws; `style.hasGridlines` alone is a legacy
@@ -17192,6 +17640,9 @@ declare class ChartDisplayOptionsComponent {
     protected onLegendPosition(event: Event): void;
     protected onToggleGridlines(event: Event): void;
     protected onToggleDataLabels(event: Event): void;
+    protected onBar3DShape(event: Event): void;
+    protected onRadarStyle(event: Event): void;
+    protected onSurfaceWireframe(event: Event): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartDisplayOptionsComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartDisplayOptionsComponent, "pptx-chart-display-options", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "canEdit": { "alias": "canEdit"; "required": false; "isSignal": true; }; }, { "elementChange": "elementChange"; }, never, never, true, never>;
 }
@@ -17255,11 +17706,19 @@ declare class ChartAxisStyleOptionsComponent {
     readonly element: _angular_core.InputSignal<ChartPptxElement>;
     readonly canEdit: _angular_core.InputSignal<boolean>;
     readonly elementChange: _angular_core.OutputEmitterRef<ChartPptxElement>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly dashOptions: readonly ChartOption<ChartGridlineDashValue>[];
     protected readonly gridlineKinds: readonly ["major", "minor"];
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     protected readonly rows: _angular_core.Signal<AxisRow[]>;
     protected gridlineEnabled(axis: PptxChartAxisFormatting, which: 'major' | 'minor'): boolean;
     protected gridlineSpPr(axis: PptxChartAxisFormatting, which: 'major' | 'minor'): pptx_viewer_core.PptxChartShapeProps | undefined;
+    protected gridDash(axis: PptxChartAxisFormatting, which: 'major' | 'minor'): string;
     protected onLogScale(axisType: PptxChartAxisType, axis: PptxChartAxisFormatting, event: Event): void;
     protected onLogBase(axisType: PptxChartAxisType, event: Event): void;
     protected onTitleFont(axisType: PptxChartAxisType, event: Event): void;
@@ -17278,7 +17737,14 @@ declare class ChartMarkerOptionsComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     readonly elementChange: _angular_core.OutputEmitterRef<ChartPptxElement>;
     protected readonly symbolOptions: readonly ChartOption<ChartMarkerSymbolValue>[];
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly series: _angular_core.Signal<PptxChartSeries[]>;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     protected readonly supported: _angular_core.Signal<boolean>;
     protected onSymbol(index: number, event: Event): void;
     protected onSize(index: number, event: Event): void;
@@ -17304,7 +17770,14 @@ declare class ChartDatapointMarkerOptionsComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     readonly elementChange: _angular_core.OutputEmitterRef<ChartPptxElement>;
     protected readonly symbolOptions: ChartOption<ChartMarkerSymbolValue>[];
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     private readonly seriesIndex;
+    /**
+     * Record the committed (native `change`, not the live-preview `input`)
+     * colour into the shared "Recent colours" list.
+     */
+    protected pushRecentColor(event: Event): void;
     protected readonly series: _angular_core.Signal<PptxChartSeries[]>;
     protected readonly categories: _angular_core.Signal<string[]>;
     /** Clamp the picker: removing a series must not strand the index past the end. */
@@ -18175,47 +18648,6 @@ declare class CommentMarkersOverlayComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentMarkersOverlayComponent, "pptx-comment-markers-overlay", never, { "comments": { "alias": "comments"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": true; "isSignal": true; }; }, { "markerClick": "markerClick"; }, never, never, true, never>;
 }
 
-declare class CommentsPanelComponent {
-    /** The active slide's comments (already filtered to the active slide). */
-    readonly comments: _angular_core.InputSignal<PptxComment[]>;
-    private readonly translate;
-    /** Display name shown in the compose label ("Commenting as …"). */
-    readonly authorName: _angular_core.InputSignal<string>;
-    /** Emits the trimmed comment text the user wants to add. */
-    readonly add: _angular_core.OutputEmitterRef<string>;
-    /** Emits the id of a comment the user wants to remove. */
-    readonly remove: _angular_core.OutputEmitterRef<string>;
-    /** Emits the id of a comment whose resolved flag should toggle. */
-    readonly resolve: _angular_core.OutputEmitterRef<string>;
-    /** Emits the parent comment id + trimmed text of a threaded reply. */
-    readonly reply: _angular_core.OutputEmitterRef<{
-        parentId: string;
-        text: string;
-    }>;
-    /** Current text typed into the compose textarea. */
-    readonly draft: _angular_core.WritableSignal<string>;
-    /** Whether the draft has non-whitespace content (enables the submit button). */
-    readonly canAdd: _angular_core.Signal<boolean>;
-    /** Id of the comment whose reply composer is open (one at a time). */
-    readonly replyingTo: _angular_core.WritableSignal<string | null>;
-    /** Current text typed into the open reply composer. */
-    readonly replyDraft: _angular_core.WritableSignal<string>;
-    /** Whether the reply draft has content (enables the reply submit button). */
-    readonly canReply: _angular_core.Signal<boolean>;
-    onDraftInput(event: Event): void;
-    submit(event: Event): void;
-    /** Localized reply-composer placeholder ("Reply to <author>..."). */
-    replyPlaceholder(comment: PptxComment): string;
-    /** Open the reply composer under `parentId` (closing any other composer). */
-    startReply(parentId: string): void;
-    cancelReply(): void;
-    onReplyInput(event: Event): void;
-    submitReply(parentId: string): void;
-    formatTimestamp(value: string | undefined): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommentsPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommentsPanelComponent, "pptx-comments-panel", never, { "comments": { "alias": "comments"; "required": false; "isSignal": true; }; "authorName": { "alias": "authorName"; "required": false; "isSignal": true; }; }, { "add": "add"; "remove": "remove"; "resolve": "resolve"; "reply": "reply"; }, never, never, true, never>;
-}
-
 declare class CommentsService {
     /**
      * The active slide's comments (the deck slice for `activeSlideIndex`).
@@ -18430,10 +18862,15 @@ declare class ActionSettingsPanelComponent {
     protected actionFor(trigger: Trigger): ElementAction | undefined;
     /** The action type this trigger's controls should render right now. */
     protected typeFor(trigger: Trigger): ElementActionType;
+    /** `data.customShows`, for the `customShow` type's target `<select>`. */
+    private readonly loader;
+    protected readonly customShows: _angular_core.Signal<readonly PptxCustomShow[]>;
     private update;
     protected onType(event: Event, trigger: Trigger): void;
-    protected onUrl(event: Event, trigger: Trigger): void;
-    protected onSlide(event: Event, trigger: Trigger): void;
+    protected onUrl(url: string, trigger: Trigger): void;
+    protected onSlide(oneBasedSlide: number, trigger: Trigger): void;
+    protected onCustomShow(customShowId: string, trigger: Trigger): void;
+    protected onReturnAfter(returnAfter: boolean, trigger: Trigger): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActionSettingsPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActionSettingsPanelComponent, "pptx-action-settings-panel", never, { "element": { "alias": "element"; "required": true; "isSignal": true; }; "slideCount": { "alias": "slideCount"; "required": false; "isSignal": true; }; }, { "patch": "patch"; }, never, never, true, never>;
 }
@@ -18445,6 +18882,8 @@ type ImageElement = PptxElement & {
 declare class ImagePropertiesPanelComponent {
     readonly element: _angular_core.InputSignal<PptxElement>;
     readonly patch: _angular_core.OutputEmitterRef<Partial<PptxElement>>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly image: _angular_core.Signal<ImageElement>;
     protected readonly effects: _angular_core.Signal<PptxImageEffects>;
     protected readonly artisticEffects: readonly [readonly ["none", "pptx.image.effectNone", ""], readonly ["blur", "pptx.image.effectBlur", "blur(4px)"], readonly ["grayscale", "pptx.image.effectGrayscale", "grayscale(100%)"], readonly ["sepia", "pptx.image.effectSepia", "sepia(100%)"], readonly ["pencilSketch", "pptx.image.effectPencilSketch", "grayscale(100%) contrast(150%) brightness(80%)"], readonly ["lineDrawing", "pptx.image.effectLineDrawing", "grayscale(100%) contrast(150%)"], readonly ["watercolorSponge", "pptx.image.effectWatercolor", "saturate(150%) blur(1px)"], readonly ["paintStrokes", "pptx.image.effectPaintStrokes", "blur(3px) saturate(140%)"], readonly ["glow_edges", "pptx.image.effectGlowEdges", "contrast(180%) invert(5%) brightness(110%)"], readonly ["glowDiffused", "pptx.image.effectGlowDiffused", "blur(3px) brightness(120%)"], readonly ["cement", "pptx.image.effectCement", "contrast(200%) brightness(60%)"], readonly ["photocopy", "pptx.image.effectPhotocopy", "grayscale(100%) contrast(200%) brightness(120%)"], readonly ["filmGrain", "pptx.image.effectFilmGrain", "contrast(110%) brightness(105%)"], readonly ["mosaic", "pptx.image.effectMosaic", "blur(8px) contrast(105%)"], readonly ["chalkSketch", "pptx.image.effectChalk", "grayscale(80%) contrast(140%) brightness(110%)"], readonly ["marker", "pptx.image.effectMarker", "contrast(130%) saturate(130%)"], readonly ["cutout", "pptx.image.effectCutout", "contrast(300%) brightness(120%)"], readonly ["pastelsSmooth", "pptx.image.effectPastels", "blur(4px) saturate(120%)"], readonly ["paint", "pptx.image.effectPaint", "blur(3px) saturate(160%) contrast(110%)"], readonly ["plasticWrap", "pptx.image.effectPlasticWrap", "contrast(150%) brightness(115%) saturate(80%)"], readonly ["lightScreen", "pptx.image.effectLightScreen", "brightness(130%) contrast(80%)"], readonly ["sharpen", "pptx.image.effectSharpen", "contrast(160%) brightness(105%)"], readonly ["texturizer", "pptx.image.effectTexturizer", "contrast(110%) brightness(105%)"], readonly ["crisscrossEtching", "pptx.image.effectCrisscross", "grayscale(60%) contrast(120%)"]];
@@ -19441,7 +19880,7 @@ declare class AccountPageComponent {
     readonly accountAuth: _angular_core.InputSignal<AccountAuthConfig | undefined>;
     private readonly translate;
     protected readonly swatches: readonly string[];
-    protected readonly version = "3.3.0";
+    protected readonly version = "3.4.0";
     protected readonly profile: _angular_core.WritableSignal<ViewerProfile>;
     protected readonly initial: _angular_core.Signal<string>;
     protected readonly usage: _angular_core.WritableSignal<LocalStorageUsageSummary | null>;
@@ -20058,6 +20497,12 @@ declare class PresenterViewComponent {
      * forward press lands on is the show's next member, not `index + 1`.
      */
     readonly activeCustomShow: _angular_core.InputSignal<ShowOrderCustomShow | null>;
+    /**
+     * The deck's authored `p:showPr/p:sldRg` slide-range restriction, or null
+     * for the whole deck. The next-slide preview must honour it the same way it
+     * honours {@link activeCustomShow}.
+     */
+    readonly authoredRange: _angular_core.InputSignal<AuthoredSlideRange | null>;
     readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
     readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
@@ -20132,7 +20577,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; }; "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>;
+    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; }; "authoredRange": { "alias": "authoredRange"; "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>;
 }
 
 /**
@@ -20161,6 +20606,12 @@ declare class MobilePresenterViewComponent {
      * forward press lands on is the show's next member, not `index + 1`.
      */
     readonly activeCustomShow: _angular_core.InputSignal<ShowOrderCustomShow | null>;
+    /**
+     * The deck's authored `p:showPr/p:sldRg` slide-range restriction, or null
+     * for the whole deck. The next-slide preview must honour it the same way it
+     * honours {@link activeCustomShow}.
+     */
+    readonly authoredRange: _angular_core.InputSignal<AuthoredSlideRange | null>;
     readonly canvasSize: _angular_core.InputSignal<CanvasSize>;
     readonly templateElements: _angular_core.InputSignal<readonly PptxElement[]>;
     readonly mediaDataUrls: _angular_core.InputSignal<Map<string, string>>;
@@ -20186,7 +20637,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; }; "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>;
+    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; }; "authoredRange": { "alias": "authoredRange"; "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>;
 }
 
 /**
@@ -21000,6 +21451,8 @@ declare class SmartArtPropertiesComponent {
     readonly canEdit: _angular_core.InputSignal<boolean>;
     /** Emits a complete new data model after any edit. */
     readonly smartArtDataChange: _angular_core.OutputEmitterRef<PptxSmartArtData>;
+    /** Optional: absent in a standalone unit test with no viewer-level DI tree. */
+    private readonly recentColors;
     protected readonly layoutTypes: readonly SmartArtLayoutType[];
     protected readonly colorSchemes: readonly SmartArtColorScheme[];
     protected readonly styleOptions: readonly SmartArtStyle[];
@@ -21230,6 +21683,9 @@ declare class RibbonColorPopoverComponent {
     readonly titleKey: _angular_core.InputSignal<string>;
     readonly swatchAriaKey: _angular_core.InputSignal<string>;
     readonly pick: _angular_core.OutputEmitterRef<string>;
+    protected readonly recentColors: RecentColorsService;
+    /** Every commit through this popover both fires `pick` and records the colour as recently used. */
+    protected onPick(color: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<RibbonColorPopoverComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<RibbonColorPopoverComponent, "pptx-ribbon-color-popover", never, { "current": { "alias": "current"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "titleKey": { "alias": "titleKey"; "required": false; "isSignal": true; }; "swatchAriaKey": { "alias": "swatchAriaKey"; "required": false; "isSignal": true; }; }, { "pick": "pick"; }, never, ["*"], true, never>;
 }