ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/notes/notes-print.d.ts

@@ -0,0 +1,23 @@
+/**
+ * notes-print.ts: framework-agnostic "Print speaker notes" document builder.
+ *
+ * Ported from React's `NotesPrintDialog.handlePrint`. Builds the full HTML
+ * document string (one page per slide: header, placeholder thumbnail, bulleted
+ * /numbered/indented notes) that each binding writes into a hidden print
+ * iframe or a `window.open` document before calling `print()`.
+ */
+import type { PptxSlide, PptxTextStyleLevels } from 'ooxml-core/pptx';
+/**
+ * Build the printable notes document for every slide.
+ *
+ * @param slides    the presentation slides, in order.
+ * @param slideLabel maps a 1-based slide number to its display label, so the
+ *                   caller can localise "Slide N" / "Folie N" / etc.
+ * @param notesStyle the deck's notes master `<p:notesStyle>` (`PptxData.
+ *                   notesMaster.notesStyle`), when available. Its level-0
+ *                   font size/family/colour become the printed notes-text
+ *                   defaults instead of a hardcoded 12px look; absent decks
+ *                   keep the previous fallback exactly.
+ */
+export declare function buildNotesPrintHtml(slides: PptxSlide[], slideLabel: (slideNumber: number) => string, notesStyle?: PptxTextStyleLevels): string;
+//# sourceMappingURL=notes-print.d.ts.map

package/dist/pptx/render/notes/notes-print.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes-print.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/notes/notes-print.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAmBtE;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,SAAS,EAAE,EACnB,UAAU,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,EAC3C,UAAU,CAAC,EAAE,mBAAmB,GAC9B,MAAM,CA0DR"}

package/dist/pptx/render/notes/notes-style-cascade.d.ts

@@ -0,0 +1,89 @@
+/**
+ * notes-style-cascade.ts: pure resolver that turns a notes master's
+ * `<p:notesStyle>` (parsed by core into {@link PptxTextStyleLevels}) into a
+ * framework-neutral descriptor the notes-rendering surfaces can apply.
+ *
+ * `<p:notesStyle>` is a `CT_TextListStyle` (ECMA-376 SS19.3.1.34): the same
+ * `a:defPPr` + `a:lvl1pPr`..`a:lvl9pPr` shape `p:titleStyle` / `p:bodyStyle` /
+ * `p:otherStyle` use on a slide master, keyed 0-8 with the paragraph default
+ * at level -1. Every binding's notes surfaces (the docked speaker-notes
+ * editor, "Print Notes Pages", the Notes Master schematic canvas) share this
+ * one cascade instead of re-deriving it, so an authored deck's notes-text
+ * defaults reach all five without duplicating the lookup.
+ *
+ * `PlaceholderTextLevelStyle.fontSize` is stored in CSS pixels (the
+ * convention every other consumer of that type uses); {@link TextStyle}
+ * expects points, so {@link resolveNotesLevelStyle} converts once here rather
+ * than leaving every call site to remember the unit mismatch.
+ */
+import type { PptxTextStyleLevels, TextSegment } from 'ooxml-core/pptx';
+/**
+ * Fallback notes-text font size (points) used when the deck has no authored
+ * `<p:notesStyle>` (or the resolved level omits a font size). Shared by the
+ * print builder ({@link "./notes-print"}) and the Notes Master schematic
+ * preview ({@link resolveNotesSchematicBodyFontSizePx}) so both surfaces fall
+ * back to the same default instead of drifting independently.
+ */
+export declare const DEFAULT_NOTES_FONT_SIZE_PT = 9;
+/**
+ * The subset of a notes-style level's authored defaults the notes-rendering
+ * surfaces understand. Fields are omitted (not `undefined`-valued) when the
+ * deck's `<p:notesStyle>` does not define them at the resolved level, so a
+ * caller can spread this directly without clobbering an explicit value with
+ * `undefined`.
+ */
+export interface NotesLevelStyleDescriptor {
+    fontFamily?: string;
+    /** In points, matching {@link TextStyle.fontSize}. */
+    fontSize?: number;
+    bold?: boolean;
+    italic?: boolean;
+    color?: string;
+    /** Paragraph left margin in CSS pixels, matching {@link TextStyle.paragraphMarginLeft}. */
+    marginLeft?: number;
+}
+/**
+ * Resolve the notes-text defaults for one outline level (0-8), falling back
+ * to the list's own paragraph default (`a:defPPr`, stored at level -1) for
+ * any field the level itself does not set.
+ *
+ * Returns `{}` when `notesStyle` is absent (no authored `<p:notesStyle>`, the
+ * common case), so callers can apply the result unconditionally without a
+ * presence check of their own.
+ */
+export declare function resolveNotesLevelStyle(notesStyle: PptxTextStyleLevels | undefined, level?: number): NotesLevelStyleDescriptor;
+/**
+ * Apply the deck's notes-style level-0 defaults to every non-break segment
+ * that does not already carry an explicit value for a given field.
+ *
+ * The notes editor's simplified paragraph model does not currently retain
+ * each paragraph's authored `@lvl` (only a UI indent level unrelated to the
+ * OOXML outline level), so every paragraph in the notes body resolves
+ * against level 0 - the level PowerPoint's own Notes Page uses for
+ * unindented speaker notes, and the level almost every authored deck sets.
+ * `resolveNotesLevelStyle` still resolves any of the nine levels; wiring a
+ * genuine per-paragraph level through the segment model is future work.
+ */
+export declare function applyNotesLevelDefaults(segments: TextSegment[], descriptor: NotesLevelStyleDescriptor): TextSegment[];
+/**
+ * Resolve the font size (CSS px) for the Notes Master schematic preview's
+ * body-placeholder label, honouring the deck's authored `<p:notesStyle>`
+ * level-0 default instead of a fixed clamp untethered from it.
+ *
+ * Every binding's Notes Master schematic (`NotesMasterCanvas` / equivalent)
+ * draws the notes page shrunk to fit a sidebar preview. `scale` is that
+ * preview's ratio to the page's real CSS-px dimensions (e.g. the same `scale`
+ * each canvas already computes from `canvasSize` vs. the authored page size).
+ * This resolves the *real* body font size in px at 1:1 first
+ * (`resolveNotesLevelStyle` -> pt -> px), THEN multiplies by `scale` - the
+ * schematic zoom is applied on top of the resolved style, never as a
+ * replacement for it, so a deck authoring a large or small notes default
+ * visibly differs in the preview.
+ *
+ * `minPx` is a legibility floor only (default 6): at very small preview
+ * scales even a normally-sized authored font would round to an illegible
+ * sub-pixel value, so the floor guarantees a readable label. It never
+ * overrides a resolved size that is already larger.
+ */
+export declare function resolveNotesSchematicBodyFontSizePx(notesStyle: PptxTextStyleLevels | undefined, scale: number, minPx?: number): number;
+//# sourceMappingURL=notes-style-cascade.d.ts.map

package/dist/pptx/render/notes/notes-style-cascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes-style-cascade.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/notes/notes-style-cascade.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAa,MAAM,iBAAiB,CAAC;AAKnF;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,yBAAyB;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2FAA2F;IAC3F,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAUD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,mBAAmB,GAAG,SAAS,EAC3C,KAAK,SAAI,GACP,yBAAyB,CAsB3B;AAgCD;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,WAAW,EAAE,EACvB,UAAU,EAAE,yBAAyB,GACnC,WAAW,EAAE,CASf;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mCAAmC,CAClD,UAAU,EAAE,mBAAmB,GAAG,SAAS,EAC3C,KAAK,EAAE,MAAM,EACb,KAAK,SAAI,GACP,MAAM,CAKR"}

package/dist/pptx/render/notes/notes-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * notes-utils.ts: framework-agnostic pure helpers for the rich speaker-notes
+ * editor, shared by the React, Vue, and Angular bindings.
+ *
+ * Ported from React's `viewer/components/notes/notes-utils.ts`. Pure TypeScript
+ * (no DOM, no framework imports beyond the core `TextSegment` model), so each
+ * binding consumes one copy: paragraph/segment conversions, plain-text seeding,
+ * normalisation, and the cursor->paragraph index lookup used by list/indent
+ * toolbar actions.
+ *
+ * NOTE: `escapeHtml` is exported for sibling notes modules but intentionally not
+ * re-exported through the notes barrel: the shared `export/print-document`
+ * module already exports a symbol of the same name.
+ */
+import type { TextSegment } from 'ooxml-core/pptx';
+/** Paragraph metadata derived from segments. */
+export interface NotesParagraph {
+    segments: TextSegment[];
+    bulletType: 'none' | 'bullet' | 'numbered';
+    indentLevel: number;
+}
+/** Which editor surface is active. */
+export type NotesEditorMode = 'rich' | 'plain';
+/** Inline character-formatting commands handled via `document.execCommand`. */
+export type NotesInlineCommand = 'bold' | 'italic' | 'underline' | 'strikeThrough';
+export declare const DEBOUNCE_MS = 600;
+export declare const EXPANDED_MAX_HEIGHT = 200;
+export declare const PX_TO_PT = 0.75;
+export declare const MAX_INDENT_LEVEL = 4;
+export declare const INDENT_PX = 24;
+export declare function escapeHtml(value: string): string;
+export declare function createPlainNotesSegments(text: string): TextSegment[];
+export declare function segmentsToPlainText(segments: TextSegment[]): string;
+export declare function normalizeSegments(segments: TextSegment[]): TextSegment[];
+export declare function parsePt(value: string | undefined): number | undefined;
+export declare function segmentsToParagraphs(segments: TextSegment[]): NotesParagraph[];
+export declare function paragraphsToSegments(paragraphs: NotesParagraph[]): TextSegment[];
+export declare function getCurrentParagraphIndex(editorEl: HTMLElement, segments: TextSegment[]): number;
+//# sourceMappingURL=notes-utils.d.ts.map

package/dist/pptx/render/notes/notes-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes-utils.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/notes/notes-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD,gDAAgD;AAChD,MAAM,WAAW,cAAc;IAC9B,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,sCAAsC;AACtC,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,OAAO,CAAC;AAE/C,+EAA+E;AAC/E,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,eAAe,CAAC;AAMnF,eAAO,MAAM,WAAW,MAAM,CAAC;AAC/B,eAAO,MAAM,mBAAmB,MAAM,CAAC;AACvC,eAAO,MAAM,QAAQ,OAAO,CAAC;AAC7B,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAClC,eAAO,MAAM,SAAS,KAAK,CAAC;AAM5B,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAOhD;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,EAAE,CAapE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAMxE;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAYrE;AAgCD,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,cAAc,EAAE,CAwB9E;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,cAAc,EAAE,GAAG,WAAW,EAAE,CA0ChF;AAMD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,CAkC/F"}

package/dist/pptx/render/notes-toolbar-state.d.ts

@@ -0,0 +1,42 @@
+import type { NotesInlineCommand, NotesParagraphCommand } from './notes/index.js';
+/**
+ * Shared model for the speaker-notes formatting toolbar (`pptx-ui-notes-toolbar`).
+ *
+ * The toolbar owns the buttons, their order, icons, labels, enabled state and
+ * the hyperlink popover. Hosts own the contenteditable editor, selection-based
+ * edits, history, printing and persistence, and route typed intents to them.
+ */
+export type NotesToolbarTranslate = (key: string, params?: Record<string, string | number>) => string;
+/** Public button ids, in canonical order. */
+export type NotesToolbarControlId = 'bold' | 'italic' | 'underline' | 'strike' | 'bullet' | 'numbered' | 'indent' | 'outdent' | 'link' | 'print' | 'toggleRich';
+export interface NotesToolbarViewState {
+    /** True while the rich (contenteditable) surface is active. Drives the mode button label. */
+    rich: boolean;
+    /** Enables the formatting buttons. False in the plain editor, where they cannot act. */
+    canFormat: boolean;
+    /** Shows the Print button. */
+    showPrint: boolean;
+    /** Disables every button, for example while no slide is selected. */
+    disabled?: boolean;
+    /** Host translator; keys are the canonical `pptx.notes.*` set. Omitted: keys are shown. */
+    translate?: NotesToolbarTranslate;
+}
+export type NotesToolbarIntent = {
+    kind: 'inline';
+    command: NotesInlineCommand;
+} | {
+    kind: 'paragraph';
+    command: NotesParagraphCommand;
+}
+/** Emitted when the link popover is submitted; `url` is already normalised. */
+ | {
+    kind: 'link';
+    url: string;
+    text: string;
+} | {
+    kind: 'print';
+} | {
+    kind: 'toggle-rich';
+};
+export declare const NOTES_TOOLBAR_DEFAULT_STATE: NotesToolbarViewState;
+//# sourceMappingURL=notes-toolbar-state.d.ts.map

package/dist/pptx/render/notes-toolbar-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notes-toolbar-state.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/notes-toolbar-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEzE;;;;;;GAMG;AAEH,MAAM,MAAM,qBAAqB,GAAG,CACnC,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KACpC,MAAM,CAAC;AAEZ,6CAA6C;AAC7C,MAAM,MAAM,qBAAqB,GAC9B,MAAM,GACN,QAAQ,GACR,WAAW,GACX,QAAQ,GACR,QAAQ,GACR,UAAU,GACV,QAAQ,GACR,SAAS,GACT,MAAM,GACN,OAAO,GACP,YAAY,CAAC;AAEhB,MAAM,WAAW,qBAAqB;IACrC,6FAA6F;IAC7F,IAAI,EAAE,OAAO,CAAC;IACd,wFAAwF;IACxF,SAAS,EAAE,OAAO,CAAC;IACnB,8BAA8B;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,qEAAqE;IACrE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2FAA2F;IAC3F,SAAS,CAAC,EAAE,qBAAqB,CAAC;CAClC;AAED,MAAM,MAAM,kBAAkB,GAC3B;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,kBAAkB,CAAA;CAAE,GAC/C;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAE;AACvD,+EAA+E;GAC7E;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,CAAC;AAE3B,eAAO,MAAM,2BAA2B,EAAE,qBAIzC,CAAC"}

package/dist/pptx/render/ole-actions.d.ts

@@ -0,0 +1,43 @@
+/**
+ * ole-actions.ts - framework-agnostic helpers for the OLE download/open UI.
+ *
+ * Shared by the binding OLE renderers to format the recovered embedded payload
+ * size and decide whether its MIME type can be opened directly in a browser tab
+ * (vs download-only). Pure functions, no framework or DOM dependencies.
+ *
+ * @module shared/render/ole-actions
+ */
+import type { MediaSurface } from './media-playback.js';
+/**
+ * Human-readable binary file size (1024-based), e.g. `1 byte`, `0 bytes`,
+ * `12 MB`. Returns `undefined` for missing, negative, or non-finite input so
+ * callers can simply omit the size when it is unknown.
+ */
+export declare function formatBytes(bytes?: number): string | undefined;
+/**
+ * Whether a payload of the given MIME type can be opened directly in a browser
+ * tab (PDF, images, plain text, JSON, XML, XHTML). Everything else is
+ * download-only. Matching is case-insensitive and ignores any trailing
+ * `; charset=...` (or other `;`-delimited) parameter.
+ */
+export declare function isBrowserOpenableMime(mime?: string): boolean;
+/**
+ * Whether an OLE element's interactive Download / (browser-openable) Open
+ * action bar should render at all.
+ *
+ * Mirrors {@link import('./media-playback').mediaTransportVisible}'s two
+ * non-interactive surfaces: a still of a slide (thumbnail rail, presenter
+ * console panes, a slide-transition overlay, an export raster) and the live
+ * presentation stage never offer element-level browser chrome, only the
+ * editable canvas does. Unlike media transport there is no per-binding
+ * "what the canvas already does" divergence to preserve: every binding's own
+ * authoring canvas already shows these actions, so the rule reduces to
+ * "the editable canvas, and nowhere else".
+ *
+ * This matters beyond correctness: a slide thumbnail is rendered INSIDE a
+ * `<button aria-label="Go to slide N">` in every binding, so an OLE preview's
+ * own Download/Open `<button>` rendered there is invalid, un-clickable
+ * (nested-interactive-control) markup, not merely an unwanted affordance.
+ */
+export declare function oleActionsVisible(surface: MediaSurface): boolean;
+//# sourceMappingURL=ole-actions.d.ts.map

package/dist/pptx/render/ole-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ole-actions.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ole-actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoB9D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAiB5D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAEhE"}

package/dist/pptx/render/ole-edit-model.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Pure decision module for the "Edit content" OLE dialog: which editor tab
+ * a binding should show for a given `OlePptxElement`, and the dialog's
+ * title/label furniture. Every binding maps this descriptor onto its own
+ * dialog component; none of them re-derive the kind themselves.
+ *
+ * This is a LIGHTWEIGHT, synchronous classification from the element's
+ * already-parsed `oleObjectType` / `oleFileExtension` fields, used only to
+ * decide which UI affordance to show (a grid, a paragraph list, a nested
+ * viewer, or just Replace File). It is deliberately not the same check as
+ * core's `detectOlePayloadEditorKind` (`ooxml-core/pptx`), which sniffs the
+ * actual payload bytes and is the source of truth the edit functions
+ * (`ole-edit-api.ts` in core) validate against before writing anything. A
+ * mismatch between this guess and core's byte-level detection just means the
+ * dialog opened the "wrong" tab for a mislabelled file; core's own detection
+ * still decides what can actually be written, so no edit is ever silently
+ * corrupted by a wrong guess here.
+ *
+ * @module render/ole-edit-model
+ */
+import type { OlePptxElement } from 'ooxml-core/pptx';
+/** Which editor UI a binding's "Edit content" dialog should present. */
+export type OleEditorKind = 'sheet' | 'document' | 'deck' | 'file';
+/**
+ * Guess which editor tab applies to an OLE element, from its already-parsed
+ * type/extension fields (no byte-sniffing; see module doc).
+ */
+export declare function resolveOleEditorKind(element: Pick<OlePptxElement, 'oleObjectType' | 'oleFileExtension'>): OleEditorKind;
+/** Descriptor for one tab of the "Edit content" dialog. */
+export interface OleEditDialogTab {
+    kind: OleEditorKind;
+    /** i18n key for the tab label. */
+    labelKey: string;
+}
+/** Full descriptor for the "Edit content" dialog: which tabs to show and in what order. */
+export interface OleEditDialogDescriptor {
+    /** i18n key for the dialog title. */
+    titleKey: string;
+    /** The content-editing tab for this element's kind, absent for a plain file (Replace File only). */
+    contentTab?: OleEditDialogTab;
+    /** Whether to show the "Replace file" action (always true: every kind supports it). */
+    showReplaceFile: true;
+    /** Whether to show the Object Name field (always true, mirrors the existing inspector field). */
+    showObjectName: true;
+}
+/** Build the full dialog descriptor for an OLE element's "Edit content" action. */
+export declare function buildOleEditDialogDescriptor(element: Pick<OlePptxElement, 'oleObjectType' | 'oleFileExtension'>): OleEditDialogDescriptor;
+/**
+ * Extract the `Partial<OlePptxElement>` patch to commit after any of core's
+ * `ole-edit-api.ts` functions (`applyOleSheetCellEdit`,
+ * `applyOleDocumentParagraphEdit`, `applyOleNestedDeckBytes`,
+ * `replaceOleFile`, `setOleObjectName`) returns an updated element.
+ *
+ * Every binding's OLE editor dialog calls this the same way (commit through
+ * the same `onUpdateElement`-style patch API every other inspector field
+ * uses), so the field list that content-editing can touch lives once here
+ * instead of being repeated per binding.
+ */
+export declare function buildOleContentUpdatePatch(updated: OlePptxElement): Partial<OlePptxElement>;
+//# sourceMappingURL=ole-edit-model.d.ts.map

package/dist/pptx/render/ole-edit-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ole-edit-model.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ole-edit-model.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAErE,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,UAAU,GAAG,MAAM,GAAG,MAAM,CAAC;AAQnE;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,kBAAkB,CAAC,GACjE,aAAa,CAmBf;AAED,2DAA2D;AAC3D,MAAM,WAAW,gBAAgB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,2FAA2F;AAC3F,MAAM,WAAW,uBAAuB;IACvC,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,oGAAoG;IACpG,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,uFAAuF;IACvF,eAAe,EAAE,IAAI,CAAC;IACtB,iGAAiG;IACjG,cAAc,EAAE,IAAI,CAAC;CACrB;AASD,mFAAmF;AACnF,wBAAgB,4BAA4B,CAC3C,OAAO,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,kBAAkB,CAAC,GACjE,uBAAuB,CAQzB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAW3F"}

package/dist/pptx/render/ole-icon-primitives.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Data-driven placeholder icon primitives for `ole` (embedded object)
+ * elements: the Excel grid, Word document, PDF, Visio diagram, MathType
+ * `f(x)`, and generic linked-objects glyphs.
+ *
+ * Extracted from the identical `rect`/`line`/`text` builders + `ICONS` table
+ * that Svelte's `render/ole-view.ts` and Vanilla's
+ * `render/elements/ole-icons.ts` both hand-rolled byte-for-byte (down to the
+ * shape coordinates). Every binding's OLE renderer maps `OleIconShape[]` onto
+ * its own `<rect>`/`<line>`/`<text>` (or `createSvgEl`) primitives; only the
+ * DOM/JSX emission stays per binding.
+ */
+import type { ResolvedOleType } from './ole-renderer-helpers.js';
+/** One primitive of a data-driven placeholder icon. */
+export interface OleIconShape {
+    tag: 'rect' | 'line' | 'text';
+    attrs: Record<string, string | number>;
+    /** Text content, only present when `tag === 'text'`. */
+    text?: string;
+}
+/** Icon primitives for a resolved OLE type. */
+export declare function getOleIconShapes(type: ResolvedOleType): OleIconShape[];
+//# sourceMappingURL=ole-icon-primitives.d.ts.map

package/dist/pptx/render/ole-icon-primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ole-icon-primitives.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ole-icon-primitives.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC5B,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACvC,wDAAwD;IACxD,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAsFD,+CAA+C;AAC/C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,YAAY,EAAE,CAEtE"}

package/dist/pptx/render/ole-renderer-helpers.d.ts

@@ -0,0 +1,78 @@
+/**
+ * ole-renderer-helpers.ts - framework-agnostic OLE type-resolution helpers.
+ *
+ * Resolves an embedded `OlePptxElement` to a narrowed application type and
+ * derives the per-type brand colour, human-readable label, accessible label,
+ * short badge text, display name, and placeholder box style. Shared by every
+ * binding's OLE renderer (React/Vue/Angular) so the branding stays identical.
+ *
+ * Pure: no framework or DOM dependencies. The JSX/template that paints icons and
+ * badges stays in each binding; only the type -> colour/label mapping lives here.
+ *
+ * @module shared/render/ole-renderer-helpers
+ */
+import type { OlePptxElement } from 'ooxml-core/pptx';
+/**
+ * Resolved OLE application type, narrowed from the raw `OleObjectType` union.
+ *
+ * `package` and `unknown` from the core type both collapse to `'unknown'` here
+ * so that every branch is guaranteed to have a colour and label.
+ */
+export type ResolvedOleType = 'excel' | 'word' | 'powerpoint' | 'pdf' | 'visio' | 'mathtype' | 'unknown';
+/**
+ * Resolve the OLE application type from `oleObjectType`, falling back to a
+ * case-insensitive substring match on `oleProgId`.
+ */
+export declare function resolveOleType(el: OlePptxElement): ResolvedOleType;
+/** Return the brand hex colour for a resolved OLE type. */
+export declare function getOleTypeColor(type: ResolvedOleType): string;
+/** Return the human-readable label for a resolved OLE type. */
+export declare function getOleTypeLabel(type: ResolvedOleType): string;
+/**
+ * Build the accessible label for an OLE element.
+ *
+ * - With a resolvable name (see {@link resolveOleBestName}): `"<TypeLabel>: <name>"`
+ *   (e.g. `"Excel Spreadsheet: budget.xlsx"`, or `"Excel Spreadsheet: Q3 Budget"`
+ *   once the object has been given a custom name via the inspector).
+ * - Otherwise: just the type label (e.g. `"Embedded Object"`).
+ */
+export declare function getOleAriaLabel(el: OlePptxElement): string;
+/**
+ * Short uppercase badge text shown over the preview image.
+ *
+ * Returns `'OLE'` for the unknown type, otherwise the type in upper-case
+ * (e.g. `'EXCEL'`, `'PDF'`).
+ */
+export declare function getOleBadgeLabel(type: ResolvedOleType): string;
+/**
+ * The primary display name shown in the placeholder box, tooltip, and other
+ * captions.
+ *
+ * Prefers the best resolvable name (see {@link resolveOleBestName}: the
+ * author's own OLE object name first, then the recovered embedded file name,
+ * then the authored file name); falls back to the resolved type label when
+ * none are known.
+ */
+export declare function getOleDisplayName(el: OlePptxElement): string;
+/**
+ * Build the patch to apply when the user edits an OLE object's Name field in
+ * the inspector (the browser-realistic analogue of PowerPoint's own OLE
+ * object rename: `p:oleObj/@name`, which already parses, saves, and syncs via
+ * collaboration; only an editing surface for it was missing).
+ *
+ * Blank/whitespace-only input clears the name (`undefined`), so the display
+ * falls back to the embedded/authored file name or type label, matching how
+ * clearing PowerPoint's own object-name field behaves.
+ */
+export declare function buildOleObjectNamePatch(rawInput: string): {
+    oleName: string | undefined;
+};
+/**
+ * Compute the border + background style for the type-specific placeholder box.
+ *
+ * Uses the brand colour at 20% opacity for the border and 5% for the fill
+ * (the `${color}33` / `${color}0d` hex-alpha trick). Returns a neutral CSS
+ * property record; each binding casts it to its framework's style type.
+ */
+export declare function getPlaceholderStyle(type: ResolvedOleType): Record<string, string | number>;
+//# sourceMappingURL=ole-renderer-helpers.d.ts.map

package/dist/pptx/render/ole-renderer-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ole-renderer-helpers.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/ole-renderer-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GACxB,OAAO,GACP,MAAM,GACN,YAAY,GACZ,KAAK,GACL,OAAO,GACP,UAAU,GACV,SAAS,CAAC;AAwBb;;;GAGG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,cAAc,GAAG,eAAe,CA0BlE;AAED,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAE7D;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAE7D;AA0BD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,CAI1D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAE9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAGzF;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAO1F"}

package/dist/pptx/render/omml-color.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: canonical equation logic lives in ooxml-core/math. */
+export { getOmmlMathColor, getOmmlMathFontSize } from 'ooxml-core/math';
+//# sourceMappingURL=omml-color.d.ts.map

package/dist/pptx/render/omml-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-color.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/omml-color.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/pptx/render/omml-to-latex-helpers.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: canonical equation logic lives in ooxml-core/math. */
+export { type XmlRecord, ensureArr, childNode, attrVal, hasAttr, isOn, readRunText, contentKeys, soleChild, escapeChar, escapeMathText, escapeTextArgument, isSingleAtom, collectText, } from 'ooxml-core/math';
+//# sourceMappingURL=omml-to-latex-helpers.d.ts.map

package/dist/pptx/render/omml-to-latex-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex-helpers.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/omml-to-latex-helpers.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,EACN,KAAK,SAAS,EACd,SAAS,EACT,SAAS,EACT,OAAO,EACP,OAAO,EACP,IAAI,EACJ,WAAW,EACX,WAAW,EACX,SAAS,EACT,UAAU,EACV,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,WAAW,GACX,MAAM,iBAAiB,CAAC"}

package/dist/pptx/render/omml-to-latex-layout.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: canonical equation logic lives in ooxml-core/math. */
+export { type LatexEmitter, naryToLatex, rowsToLatex, matrixToLatex, eqArrToLatex, delimiterToLatex, } from 'ooxml-core/math';
+//# sourceMappingURL=omml-to-latex-layout.d.ts.map

package/dist/pptx/render/omml-to-latex-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex-layout.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/omml-to-latex-layout.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,EACN,KAAK,YAAY,EACjB,WAAW,EACX,WAAW,EACX,aAAa,EACb,YAAY,EACZ,gBAAgB,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/pptx/render/omml-to-latex.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: canonical equation logic lives in ooxml-core/math. */
+export { convertOmmlToLatex } from 'ooxml-core/math';
+//# sourceMappingURL=omml-to-latex.d.ts.map

package/dist/pptx/render/omml-to-latex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-latex.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/omml-to-latex.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/pptx/render/omml-to-mathml.d.ts

@@ -0,0 +1,3 @@
+/** Compatibility entry: canonical equation logic lives in ooxml-core/math. */
+export { type OmmlNode, convertOmmlToMathMl, ommlToMathml } from 'ooxml-core/math';
+//# sourceMappingURL=omml-to-mathml.d.ts.map

package/dist/pptx/render/omml-to-mathml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omml-to-mathml.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/omml-to-mathml.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,OAAO,EAAE,KAAK,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/pptx/render/online-video.d.ts

@@ -0,0 +1,53 @@
+/**
+ * PowerPoint's "Online Video" insert links a `media` element (`isLinked`,
+ * G17) to a web page rather than an audio/video file: `mediaPath` ends up
+ * the verbatim URL the author pasted (a YouTube/Vimeo watch page, a share
+ * link, or the provider's own `/embed/` URL). A `<video src>` cannot play
+ * any of these: the response is an HTML document, not a media stream, so
+ * playback fails silently and the slide shows a blank/broken player.
+ *
+ * `resolveOnlineVideoEmbed` recognises the common web-video hosts and
+ * normalises whatever URL form the deck carries into the provider's
+ * iframe-embeddable URL, so a binding can render an `<iframe>` instead of a
+ * `<video>` for exactly this case and nothing else (a normal linked MP4
+ * still plays through `<video>`).
+ *
+ * @module render/online-video
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** What an online-video URL resolves to: the iframe-embeddable form. */
+export interface OnlineVideoEmbed {
+    embedUrl: string;
+}
+/**
+ * The `<iframe allow="...">` Permissions Policy value every binding's
+ * online-video embed uses, so a provider capability (fullscreen, PiP) reaches
+ * all five at once instead of drifting per hand-ported copy.
+ */
+export declare const ONLINE_VIDEO_IFRAME_ALLOW = "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; fullscreen";
+/**
+ * The `<iframe sandbox="...">` value every binding's online-video embed uses.
+ * YouTube/Vimeo's own player needs `allow-scripts` (it is a full web app) and
+ * `allow-same-origin` (their own origin, never the host page's, so this does
+ * not weaken the host); `allow-popups` covers the player's "Share"/"Watch on
+ * YouTube" links, and `allow-presentation` its cast button. Deliberately
+ * narrower than "no sandbox at all": still blocks top-level navigation and
+ * form submission from the embedded page.
+ */
+export declare const ONLINE_VIDEO_IFRAME_SANDBOX = "allow-scripts allow-same-origin allow-popups allow-presentation";
+/**
+ * Resolve a linked media URL to an iframe-embeddable web-video URL, or
+ * `undefined` when it is not a recognised web-video host (a plain linked
+ * media file, which plays through `<video>`/`<audio>` as usual).
+ *
+ * Only meaningful for LINKED media: an embedded (`r:embed`) video is always
+ * a real media file inside the package, never a web page.
+ */
+export declare function resolveOnlineVideoEmbed(mediaPath: string | undefined, isLinked: boolean | undefined): OnlineVideoEmbed | undefined;
+/**
+ * Convenience wrapper over {@link resolveOnlineVideoEmbed} for a full
+ * `PptxElement`: `undefined` for anything but a linked `media`/`video`
+ * element whose URL resolves to a recognised web-video host.
+ */
+export declare function getOnlineVideoEmbed(element: PptxElement): OnlineVideoEmbed | undefined;
+//# sourceMappingURL=online-video.d.ts.map

package/dist/pptx/render/online-video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"online-video.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/online-video.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAChC,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,yGACiE,CAAC;AAExG;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,oEAC0B,CAAC;AAwCnE;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,QAAQ,EAAE,OAAO,GAAG,SAAS,GAC3B,gBAAgB,GAAG,SAAS,CAuB9B;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,gBAAgB,GAAG,SAAS,CAKtF"}

package/dist/pptx/render/open-file-picker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * open-file-picker: framework-agnostic helper that opens the native file
+ * picker and resolves the chosen file. Every binding's File > Open action wires
+ * its built-in picker through here so the accepted extensions and the
+ * pick-to-ArrayBuffer flow stay identical across all five bindings.
+ *
+ * The accepted-extension list itself lives in `./presentation-file-kinds`,
+ * alongside the matching drop-target predicate, so a picker and a drop zone
+ * cannot disagree about what is loadable.
+ */
+export interface OpenFilePickerOptions {
+    /** Comma-separated `accept` list. Defaults to {@link PPTX_OPEN_ACCEPT}. */
+    accept?: string;
+}
+/**
+ * Opens a transient `<input type="file">` and resolves with the selected
+ * `File`, or `null` when the user cancels (or when there is no DOM, e.g. SSR).
+ */
+export declare function openFilePicker(options?: OpenFilePickerOptions): Promise<File | null>;
+/**
+ * Opens the picker and reads the chosen file into an `ArrayBuffer` ready to hand
+ * to the loader. Resolves `null` when the user cancels.
+ *
+ * The picked deck is also remembered for this browser tab (see
+ * `./session-restore`). Every binding's File > Open swaps the deck INSIDE the
+ * viewer without telling the host, so without this a host that restores on load
+ * would reopen the deck it handed in rather than the one the user picked.
+ */
+export declare function openPptxFile(options?: OpenFilePickerOptions): Promise<{
+    file: File;
+    buffer: ArrayBuffer;
+} | null>;
+//# sourceMappingURL=open-file-picker.d.ts.map

package/dist/pptx/render/open-file-picker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-file-picker.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/open-file-picker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,MAAM,WAAW,qBAAqB;IACrC,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAuCxF;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CACjC,OAAO,GAAE,qBAA0B,GACjC,OAAO,CAAC;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAAG,IAAI,CAAC,CAQrD"}

package/dist/pptx/render/options/autocorrect.d.ts

@@ -0,0 +1,4 @@
+import type { ViewerProofingOptions } from './viewer-options.js';
+/** Apply every enabled AutoCorrect rule to a committed run of text. */
+export declare function applyAutoCorrect(text: string, proofing: ViewerProofingOptions): string;
+//# sourceMappingURL=autocorrect.d.ts.map

package/dist/pptx/render/options/autocorrect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocorrect.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/options/autocorrect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AA0G9D,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,qBAAqB,GAAG,MAAM,CA0BtF"}

package/dist/pptx/render/options/index.d.ts

@@ -0,0 +1,12 @@
+export * from './autocorrect.js';
+export * from './quick-access.js';
+export * from './viewer-addins.js';
+export * from './viewer-options.js';
+export * from './viewer-options-apply.js';
+export * from './viewer-options-constraints.js';
+export * from './viewer-options-controls.js';
+export * from './viewer-options-schema.js';
+export * from './viewer-options-store.js';
+export * from './viewer-options-tabs-advanced.js';
+export * from './viewer-options-tabs-core.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pptx/render/options/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/options/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}