ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/layout-preview.mjs

@@ -0,0 +1 @@
+export { buildLayoutPreviewFrames, buildLayoutPreviewGeometry } from '../chunk-A63ASSCH.mjs';

package/dist/pptx/render/linked-text-box-overflow.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Linked text box overflow utilities.
+ *
+ * Wraps the core `getLinkedTextBoxSegments` function and provides helpers for
+ * computing which text segments should render in each box of a linked text box
+ * chain. Framework-agnostic.
+ */
+import type { PptxElement, TextSegment } from 'ooxml-core/pptx';
+/**
+ * Determine whether an element participates in a linked text box chain.
+ */
+export declare function isLinkedTextBox(element: PptxElement): boolean;
+/**
+ * Determine whether an element is the head (seq 0) of a linked text box chain.
+ */
+export declare function isLinkedTextBoxHead(element: PptxElement): boolean;
+/**
+ * Compute the distributed text segments for a given element in a linked text
+ * box chain.
+ *
+ * Returns the segments that this element should display after overflow
+ * distribution, or `undefined` if the element is not part of a chain, is the
+ * only member, or the caller has no sibling list to resolve the chain against.
+ *
+ * `slideElements` is nullable so every binding can call this unconditionally at
+ * its text-render site: a surface that does not (yet) thread the sibling list
+ * down, or renders an element outside any slide, degrades to the element's own
+ * authored segments instead of forcing a guard into each view layer.
+ *
+ * `slideElements` is the slide's TOP-LEVEL list in every binding, including at
+ * a group child's render site, so the chain lookup flattens it first. The
+ * not-a-chain guard runs before the flatten because this is a per-element,
+ * per-render call and all but a handful of elements exit here.
+ */
+export declare function getOverflowSegments(element: PptxElement, slideElements: readonly PptxElement[] | undefined): TextSegment[] | undefined;
+/**
+ * Build a complete segment distribution map for all linked text box chains on a
+ * slide.
+ *
+ * Returns a map from element ID to the text segments that element should
+ * render. Elements not in any chain are not included. Group children are
+ * included: the map is keyed by element ID, which is unique slide-wide, so a
+ * caller can look up a nested box without knowing where it sits.
+ */
+export declare function buildSlideOverflowMap(slideElements: readonly PptxElement[]): Map<string, TextSegment[]>;
+//# sourceMappingURL=linked-text-box-overflow.d.ts.map

package/dist/pptx/render/linked-text-box-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-text-box-overflow.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/linked-text-box-overflow.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAahE;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE7D;AAuDD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAMjE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAClC,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,GAC/C,WAAW,EAAE,GAAG,SAAS,CAQ3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACpC,aAAa,EAAE,SAAS,WAAW,EAAE,GACnC,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,CAmB5B"}

package/dist/pptx/render/master-page-layout.d.ts

@@ -0,0 +1,12 @@
+import type { CanvasSize } from '../types.js';
+export interface MasterPageRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export declare const DEFAULT_MASTER_PAGE_SIZE: Readonly<CanvasSize>;
+export declare const NOTES_MASTER_PLACEHOLDER_RECTS: Readonly<Record<string, MasterPageRect>>;
+/** Framework-neutral handout slot geometry, expressed as page fractions. */
+export declare function computeHandoutSlotLayout(slidesPerPage: number, slideAspect?: number): MasterPageRect[];
+//# sourceMappingURL=master-page-layout.d.ts.map

package/dist/pptx/render/master-page-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-page-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/master-page-layout.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,MAAM,WAAW,cAAc;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,UAAU,CAA+B,CAAC;AAE1F,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAOnF,CAAC;AAKF,4EAA4E;AAC5E,wBAAgB,wBAAwB,CACvC,aAAa,EAAE,MAAM,EACrB,WAAW,SAAQ,GACjB,cAAc,EAAE,CAmDlB"}

package/dist/pptx/render/master-view-crud.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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
+ *   `ooxml-core/pptx`'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
+ */
+import type { LayoutDefinition, MasterLayoutCrudFailure, PptxData, PptxHandler } from 'ooxml-core/pptx';
+import type { MasterViewTarget } from './master-view.js';
+/** One Slide Master view sidebar command. */
+export type MasterViewCrudActionId = 'addLayout' | 'duplicateLayout' | 'deleteLayout' | 'renameLayout' | 'addMaster' | 'duplicateMaster' | 'deleteMaster' | 'renameMaster';
+/** A framework-neutral descriptor for one sidebar button. */
+export 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;
+}
+/**
+ * The i18n key a binding should show when {@link applyMasterViewCrudAction}
+ * refuses a command. Core reports a single `inUse` reason for both part
+ * kinds, so the copy is picked by the command that was attempted.
+ */
+export declare function masterViewCrudFailureKey(id: MasterViewCrudActionId, reason: MasterLayoutCrudFailure['reason']): string;
+/**
+ * The eight Slide Master view sidebar commands for the current selection,
+ * each already resolved to enabled/disabled with the i18n key a binding
+ * needs to explain why (`pptx.masterView.layoutInUse` /
+ * `masterInUse` / `lastMaster`). Returns `[]` outside the "slides" tab (the
+ * Notes/Handout master panes have no layout gallery to act on).
+ */
+export declare function masterViewCrudActions(data: PptxData, target: MasterViewTarget | null | undefined): MasterViewCrudAction[];
+/** Extra input a command needs beyond `target`: a new name, or a layout definition for `addLayout`. */
+export interface MasterViewCrudActionOptions {
+    name?: string;
+    layoutDefinition?: LayoutDefinition;
+}
+/** {@link applyMasterViewCrudAction} success: the selection to move to. */
+export interface MasterViewCrudApplySuccess {
+    ok: true;
+    handler: PptxHandler;
+    data: PptxData;
+    target: MasterViewTarget;
+}
+export type MasterViewCrudApplyResult = MasterViewCrudApplySuccess | MasterLayoutCrudFailure;
+/**
+ * Run one Slide Master view sidebar command against `ooxml-core/pptx`'s
+ * `master-layout-crud` module, and resolve the selection the sidebar should
+ * move to afterwards: the layout/master the command just created, or the
+ * owning master once a delete removes the current selection.
+ *
+ * `options.name` is required for `renameLayout` / `renameMaster`;
+ * `options.layoutDefinition` is optional for `addLayout` (a default
+ * title-only layout is generated when omitted, see `insertLayout` in core).
+ */
+export declare function applyMasterViewCrudAction(handler: PptxHandler, data: PptxData, action: MasterViewCrudActionId, target: MasterViewTarget, options?: MasterViewCrudActionOptions): Promise<MasterViewCrudApplyResult>;
+//# sourceMappingURL=master-view-crud.d.ts.map

package/dist/pptx/render/master-view-crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-view-crud.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/master-view-crud.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,QAAQ,EACR,WAAW,EAEX,MAAM,iBAAiB,CAAC;AAYzB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,6CAA6C;AAC7C,MAAM,MAAM,sBAAsB,GAC/B,WAAW,GACX,iBAAiB,GACjB,cAAc,GACd,cAAc,GACd,WAAW,GACX,iBAAiB,GACjB,cAAc,GACd,cAAc,CAAC;AAElB,6DAA6D;AAC7D,MAAM,WAAW,oBAAoB;IACpC,EAAE,EAAE,sBAAsB,CAAC;IAC3B,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,EAAE,EAAE,sBAAsB,EAC1B,MAAM,EAAE,uBAAuB,CAAC,QAAQ,CAAC,GACvC,MAAM,CASR;AAaD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GACzC,oBAAoB,EAAE,CAmDxB;AAED,uGAAuG;AACvG,MAAM,WAAW,2BAA2B;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACpC;AAED,2EAA2E;AAC3E,MAAM,WAAW,0BAA0B;IAC1C,EAAE,EAAE,IAAI,CAAC;IACT,OAAO,EAAE,WAAW,CAAC;IACrB,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,gBAAgB,CAAC;CACzB;AACD,MAAM,MAAM,yBAAyB,GAAG,0BAA0B,GAAG,uBAAuB,CAAC;AA2B7F;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC9C,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,sBAAsB,EAC9B,MAAM,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,2BAA2B,GACnC,OAAO,CAAC,yBAAyB,CAAC,CAsGpC"}

package/dist/pptx/render/master-view-editing.d.ts

@@ -0,0 +1,57 @@
+/**
+ * master-view-editing.ts: the master-view edits that are not element patches.
+ *
+ * Splits out of {@link module:render/master-view} purely for file size; the
+ * routing rules are the same ones, so every write here goes back through
+ * `replaceMasterViewElements` or writes the same `MasterViewWrite` shape.
+ *
+ * @module render/master-view-editing
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { MasterViewDocument, MasterViewTarget, MasterViewWrite } from './master-view.js';
+/**
+ * Remove elements from the master view, routing each removal to the part that
+ * owns it. A layout canvas paints its master's artwork too, so deleting by
+ * filtering the flat list and re-partitioning is the only way a shape leaves
+ * the right shape tree.
+ */
+export declare function deleteMasterViewElements(document: MasterViewDocument, target: MasterViewTarget | null | undefined, elementIds: readonly string[]): MasterViewWrite | null;
+/**
+ * The master-view element a pointer hit belongs to.
+ *
+ * A binding that resolves a click by walking up to the nearest
+ * `[data-element-id]` lands on a GROUP CHILD, because every binding stamps that
+ * marker on a group's children as well as on the group. Every master-view write
+ * routes through the part's own TOP-LEVEL shape list, where a child id matches
+ * nothing, so the edit is dropped without a word: Vue could delete a plain
+ * master shape but never a group, which read as a broken Delete key rather than
+ * a mis-aimed one.
+ *
+ * Ownership is decided by walking `children`, not by comparing id prefixes: a
+ * group child's id does derive from its group's, but that is an id-format
+ * convention the editor is free to break, and a prefix test would also claim a
+ * sibling whose id merely starts the same way.
+ *
+ * @returns The owning top-level element's id, or `null` when the id belongs to
+ *   nothing the master view is painting (a click on the surface, or on a
+ *   navigation-rail preview).
+ */
+export declare function masterViewOwnerElementId(elements: readonly PptxElement[], elementId: string | null | undefined): string | null;
+/**
+ * The background colour of the part the master view has selected.
+ *
+ * This is the *primary* part, not the whole painted stack: selecting a layout
+ * shows the master's artwork behind it, but the background belongs to the
+ * layout, and `masterViewParts` already falls back to the master's colour when
+ * the layout declares none.
+ */
+export declare function masterViewBackgroundColor(document: MasterViewDocument, target: MasterViewTarget | null | undefined): string | undefined;
+/**
+ * Set the background colour on the part the master view has selected.
+ *
+ * The empty string means "remove", which restores inheritance from the master
+ * (a layout PowerPoint has not touched carries no `p:bg` at all). Returns only
+ * the models that changed, or `null` when the target resolves to nothing.
+ */
+export declare function setMasterViewBackgroundColor(document: MasterViewDocument, target: MasterViewTarget | null | undefined, backgroundColor: string): MasterViewWrite | null;
+//# sourceMappingURL=master-view-editing.d.ts.map

package/dist/pptx/render/master-view-editing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-view-editing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/master-view-editing.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAoB,WAAW,EAAmB,MAAM,iBAAiB,CAAC;AAQtF,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE3F;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAC3C,UAAU,EAAE,SAAS,MAAM,EAAE,GAC3B,eAAe,GAAG,IAAI,CASxB;AAeD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAClC,MAAM,GAAG,IAAI,CAUf;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACxC,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,GACzC,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC3C,QAAQ,EAAE,kBAAkB,EAC5B,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAAG,SAAS,EAC3C,eAAe,EAAE,MAAM,GACrB,eAAe,GAAG,IAAI,CAgCxB"}

package/dist/pptx/render/master-view.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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
+ */
+import type { MasterViewTab, PptxElement, PptxHandoutMaster, PptxImageProperties, PptxNotesMaster, PptxSlide, PptxSlideMaster } from 'ooxml-core/pptx';
+/** Which part the master view is currently pointed at. */
+export interface MasterViewTarget {
+    tab: MasterViewTab;
+    masterIndex: number;
+    /** `null` selects the master itself rather than one of its layouts. */
+    layoutIndex: number | null;
+}
+/** The parts a master view can reach, however the binding stores them. */
+export interface MasterViewDocument {
+    slideMasters: readonly PptxSlideMaster[];
+    notesMaster?: PptxNotesMaster | undefined;
+    handoutMaster?: PptxHandoutMaster | undefined;
+}
+/** Which model an element belongs to, so a write can be routed back to it. */
+export type MasterViewPartKind = 'master' | 'layout' | 'notes' | 'handout';
+/** One part contributing elements to the master-view canvas. */
+export interface MasterViewPart {
+    kind: MasterViewPartKind;
+    /** Archive path of the part (`ppt/slideLayouts/slideLayout3.xml`). */
+    path: string;
+    /** Index into `slideMasters`, for `master` and `layout` parts. */
+    masterIndex?: number;
+    /** Index into that master's `layouts`, for `layout` parts. */
+    layoutIndex?: number;
+    elements: readonly PptxElement[];
+    backgroundColor?: string | undefined;
+    backgroundImage?: string | undefined;
+    backgroundImageProperties?: PptxImageProperties | undefined;
+}
+/** A write-back for one master-view edit; only the touched models are set. */
+export interface MasterViewWrite {
+    slideMasters?: PptxSlideMaster[];
+    notesMaster?: PptxNotesMaster;
+    handoutMaster?: PptxHandoutMaster;
+}
+/**
+ * The parts painted for this target, back to front.
+ *
+ * Selecting a layout also paints its master underneath, which is what
+ * PowerPoint shows and what the master's `p:spTree` is for. The last entry is
+ * the *primary* part: the one a newly drawn shape belongs to.
+ */
+export declare function masterViewParts(document: MasterViewDocument, target: MasterViewTarget | null | undefined): MasterViewPart[];
+/** The part a newly drawn or unrecognised element belongs to. */
+export declare function primaryMasterViewPart(parts: readonly MasterViewPart[]): MasterViewPart | undefined;
+/**
+ * The selected part rendered as a slide, so the ordinary canvas can paint it.
+ *
+ * The id is the part's archive path. That is deliberate: it is the key the
+ * save writer matches parts on, and it must never collide with a real
+ * `PptxSlide.id`.
+ */
+export declare function masterViewPseudoSlide(document: MasterViewDocument, target: MasterViewTarget | null | undefined): PptxSlide | undefined;
+/** Every element the master-view canvas is currently painting. */
+export declare function masterViewElements(document: MasterViewDocument, target: MasterViewTarget | null | undefined): PptxElement[];
+/** The part that owns one element id, or the primary part when it is new. */
+export declare function masterViewPartForElement(parts: readonly MasterViewPart[], elementId: string): MasterViewPart | undefined;
+/**
+ * Split a flat element list back into the parts it came from.
+ *
+ * The canvas hands back one array, but a layout view paints two parts, so an
+ * edit has to be routed by ownership rather than dropped into whichever model
+ * the binding happens to hold. Elements the loader never produced (a shape the
+ * user just drew) land on the primary part.
+ */
+export declare function partitionMasterViewElements(parts: readonly MasterViewPart[], elements: readonly PptxElement[]): Map<string, PptxElement[]>;
+/**
+ * Replace the master view's element list, routing each element back to the
+ * part that owns it. Returns only the models that changed, or `null` when the
+ * target resolves to nothing.
+ */
+export declare function replaceMasterViewElements(document: MasterViewDocument, target: MasterViewTarget | null | undefined, elements: readonly PptxElement[]): MasterViewWrite | null;
+/**
+ * Apply a partial update to one element in the master view.
+ *
+ * This is the shape every binding's canvas needs: a drag, a rotate or a text
+ * commit arrives as `{ id, patch }` and has to reach whichever part owns that
+ * id, which is not necessarily the part the sidebar has selected.
+ */
+export declare function updateMasterViewElement(document: MasterViewDocument, target: MasterViewTarget | null | undefined, elementId: string, patch: Partial<PptxElement>): MasterViewWrite | null;
+/** True when the master view is pointed at a part that has something to edit. */
+export declare function isMasterViewEditable(document: MasterViewDocument, target: MasterViewTarget | null | undefined): boolean;
+//# sourceMappingURL=master-view.d.ts.map

package/dist/pptx/render/master-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-view.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/master-view.ts"],"names":[],"mappings":"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"}

package/dist/pptx/render/mathml-sanitize.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Safely sanitise a MathML/SVG markup string.
+ *
+ * In browser environments DOMPurify ships with `sanitize` ready to go. In
+ * non-DOM contexts (node-based tests, SSR without jsdom) there is no
+ * sanitizer to run, and the markup can originate from an untrusted OOXML
+ * equation, so this fails closed (empty string) rather than passing raw,
+ * unsanitised markup through to a caller that injects it as HTML.
+ *
+ * @param markup - MathML (optionally with embedded SVG) markup to sanitise.
+ * @returns The sanitised markup, or `''` when no DOM sanitizer is available.
+ */
+export declare function sanitizeMathMl(markup: string): string;
+//# sourceMappingURL=mathml-sanitize.d.ts.map

package/dist/pptx/render/mathml-sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathml-sanitize.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/mathml-sanitize.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASrD"}

package/dist/pptx/render/media-file-type.d.ts

@@ -0,0 +1,11 @@
+/** The media kind a chosen file's MIME type maps to, or `null` for an unsupported type. */
+export type MediaFileType = 'audio' | 'video';
+/**
+ * Classify an inserted file's MIME type as `audio`, `video`, or `null` for
+ * anything else. Every binding's "insert audio/video" flow needs this same
+ * check before building a `media` element; without the `null` case a binding
+ * ends up treating any non-audio file (a PDF, an image picked by mistake, an
+ * unrecognised codec) as video.
+ */
+export declare function classifyMediaType(mimeType: string): MediaFileType | null;
+//# sourceMappingURL=media-file-type.d.ts.map

package/dist/pptx/render/media-file-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-file-type.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-file-type.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,OAAO,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAQxE"}

package/dist/pptx/render/media-fullscreen.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Media `fullScrn` full-slide playback overlay.
+ *
+ * ECMA-376's media-playback extension (`p:cMediaNode`'s ext list, surfaced by
+ * core as `MediaPptxElement.fullScreen`) lets an author mark a video/audio
+ * clip to play letterboxed across the WHOLE slide once it starts, instead of
+ * at its authored frame. PowerPoint only switches to that layout once the
+ * clip actually starts playing on the live show; a still slide (even one with
+ * `fullScrn` media on it) shows the clip at its authored frame.
+ *
+ * WHY shared: this was React-only (`ElementRenderer.tsx`'s `isFullscreenMedia`
+ * plus inline literals in `element-renderer-helpers.tsx`'s `getContainerStyle`).
+ * All five bindings' media inspector already expose the same `fullScreen`
+ * checkbox (`pptx.media.fullScreen`), so a deck that turns it on played
+ * letterboxed only in React and inline-at-frame everywhere else. The trigger
+ * and the resulting layout are pure decisions with no framework dependency, so
+ * both live here; a binding only wires the boolean to its own play/pause
+ * listeners and spreads the style object over its normal container style.
+ *
+ * @module render/media-fullscreen
+ */
+/** Inputs for {@link isMediaFullscreenActive}. */
+export interface MediaFullscreenInput {
+    /** The authored `fullScrn` flag (`MediaPptxElement.fullScreen`). */
+    fullScreen?: boolean;
+    /** True only on the live presentation (show) stage; never a still/preview/canvas. */
+    presenting: boolean;
+    /**
+     * True while the media element is actively playing: a `play` event has
+     * fired and no `pause`/`ended` has followed it yet.
+     */
+    playing: boolean;
+}
+/**
+ * Whether a media element should currently render in the full-slide overlay
+ * layout.
+ *
+ * All three conditions are required: the element must be authored `fullScrn`,
+ * the surface must be the live show (a still/preview/authoring canvas never
+ * gets the overlay), and playback must actually be under way. PowerPoint does
+ * not switch layout the instant the slide appears, only once the clip starts.
+ */
+export declare function isMediaFullscreenActive(input: MediaFullscreenInput): boolean;
+/**
+ * The CSS-legal style override every binding applies to a media element's
+ * outer container while {@link isMediaFullscreenActive} is true: pin it to
+ * the full slide surface, above everything else, on a black backdrop, with a
+ * short transition so the jump from the authored frame reads as a deliberate
+ * zoom rather than a hard cut.
+ *
+ * Spread on TOP of the binding's normal container style; when
+ * {@link isMediaFullscreenActive} is false a binding must leave its normal
+ * style untouched, none of these fields apply.
+ */
+export declare const MEDIA_FULLSCREEN_OVERLAY_STYLE: {
+    readonly left: 0;
+    readonly top: 0;
+    readonly width: '100%';
+    readonly height: '100%';
+    readonly transform: 'none';
+    readonly zIndex: 20;
+    readonly background: '#000';
+    readonly transition: 'left 0.3s ease, top 0.3s ease, width 0.3s ease, height 0.3s ease';
+    readonly borderColor: 'transparent';
+};
+/** The type of {@link MEDIA_FULLSCREEN_OVERLAY_STYLE}, for typed consumers. */
+export type MediaFullscreenOverlayStyle = typeof MEDIA_FULLSCREEN_OVERLAY_STYLE;
+/**
+ * Whether the full-slide overlay's stop/close affordance should be drawn.
+ * Identical trigger to {@link isMediaFullscreenActive}: the button only makes
+ * sense once the overlay itself is showing.
+ */
+export declare function shouldShowMediaFullscreenStopButton(input: MediaFullscreenInput): boolean;
+//# sourceMappingURL=media-fullscreen.d.ts.map

package/dist/pptx/render/media-fullscreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-fullscreen.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-fullscreen.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,kDAAkD;AAClD,MAAM,WAAW,oBAAoB;IACpC,oEAAoE;IACpE,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,qFAAqF;IACrF,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAE5E;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,8BAA8B;aAC1C,IAAI,EAAE,CAAC;aACP,GAAG,EAAE,CAAC;aACN,KAAK,EAAE,MAAM;aACb,MAAM,EAAE,MAAM;aACd,SAAS,EAAE,MAAM;aACjB,MAAM,EAAE,EAAE;aACV,UAAU,EAAE,MAAM;aAClB,UAAU,EAAE,kEAAkE;aAC9E,WAAW,EAAE,aAAa;CACjB,CAAC;AAEX,+EAA+E;AAC/E,MAAM,MAAM,2BAA2B,GAAG,OAAO,8BAA8B,CAAC;AAEhF;;;;GAIG;AACH,wBAAgB,mCAAmC,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAExF"}

package/dist/pptx/render/media-persistent-audio.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Persistent audio manager: keeps "play across slides" audio alive when the
+ * presentation advances and its source slide unmounts.
+ *
+ * Framework-agnostic (document-level, no framework types): every binding
+ * registers its cross-slide audio here instead of letting the element die
+ * with the slide DOM. Registered audio lives hidden on `document.body` until
+ * {@link stopAllPersistentAudio} tears it down on presentation exit.
+ */
+/** Whether an element's audio is already registered (and thus playing). */
+export declare function hasPersistentAudio(elementId: string): boolean;
+/**
+ * Register (and start) a cross-slide audio track. Idempotent per element id:
+ * re-registering while the track is alive is a no-op, so re-entering the
+ * slide that owns the audio does not restart it.
+ */
+export declare function registerPersistentAudio(elementId: string, dataUrl: string, mimetype: string | undefined, loop: boolean, volume: number, trimStartSec: number): void;
+/** Stop and remove all persistent audio; call when leaving presentation mode. */
+export declare function stopAllPersistentAudio(): void;
+/**
+ * Pause every currently-playing persistent track, remembering which ones
+ * were playing so {@link resumeAllPersistentAudio} restarts only those.
+ * Used by the presentation visibility handler when the tab is hidden.
+ */
+export declare function pauseAllPersistentAudio(): void;
+/** Resume the tracks {@link pauseAllPersistentAudio} paused. */
+export declare function resumeAllPersistentAudio(): void;
+//# sourceMappingURL=media-persistent-audio.d.ts.map

package/dist/pptx/render/media-persistent-audio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-persistent-audio.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/media-persistent-audio.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAaH,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACtC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,IAAI,EAAE,OAAO,EACb,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GAClB,IAAI,CAiCN;AAED,iFAAiF;AACjF,wBAAgB,sBAAsB,IAAI,IAAI,CAM7C;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAO9C;AAED,gEAAgE;AAChE,wBAAgB,wBAAwB,IAAI,IAAI,CAS/C"}

package/dist/pptx/render/media-playback.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Presentation-mode media autoplay.
+ *
+ * When present mode makes a slide the active, visible surface, any media on it
+ * should begin playing without a manual click (matching PowerPoint's slideshow
+ * behaviour). Browsers only honour a fresh `.play()` call, not an `autoplay`
+ * attribute added retroactively to an already-mounted node, so each binding
+ * calls this once the media element is mounted and its slide is live.
+ *
+ * `play()` can reject when the browser blocks autoplay-with-sound without a
+ * prior user gesture; the rejection is swallowed so it never surfaces as an
+ * unhandled promise (the element simply stays paused until the user interacts).
+ */
+export declare function startMediaAutoplay(el: HTMLMediaElement, options?: {
+    trimStartMs?: number;
+}): void;
+/** The `p:cMediaNode` playback settings a deck asks a media node to honour. */
+export interface MediaPlaybackSource {
+    /** `<a:videoFile>` / `p:cMediaNode` loop flag. */
+    loop?: boolean;
+    /** Authored volume, already normalised to 0..1 by the parse layer. */
+    volume?: number;
+    /** Authored playback rate multiplier. */
+    playbackSpeed?: number;
+}
+/** The DOM-facing playback attributes derived from {@link MediaPlaybackSource}. */
+export interface MediaPlaybackAttributes {
+    loop: boolean;
+    volume: number;
+    playbackRate: number;
+}
+/**
+ * Resolve a media element's authored playback settings into DOM attributes.
+ *
+ * WHY this is shared: the settings live on the parsed element, the mapping is
+ * two clamps and a default, and getting it wrong is invisible in a screenshot.
+ * Vanilla and Svelte both omitted `loop`, so `solution-explorer.pptx` slide 2 -
+ * a 2-second clip the deck marks `loop` and drives with a `playFrom(0.0)` on
+ * slide entry - played once, hit its end and froze on the last frame, which
+ * reads exactly like "the video never started". Volume was worse: only React
+ * applied it, so a deck that says `vol="0"` blared out of the other four.
+ */
+export declare function mediaPlaybackAttributes(source: MediaPlaybackSource): MediaPlaybackAttributes;
+/**
+ * Apply {@link mediaPlaybackAttributes} to a live node.
+ *
+ * `volume` and `playbackRate` are IDL properties with no attribute form, so the
+ * declarative bindings cannot set them from a template the way they set `loop`;
+ * every binding therefore needs this imperative step, not just the DOM ones.
+ */
+export declare function applyMediaPlaybackAttributes(el: HTMLMediaElement, source: MediaPlaybackSource): void;
+/** Which surface a slide is being painted on, as far as a media element cares. */
+export interface MediaSurface {
+    /** True only on the live slide-show stage. */
+    presenting: boolean;
+    /**
+     * True when the slide is painted as a STILL of itself: the presenter
+     * console's current-slide pane and next-slide preview, the slide-thumbnail
+     * rail, a slide-transition overlay, an export raster. Never the surface the
+     * show is actually running on.
+     */
+    preview: boolean;
+}
+/**
+ * Derive a {@link MediaSurface} from the two flags a binding's renderer carries.
+ *
+ * "Neither interactive nor presenting" is what a STILL of a slide looks like
+ * from inside an element renderer, and all four declarative bindings had spelt
+ * that out by hand - twice each, once per shared media rule. Deriving it once
+ * keeps a binding from quietly answering the two rules differently.
+ */
+export declare function mediaSurfaceOf(input: {
+    interactive: boolean;
+    presenting: boolean;
+}): MediaSurface;
+/** {@link MediaSurface} plus the one answer each binding owns for itself. */
+export interface MediaTransportSurface extends MediaSurface {
+    /**
+     * What the binding would do on its own AUTHORING canvas, which the five
+     * deliberately differ on: React paints a transport there, Angular suppresses
+     * it so a click selects the shape instead, Vue paints one but makes it inert.
+     * That difference is not this function's business; it only overrides the
+     * answer on the two surfaces where PowerPoint never paints a transport.
+     */
+    canvasTransport: boolean;
+}
+/**
+ * Whether a media element should carry the browser's native transport.
+ *
+ * PowerPoint paints no control bar during a show, and none on a still of a
+ * slide either. Four bindings got the still wrong: the presenter console's
+ * panes render through a NON-presenting stage, so `controls = !presenting` (and
+ * Angular's `controls = !interactive && !presenting`) turned Chrome's black
+ * scrubber ON inside the console, across the bottom of a slide the presenter
+ * cannot even play. React escaped only by accident - its preview renderer
+ * passes no media map, so the video falls back to a poster image and there is
+ * no `<video>` to put a transport on.
+ */
+export declare function mediaTransportVisible(surface: MediaTransportSurface): boolean;
+/** What a media element has to fall back on when it cannot mount a player. */
+export interface MediaFallbackInput {
+    /** The element resolved a poster / preview frame to paint. */
+    hasPoster: boolean;
+    /** The deck references media the package could not resolve (`mediaMissing`). */
+    missing?: boolean;
+}
+/**
+ * What the deck said a media element is. Mirrors core's `PptxMediaType`
+ * (including its `unknown`) without importing it, so this module stays free of
+ * a core dependency; `unknown` gets the generic icon and label.
+ */
+export type MediaKind = 'video' | 'audio' | 'unknown';
+/** The centred affordance drawn over a poster frame. */
+export type MediaFallbackBadge = 'none' | 'play' | 'missing';
+/** The box drawn when there is not even a poster frame to paint. */
+export type MediaFallbackPlaceholder = 'none' | 'typed' | 'missing';
+/** The layers a media element paints when no playable source is available. */
+export interface MediaFallbackVisual {
+    /** Paint the poster frame. Only ever true when the element has one. */
+    poster: boolean;
+    /** Dim the poster, signalling that the media behind it is unavailable. */
+    dimPoster: boolean;
+    /** Which affordance to centre over the poster, if any. */
+    badge: MediaFallbackBadge;
+    /** Which box to paint instead of a poster, if any. */
+    placeholder: MediaFallbackPlaceholder;
+}
+/**
+ * What a media element paints when it has no playable source.
+ *
+ * WHY this is shared (issue #147): a slide-transition overlay is a STILL of the
+ * outgoing slide, and React's overlay renders it without the media map, so a
+ * full-bleed background video fell back to its poster frame AND to the centred
+ * play badge that goes with it. The badge is authoring chrome, not slide
+ * content, so `solution-explorer.pptx` played a mystery play triangle across
+ * the middle of every morph out of slide 2 - which is exactly what the reporter
+ * caught at 11s. The same class of artefact was one map away in the other four:
+ * their typed "Media" placeholder box is chrome too, and it paints on any still
+ * whose media cannot resolve.
+ *
+ * The rule: a still of a slide - and the show itself - paints slide CONTENT and
+ * nothing else. Only the authoring canvas adds the affordance that says "this
+ * picture is a video you cannot play here".
+ *
+ * `badge` and `placeholder` are unions rather than booleans on purpose. As
+ * booleans, four bindings read "paint a badge" and drew a PLAY triangle over
+ * media the package had failed to find - the opposite of what React said in the
+ * same spot. A union cannot be half-read.
+ */
+export declare function mediaFallbackVisual(surface: MediaSurface, input: MediaFallbackInput): MediaFallbackVisual;
+/**
+ * The icons the fallback draws, as SVG path `d` strings in a 24x24 `viewBox`,
+ * stroked with `currentColor` over `fill: none`.
+ *
+ * Paths rather than each binding's own `<circle>` / `<polygon>` / `<line>` mix:
+ * one array renders identically through JSX, a Vue/Svelte `for`, an Angular
+ * `@for` and a DOM loop, so the five icons cannot drift apart.
+ */
+export declare const MEDIA_FALLBACK_ICONS: Readonly<Record<'play' | 'missing' | 'audio', readonly string[]>>;
+/**
+ * The icon for a resolved {@link MediaFallbackVisual}, or `[]` when the surface
+ * asks for none. An untyped placeholder gets no icon, as React has always done:
+ * the deck never said whether it is a clip or a track.
+ */
+export declare function mediaFallbackIcon(visual: MediaFallbackVisual, mediaType?: MediaKind): readonly string[];
+/**
+ * The i18n key labelling a resolved {@link MediaFallbackVisual}, or `undefined`
+ * when it carries no label (the play badge is a bare triangle).
+ *
+ * Shared because the five disagreed: React hard-coded the English words "Video"
+ * and "Audio" - untranslated, in a package that ships four locales - while the
+ * other four labelled every unplayable element the same flat "Media", whatever
+ * the deck said it was.
+ */
+export declare function mediaFallbackLabelKey(visual: MediaFallbackVisual, mediaType?: MediaKind): string | undefined;
+export declare const MEDIA_CHROME_ATTRIBUTE = "data-pptx-media-chrome";
+//# sourceMappingURL=media-playback.d.ts.map