ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/smartart-reflow-to-shapes.d.ts

@@ -0,0 +1,39 @@
+/**
+ * SmartArt reflow: convert algorithmic layout results back to
+ * PptxSmartArtDrawingShape[] so the drawing-shape renderer handles post-edit
+ * display and shapes round-trip correctly through save.
+ *
+ * When structural edits (add/remove/reorder/text/style) clear `drawingShapes`,
+ * `rebuildDrawingShapesIfCleared` calls the layout engine and converts the
+ * geometry back to drawing shapes so the richer DrawingShapeRenderer path
+ * stays active rather than falling back to the plain SVG family renderer.
+ *
+ * @module smartart-reflow-to-shapes
+ */
+import type { PptxSmartArtData, PptxSmartArtDrawingShape, PptxSmartArtNode, SmartArtLayout, SmartArtStyle } from 'ooxml-core/pptx';
+import type { BoundingBox, SmartArtLayoutResult } from './smartart-layout-types.js';
+/**
+ * Convert a SmartArt layout result to an array of PptxSmartArtDrawingShape.
+ *
+ * Rendered nodes are matched to source nodes by flat index when the counts
+ * align; otherwise the rendered node's key is used as the node-id suffix.
+ * Connector paths are omitted: PptxSmartArtDrawingShape has no SVG path field,
+ * and connectors carry no editable content anyway.
+ */
+export declare function reflowToDrawingShapes(layoutResult: SmartArtLayoutResult, nodes: readonly PptxSmartArtNode[]): PptxSmartArtDrawingShape[];
+/**
+ * Rebuild drawing shapes from the algorithmic layout engine when they have been
+ * cleared by a structural edit (add/remove/reorder/text/style change on a node).
+ *
+ * Returns the original data unchanged when drawing shapes are already populated
+ * or when there are no nodes to lay out.
+ *
+ * @param smartArtData  - The updated SmartArt data (with cleared drawingShapes).
+ * @param layout        - Named layout preset from the element (may be undefined).
+ * @param palette       - Resolved colour palette (hex strings).
+ * @param style         - Resolved SmartArt style intensity.
+ * @param elementId     - Element ID used for stable SVG key generation.
+ * @param box           - Pixel bounding box of the element.
+ */
+export declare function rebuildDrawingShapesIfCleared(smartArtData: PptxSmartArtData, layout: SmartArtLayout | undefined, palette: string[], style: SmartArtStyle, elementId: string, box: BoundingBox): PptxSmartArtData;
+//# sourceMappingURL=smartart-reflow-to-shapes.d.ts.map

package/dist/pptx/render/smartart-reflow-to-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-reflow-to-shapes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/smartart-reflow-to-shapes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACX,gBAAgB,EAChB,wBAAwB,EACxB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAAE,WAAW,EAAgB,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAmH/F;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,YAAY,EAAE,oBAAoB,EAClC,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAChC,wBAAwB,EAAE,CAa5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,6BAA6B,CAC5C,YAAY,EAAE,gBAAgB,EAC9B,MAAM,EAAE,cAAc,GAAG,SAAS,EAClC,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,aAAa,EACpB,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,WAAW,GACd,gBAAgB,CAiClB"}

package/dist/pptx/render/snap-guides.d.ts

@@ -0,0 +1,4 @@
+/** Compatibility entry: the implementation lives in ooxml-core/geometry (`snap-guides.ts`). */
+export { SNAP_THRESHOLD, computeSnapToShape, computeSnap, snapToGridStep, snapValue, snapBox, } from 'ooxml-core/geometry';
+export type { SnapSibling, SnapGuideInput, SnapLine, SnapToShapeResult, SnapBox, SnapGuide, SnapResult, } from 'ooxml-core/geometry';
+//# sourceMappingURL=snap-guides.d.ts.map

package/dist/pptx/render/snap-guides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snap-guides.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/snap-guides.ts"],"names":[],"mappings":"AAAA,+FAA+F;AAC/F,OAAO,EACN,cAAc,EACd,kBAAkB,EAClB,WAAW,EACX,cAAc,EACd,SAAS,EACT,OAAO,GACP,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACX,WAAW,EACX,cAAc,EACd,QAAQ,EACR,iBAAiB,EACjB,OAAO,EACP,SAAS,EACT,UAAU,GACV,MAAM,qBAAqB,CAAC"}

package/dist/pptx/render/state-equality.d.ts

@@ -0,0 +1,69 @@
+/**
+ * state-equality.ts: no-op-write guards for the viewer's hot state paths.
+ *
+ * Every binding keys its reactivity on identity: React compares the state
+ * object, Vue triggers on a `ref` assignment, Angular signals notify on
+ * `Object.is` mismatch, Svelte invalidates a `$state` assignment, and Vanilla
+ * repaints imperatively on each call. So a write that carries NO new
+ * information still costs a full render everywhere, and the cost is paid five
+ * times over because the write usually originates in shared code.
+ *
+ * Issue #145 was one instance of that shape: a presenter-console tick that
+ * changed nothing still allocated a fresh snapshot (and bumped `sequence`), so
+ * nothing downstream could bail out. The helpers here let the shared producers
+ * answer "did this actually change?" once, rather than each binding trying to
+ * memoise around a value that is new by construction.
+ *
+ * These are deliberately field-by-field rather than a generic deep-equal: the
+ * hot paths run per pointer move and per animation frame, so the comparison has
+ * to be cheaper than the render it prevents, and a generic walk over unknown
+ * nested data is not.
+ */
+import type { SanitizedPresence } from './collaboration-presence.js';
+import type { PresentationSnapshot } from './presentation-session-types.js';
+/**
+ * Shallow, order-sensitive array equality, for selector subscriptions whose
+ * slice is an array.
+ *
+ * Needed more often than it looks. Several shared stores rebuild their state by
+ * deep-cloning it on every write (`cloneViewerOptions` is one), so a nested
+ * array is a NEW array after any change anywhere in the object, even when its
+ * contents did not move. Under the default `Object.is` a selector reading that
+ * array would therefore fire on every unrelated write, which is exactly the
+ * over-notification a selector is supposed to prevent.
+ */
+export declare function sameArray<T>(a: readonly T[], b: readonly T[], isEqual?: (x: T, y: T) => boolean): boolean;
+/**
+ * Whether two presentation snapshots convey the same state.
+ *
+ * `sequence` is deliberately EXCLUDED. It is a monotonic change counter that is
+ * bumped by construction on every merge, so including it would make every
+ * snapshot unequal to every other and defeat the entire guard. Nothing compares
+ * sequences for ordering; the audience-side validator only type-checks it.
+ *
+ * `inkStrokes` is compared by reference on purpose. The shared ink helpers are
+ * copy-on-write (`appendPresentationInkPoint` returns a new array), so identity
+ * is an exact change signal, and a deep walk would run per pointer move while a
+ * presenter is drawing, which is the one place we can least afford it.
+ */
+export declare function presentationSnapshotsEqual(a: PresentationSnapshot, b: PresentationSnapshot): boolean;
+/**
+ * Whether two sanitised presence entries describe the same collaborator in the
+ * same place.
+ *
+ * `lastUpdated` is deliberately EXCLUDED, and that exclusion is the whole point:
+ * every peer re-stamps it on each heartbeat, so comparing it would mean an
+ * idle room still re-rendered every client on a fixed interval forever. Dropping
+ * it does not weaken staleness handling, because a peer that genuinely goes
+ * stale is removed from the list by `derivePresenceList` and the resulting
+ * length change is caught here.
+ */
+export declare function presenceEntriesEqual(a: SanitizedPresence, b: SanitizedPresence): boolean;
+/**
+ * Whether two derived presence lists are interchangeable, so a binding can keep
+ * its existing array (and skip the re-render) instead of adopting a fresh one.
+ * Order is significant, which is safe because `derivePresenceList` walks the
+ * awareness map in insertion order.
+ */
+export declare function presenceListsEqual(a: readonly SanitizedPresence[], b: readonly SanitizedPresence[]): boolean;
+//# sourceMappingURL=state-equality.d.ts.map

package/dist/pptx/render/state-equality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-equality.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/state-equality.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAEX,oBAAoB,EAEpB,MAAM,8BAA8B,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAC1B,CAAC,EAAE,SAAS,CAAC,EAAE,EACf,CAAC,EAAE,SAAS,CAAC,EAAE,EACf,OAAO,GAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmB,GAC1C,OAAO,CAWT;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACzC,CAAC,EAAE,oBAAoB,EACvB,CAAC,EAAE,oBAAoB,GACrB,OAAO,CAiBT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,iBAAiB,EAAE,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAexF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,CAAC,EAAE,SAAS,iBAAiB,EAAE,EAC/B,CAAC,EAAE,SAAS,iBAAiB,EAAE,GAC7B,OAAO,CAWT"}

package/dist/pptx/render/status-bar-state.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shared model for the bottom status bar (`pptx-ui-status-bar`).
+ *
+ * The slide counter, save indicator, notes toggle, view-mode buttons and zoom
+ * cluster were hand-built five times. The view owns the markup, pressed state
+ * and gating; hosts own every effect (notes panel, view switching, zoom).
+ */
+export type StatusBarTranslate = (key: string, params?: Record<string, string | number>) => string;
+/** Public intent ids. Hosts map them to their native handlers. */
+export type StatusBarControlId = 'notes' | 'normal' | 'sorter' | 'slideShow' | 'zoomOut' | 'zoomFit' | 'zoomIn';
+export type StatusBarSaveKind = 'idle' | 'saving' | 'error';
+export type StatusBarViewMode = 'normal' | 'sorter' | 'slideShow';
+export interface StatusBarViewState {
+    slideCount: number;
+    /** Zero-based active slide; clamped into range for display. */
+    activeSlideIndex: number;
+    /** Already-translated save indicator, see {@link resolveStatusBarSave}. */
+    saveText: string;
+    saveKind?: StatusBarSaveKind;
+    /** Omit to hide the whole zoom cluster. */
+    zoomPercent?: number;
+    showNotes?: boolean;
+    notesExpanded?: boolean;
+    /** Default true. False drops the Normal / Sorter / Slide Show cluster. */
+    showViewModes?: boolean;
+    /** Default true. */
+    showSorter?: boolean;
+    /** Default true. */
+    showSlideShow?: boolean;
+    /** The pressed view button; omit when none is active. */
+    viewMode?: StatusBarViewMode;
+    translate?: StatusBarTranslate;
+}
+export type StatusBarIntent = {
+    id: StatusBarControlId;
+};
+export interface StatusBarAutosave {
+    state: 'idle' | 'disabled' | 'saving' | 'saved' | 'error';
+    /** Epoch ms of the last successful save; "saved" without it reads as dirty/all-saved. */
+    timestamp?: number;
+}
+/** The one save-indicator rule: autosave state first, then the dirty flag. */
+export declare function resolveStatusBarSave(t: StatusBarTranslate, autosave: StatusBarAutosave | undefined, dirty: boolean, now?: number): {
+    text: string;
+    kind: StatusBarSaveKind;
+};
+/** Map a viewer mode string to the pressed view button (unknown modes press none). */
+export declare function statusBarViewMode(mode: string | undefined, sorterOpen?: boolean): StatusBarViewMode | undefined;
+//# sourceMappingURL=status-bar-state.d.ts.map

package/dist/pptx/render/status-bar-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status-bar-state.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/status-bar-state.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,MAAM,CAAC;AAEnG,kEAAkE;AAClE,MAAM,MAAM,kBAAkB,GAC3B,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,WAAW,GACX,SAAS,GACT,SAAS,GACT,QAAQ,CAAC;AAEZ,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,CAAC;AAC5D,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAC;AAElE,MAAM,WAAW,kBAAkB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,gBAAgB,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,2CAA2C;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,0EAA0E;IAC1E,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,oBAAoB;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,yDAAyD;IACzD,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,SAAS,CAAC,EAAE,kBAAkB,CAAC;CAC/B;AAED,MAAM,MAAM,eAAe,GAAG;IAAE,EAAE,EAAE,kBAAkB,CAAA;CAAE,CAAC;AAEzD,MAAM,WAAW,iBAAiB;IACjC,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;IAC1D,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAaD,8EAA8E;AAC9E,wBAAgB,oBAAoB,CACnC,CAAC,EAAE,kBAAkB,EACrB,QAAQ,EAAE,iBAAiB,GAAG,SAAS,EACvC,KAAK,EAAE,OAAO,EACd,GAAG,GAAE,MAAmB,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAiB3C;AAED,sFAAsF;AACtF,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,UAAU,UAAQ,GAChB,iBAAiB,GAAG,SAAS,CAQ/B"}

package/dist/pptx/render/stroke-dash-options.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `stroke-dash-options` - the pure option catalogue backing every binding's
+ * stroke/dash-pattern picker (shape/connector line style, table borders).
+ *
+ * WHY this lives in shared: the 12 `ST_PresetLineDashVal` values are plain
+ * data with no framework in them. They previously sat inside
+ * `packages/react/src/viewer/constants/connectors-strokes.ts`, which meant a
+ * binding porting the picker had to retype the list (and its i18n keys) by
+ * hand. `packages/react` now re-exports {@link STROKE_DASH_OPTIONS} from here
+ * so there is exactly one list to update.
+ *
+ * @module render/stroke-dash-options
+ */
+import type { StrokeDashType } from 'ooxml-core/pptx';
+/** A selectable stroke dash pattern with its English label and i18n key. */
+export interface StrokeDashOption {
+    value: StrokeDashType;
+    label: string;
+    i18nKey: string;
+}
+/**
+ * Every `ST_PresetLineDashVal` value offered by the inspector's dash-pattern
+ * select, in the same order React's `connectors-strokes.ts` used.
+ */
+export declare const STROKE_DASH_OPTIONS: readonly StrokeDashOption[];
+//# sourceMappingURL=stroke-dash-options.d.ts.map

package/dist/pptx/render/stroke-dash-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-dash-options.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-dash-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEtD,4EAA4E;AAC5E,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,SAAS,gBAAgB,EA6B1D,CAAC"}

package/dist/pptx/render/stroke-line-style-options.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `stroke-line-style-options` - the pure option catalogues backing the
+ * inspector's compound-line, line-join, and line-cap pickers.
+ *
+ * WHY this lives in shared: `COMPOUND_LINE_OPTIONS`, `LINE_JOIN_OPTIONS`, and
+ * `LINE_CAP_OPTIONS` previously sat inside React's
+ * `fill-stroke-options.ts` as bare data with no framework in them, so a
+ * binding porting the fill/stroke panel had to retype the 11 values (and
+ * their i18n keys) by hand. React now re-exports these from here so there is
+ * exactly one list to update.
+ *
+ * @module render/stroke-line-style-options
+ */
+import type { ShapeStyle } from 'ooxml-core/pptx';
+/** A selectable stroke-styling value with its English label and i18n key. */
+export interface StrokeLineStyleOption<T extends string> {
+    value: T;
+    label: string;
+    i18nKey: string;
+}
+/** Every `a:ln/@cmpd` (compound line) value offered by the inspector. */
+export declare const COMPOUND_LINE_OPTIONS: readonly StrokeLineStyleOption<NonNullable<ShapeStyle['compoundLine']>>[];
+/** Every `a:ln/a:*Join` (line join) value offered by the inspector. */
+export declare const LINE_JOIN_OPTIONS: readonly StrokeLineStyleOption<NonNullable<ShapeStyle['lineJoin']>>[];
+/** Every `a:ln/@cap` (line cap) value offered by the inspector. */
+export declare const LINE_CAP_OPTIONS: readonly StrokeLineStyleOption<NonNullable<ShapeStyle['lineCap']>>[];
+//# sourceMappingURL=stroke-line-style-options.d.ts.map

package/dist/pptx/render/stroke-line-style-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-line-style-options.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-line-style-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,6EAA6E;AAC7E,MAAM,WAAW,qBAAqB,CAAC,CAAC,SAAS,MAAM;IACtD,KAAK,EAAE,CAAC,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,eAAO,MAAM,qBAAqB,EAAE,SAAS,qBAAqB,CACjE,WAAW,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC,CACvC,EAMA,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,iBAAiB,EAAE,SAAS,qBAAqB,CAC7D,WAAW,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CACnC,EAIA,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,gBAAgB,EAAE,SAAS,qBAAqB,CAC5D,WAAW,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAClC,EAIA,CAAC"}

package/dist/pptx/render/stroke-only-preset.d.ts

@@ -0,0 +1,27 @@
+import type { PptxElement, PresetSubpathResult } from 'ooxml-core/pptx';
+/**
+ * Return a preset shape's evaluated sub-paths when, and only when, the geometry
+ * is stroke-only: `evaluatePresetShape` reports `fillNone`, i.e. every sub-path
+ * declares `fill="none"`.
+ *
+ * Custom geometry (which paints via `pathData`), non-`shape` elements and
+ * ordinary filled presets return `undefined` so callers keep their existing
+ * rendering. The element type is restricted to `shape` on purpose: a picture
+ * paints its own bitmap and must never be reinterpreted as an outline.
+ */
+export declare function getStrokeOnlyPresetPaths(element: PptxElement): PresetSubpathResult[] | undefined;
+/**
+ * Whether this element is a stroke-only preset, i.e. it must be painted as a
+ * stroked path with no container fill, no CSS border and no shape clip-path.
+ * The predicate every binding gates its container cascade on.
+ */
+export declare function isStrokeOnlyPresetElement(element: PptxElement): boolean;
+/**
+ * SVG path data for a stroke-only preset, in the element's own pixel space.
+ *
+ * Sub-paths that opt out of the stroke (`a:path/@stroke="0"`) are dropped; the
+ * rest are concatenated, which is exactly how one `<path>` paints several open
+ * strands. Returns `undefined` for anything that is not a stroke-only preset.
+ */
+export declare function strokeOnlyPresetPathData(element: PptxElement): string | undefined;
+//# sourceMappingURL=stroke-only-preset.d.ts.map

package/dist/pptx/render/stroke-only-preset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-only-preset.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-only-preset.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,mBAAmB,EAAE,GAAG,SAAS,CAwBhG;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAOjF"}

package/dist/pptx/render/stroke-outline.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Stroked SVG OUTLINES: gradient/pattern lines (`a:ln/a:gradFill`,
+ * `a:ln/a:pattFill`), stroke-only ("open") preset geometry, and centred
+ * (`a:ln/@algn="ctr"`) solid lines.
+ *
+ * Every binding paints a shape's outline as a CSS `border`, which can only take
+ * a single flat colour, can only outline a BOX, and - because `box-sizing:
+ * border-box` puts the whole border INSIDE the element's declared box - can only
+ * express `a:ln/@algn="in"`. That breaks three ways:
+ *
+ *  - A gradient outline was rendered with the parser's averaged `strokeColor`
+ *    (two-tone came out flat, fade-to-transparent came out opaque), and a
+ *    patterned outline with the pattern's foreground alone, so the hatching
+ *    disappeared entirely.
+ *  - An open preset (`<a:prstGeom prst="line"/>`, the connector family, `arc`,
+ *    …) has no region to fill and no box to outline, so a CSS border drew a
+ *    RECTANGLE where PowerPoint draws a line or an arc. See
+ *    `./stroke-only-preset`.
+ *  - `@algn="ctr"` is PowerPoint's DEFAULT (an omitted `@algn` means `ctr`, not
+ *    `in`): the line straddles the shape's path, half outside the box and half
+ *    over the fill. A `border-box` CSS border cannot straddle anything - it can
+ *    only sit flush with the box edge - so every bordered shape at the default
+ *    alignment rendered `strokeWidth / 2` too small on each edge. An SVG
+ *    `<path>` stroke is centred on the path by definition, so routing the
+ *    default-aligned case through this same overlay is the fix; `@algn="in"`
+ *    keeps the cheap `border-box` CSS border, which is already exactly right.
+ *
+ * CSS has no way to fix any of these in place - `border-image` ignores
+ * `border-radius` and cannot follow a `clip-path`, and no CSS property centres a
+ * border on the box edge - so the outline is instead stroked as a real SVG path
+ * laid over the element, using the shape's own resolved geometry. This module
+ * turns an element into everything a binding needs for that overlay; the
+ * bindings supply only the ~10 lines of view layer.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { SvgGradientDef, SvgPatternDef } from './svg-gradient-paint.js';
+/** The paint server an outline is stroked with: a gradient or a pattern. */
+export type StrokeOutlinePaint = SvgGradientDef | SvgPatternDef;
+/**
+ * One parallel stroke of a compound (`a:ln/@cmpd`) line: its width, and its
+ * perpendicular offset from the centre line in element px. A single line is one
+ * strand at offset `0`.
+ */
+export interface StrokeOutlineStrand {
+    strokeWidth: number;
+    offset: number;
+}
+/** Everything needed to stroke one shape's outline as an SVG overlay. */
+export interface StrokeOutline {
+    /** Path data in the element's own pixel space (viewBox `0 0 width height`). */
+    d: string;
+    /**
+     * Paint server to define in `<defs>`, or `undefined` when the outline is
+     * stroked with a flat colour (an open preset with an ordinary solid line).
+     */
+    paint: StrokeOutlinePaint | undefined;
+    /** Ready-to-use SVG `stroke` value: `url(#…)` for a paint server, else a colour. */
+    stroke: string;
+    strokeWidth: number;
+    /** Parallel strands to emit; one entry unless the line is compound. */
+    strands: readonly StrokeOutlineStrand[];
+    /** SVG `stroke-dasharray`, or `undefined` for a solid line. */
+    dashArray: string | undefined;
+    lineCap: 'butt' | 'round' | 'square';
+    lineJoin: 'round' | 'bevel' | 'miter';
+}
+/** Narrowing helper for bindings, whose templates cannot narrow a union inline. */
+export declare function isPatternPaint(paint: StrokeOutlinePaint | undefined): paint is SvgPatternDef;
+/**
+ * Convert a CSS `clip-path` value into path data in element pixel space.
+ *
+ * `getResolvedShapeClipPath` already returns `path('…')` for every preset the
+ * ECMA evaluator covers (including `ellipse`, which the bindings otherwise paint
+ * with `border-radius`), so that is the common case. `polygon()` from the static
+ * table is converted point by point; anything else - `inset()`, or no clip at
+ * all - falls back to the element's rectangle.
+ */
+export declare function outlinePathData(clipPath: string | undefined, width: number, height: number): string | undefined;
+/** Whether a preset's pointer is part of the authored outline and may extend outside its body box. */
+export declare function isWedgeCalloutPresetShape(shapeType?: string): boolean;
+export interface PresetShapeVectorGeometry {
+    d: string;
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    viewWidth: number;
+    viewHeight: number;
+}
+/** Resolve a preset outline into SVG path data plus any authored out-of-box bounds. */
+export declare function getPresetShapeVectorGeometry(shapeType: string | undefined, width: number, height: number, adjustments?: Record<string, number>): PresetShapeVectorGeometry | undefined;
+/**
+ * Resolve the SVG overlay that paints an element's outline, or `undefined` when
+ * the binding's CSS border is correct and cheaper (a closed shape whose line is
+ * explicitly inset, `a:ln/@algn="in"`).
+ *
+ * Three things need the overlay: a gradient/pattern line, which a CSS border
+ * cannot express; a stroke-only preset, which has no box to put a border on;
+ * and a centred (`ctr`, the default) solid line, which a `border-box` CSS
+ * border cannot straddle. The last two are painted with a flat colour, so
+ * `paint` is `undefined` there and `stroke` carries the colour instead.
+ */
+export declare function buildStrokeOutline(element: PptxElement): StrokeOutline | undefined;
+/**
+ * The `viewBox` a binding must give the outline overlay: the element's PAINTED
+ * box, i.e. its authored extent (see shared `getContainerStyle` /
+ * `paintedElementSize`), floored at zero.
+ *
+ * Matching the viewBox to the painted box rather than to some other extent
+ * keeps the user-space mapping 1:1 under `preserveAspectRatio="none"`: the
+ * overlay `<svg>` is displayed at exactly the wrapper's own CSS width/height
+ * (100%/100%), so its `viewBox` must equal the same box the wrapper itself
+ * uses or the outline would be non-uniformly scaled. This used to be the
+ * INTERACTIVE-only padded box (see `elementHitTargetStyle`); painting the
+ * outline at that padded size in read-only rendering stretched a hairline
+ * rule's border across a much taller box than it was authored at (issue #285).
+ *
+ * Returns `undefined` for a box under 1px on either side. A zero side would
+ * hide the `<svg>`, and the 1px minimum size the bindings give it would stretch
+ * a sub-pixel one. The path is then drawn in the wrapper's own pixels.
+ */
+export declare function strokeOutlineViewBox(element: PptxElement): string | undefined;
+/**
+ * Whether a binding should suppress its CSS border for this element because the
+ * stroke overlay is painting the outline instead. Keeping both would draw the
+ * averaged solid (or the pattern's bare foreground) underneath a gradient line,
+ * and would box a stroke-only preset inside the rectangle it does not have.
+ */
+export declare function suppressesCssBorder(element: PptxElement): boolean;
+//# sourceMappingURL=stroke-outline.d.ts.map

package/dist/pptx/render/stroke-outline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-outline.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-outline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,iBAAiB,CAAC;AAe/D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAS1E,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,aAAa,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yEAAyE;AACzE,MAAM,WAAW,aAAa;IAC7B,+EAA+E;IAC/E,CAAC,EAAE,MAAM,CAAC;IACV;;;OAGG;IACH,KAAK,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACtC,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,uEAAuE;IACvE,OAAO,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACxC,+DAA+D;IAC/D,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrC,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CACtC;AAED,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,kBAAkB,GAAG,SAAS,GAAG,KAAK,IAAI,aAAa,CAE5F;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACZ,MAAM,GAAG,SAAS,CAiCpB;AAQD,sGAAsG;AACtG,wBAAgB,yBAAyB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,MAAM,WAAW,yBAAyB;IACzC,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACnB;AAqBD,uFAAuF;AACvF,wBAAgB,4BAA4B,CAC3C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAClC,yBAAyB,GAAG,SAAS,CAkCvC;AAuDD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,aAAa,GAAG,SAAS,CA+ClF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,GAAG,SAAS,CAO7E;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAEjE"}

package/dist/pptx/render/stroke-paint.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Should this shape/picture outline be painted at all?
+ *
+ * OOXML allows a width-only line, e.g. `<a:ln w="12700"><a:miter .../></a:ln>`,
+ * with no fill child and no `<p:style>/<a:lnRef>` reference. That leaves the
+ * line FILL unspecified, and PowerPoint paints no outline for it (verified
+ * against a PowerPoint render of the real-world media deck, whose photos all
+ * carry exactly that markup: the pictures are frameless). Core parses it as
+ * `strokeWidth > 0` with `strokeColor`/`strokeFillMode` both `undefined`, so a
+ * renderer must treat the missing colour as "no line", never substitute a
+ * default stroke colour: React did, and painted a dark 1px frame around every
+ * such picture that no other binding (and not PowerPoint) draws.
+ *
+ * When a line has any fill source (an explicit `a:solidFill`, an averaged
+ * gradient/pattern colour, or a colour resolved from the theme's `lnStyleLst`
+ * via `a:lnRef`), core writes `strokeColor` (and `strokeFillMode`), and the
+ * outline paints as before.
+ */
+export declare function hasStrokePaint(style: {
+    strokeWidth?: number;
+    strokeColor?: string;
+    strokeFillMode?: string;
+} | undefined): boolean;
+/**
+ * The stroke width a renderer should paint: the parsed width when the line has
+ * a fill source, `0` when it is a width-only (fill-less) line. Bindings that
+ * gate their CSS border on `strokeWidth > 0` can substitute this directly.
+ */
+export declare function paintedStrokeWidth(style: {
+    strokeWidth?: number;
+    strokeColor?: string;
+    strokeFillMode?: string;
+} | undefined): number;
+//# sourceMappingURL=stroke-paint.d.ts.map

package/dist/pptx/render/stroke-paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-paint.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-paint.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GACxF,OAAO,CAKT;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,GACxF,MAAM,CAER"}

package/dist/pptx/render/stroke-style.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The CSS a shape's OUTLINE (`a:ln`) is painted with, as one neutral decision.
+ *
+ * Every binding ended up writing its own two-line version of this
+ * (`border: <width> <dash> <colour>`), and each of those copies dropped a
+ * different part of `a:ln`:
+ *
+ *  - `@cmpd` (double / thickThin / thinThick / tri) reached only React and
+ *    Angular, because only they passed the compound type to
+ *    {@link getCssBorderDashStyle}. Vue, Svelte and Vanilla painted every
+ *    compound outline as one solid line.
+ *  - `a:miter/@lim` reached only React, which wrote `stroke-miterlimit` on the
+ *    shape container. That property is an INHERITED SVG presentation property,
+ *    so writing it on the container is what makes both the freeform `<path>` and
+ *    the stroke overlay honour it - no per-overlay wiring needed.
+ *  - `strokeOpacity` was applied by React and dropped by Svelte.
+ *
+ * So the outline is resolved here once and each binding only maps the result
+ * onto its own style object. One thing deliberately stays OUT: suppressing the
+ * border for an element the binding paints as an SVG `<path>` of its own
+ * (React's freeform `renderVectorShape`) is a view-layer fact, not a property of
+ * the OOXML, so it stays in the binding.
+ *
+ * @module render/stroke-style
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { CssBorderStyle } from './element-style-transform.js';
+/** SVG `stroke-linejoin` values, as `a:ln/a:round|a:bevel|a:miter` map onto them. */
+export type SvgStrokeLineJoin = 'miter' | 'round' | 'bevel';
+/** SVG `stroke-linecap` values, as `a:ln/@cap` maps onto them. */
+export type SvgStrokeLineCap = 'butt' | 'round' | 'square';
+/** The resolved CSS outline of a shape. See {@link getComputedStrokeStyle}. */
+export interface ComputedStrokeStyle {
+    /**
+     * `border-width` in px. `0` means "paint no CSS border": either the shape has
+     * no painted line at all, or the stroke overlay
+     * ({@link suppressesCssBorder}) is painting the outline instead.
+     *
+     * A compound line keeps the full authored width, which `border-style: double`
+     * then divides between its strands and the gap.
+     */
+    readonly borderWidth: number;
+    /** `border-style`, or `undefined` when nothing is painted. */
+    readonly borderStyle: CssBorderStyle | undefined;
+    /** `border-color` (already carrying `strokeOpacity`), or `undefined`. */
+    readonly borderColor: string | undefined;
+    /**
+     * The three above as a `border` shorthand, for bindings that write one
+     * property. `undefined` when nothing is painted.
+     */
+    readonly border: string | undefined;
+    /** `stroke-linejoin` (inherited into descendant SVG), from `a:ln`'s join. */
+    readonly strokeLinejoin: SvgStrokeLineJoin | undefined;
+    /** `stroke-linecap` (inherited into descendant SVG), from `a:ln/@cap`. */
+    readonly strokeLinecap: SvgStrokeLineCap | undefined;
+    /**
+     * `stroke-miterlimit` from `a:miter/@lim`, as a plain ratio. Inherited, so
+     * writing it on the shape container reaches the freeform path AND the stroke
+     * overlay without either of them restating it.
+     */
+    readonly strokeMiterlimit: number | undefined;
+}
+/**
+ * Resolve the CSS outline of a shape-like element.
+ *
+ * @param element - The element whose `a:ln` is being painted.
+ * @returns A neutral descriptor; `borderWidth === 0` when no CSS border applies.
+ */
+export declare function getComputedStrokeStyle(element: PptxElement): ComputedStrokeStyle;
+//# sourceMappingURL=stroke-style.d.ts.map

package/dist/pptx/render/stroke-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stroke-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/stroke-style.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,iBAAiB,CAAC;AAI/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAMhE,qFAAqF;AACrF,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAC5D,kEAAkE;AAClE,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE3D,+EAA+E;AAC/E,MAAM,WAAW,mBAAmB;IACnC;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,EAAE,cAAc,GAAG,SAAS,CAAC;IACjD,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,cAAc,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvD,0EAA0E;IAC1E,QAAQ,CAAC,aAAa,EAAE,gBAAgB,GAAG,SAAS,CAAC;IACrD;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9C;AA2DD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,mBAAmB,CAyChF"}

package/dist/pptx/render/subpath-fill-overlay.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Per-sub-path FILL overlay: the shared mechanism behind two structurally
+ * identical bugs.
+ *
+ * Both custom geometry (`a:custGeom`) and preset geometry (`a:prstGeom`) can
+ * carry several sub-paths, each with its own `@fill` mode
+ * (`norm`/`lighten`/`lightenLess`/`darken`/`darkenLess`/`none`) and `@stroke`
+ * flag. Every binding paints a shape as ONE box: a single CSS
+ * `background-color` clipped to a single merged `clip-path` built by
+ * concatenating every sub-path's `d` together (`getResolvedShapeClipPath`,
+ * `buildCustomGeometryClipPath`). That merge is lossy two ways:
+ *
+ *  - It discards each sub-path's own `@fill`, so a preset's shading/bevel
+ *    sub-paths (`lighten`/`darken`, e.g. every `actionButton*`, curved arrows,
+ *    `bevel`, `foldedCorner`) paint as flat instead of shaded, and a `fill="none"`
+ *    sub-path (`smileyFace`'s eyes/mouth) paints FILLED instead of as an open
+ *    stroke - because `clip-path` auto-closes every sub-path.
+ *  - It cannot vary the fill AT ALL across sub-paths, so it is architecturally
+ *    incapable of the above regardless of which colour is chosen.
+ *
+ * The fix is the same for both: paint the affected element as layered SVG
+ * `<path>`s, each carrying its own resolved fill, instead of one CSS box. This
+ * module decides WHICH elements need that (an element needs it only when at
+ * least one sub-path's mode is not `norm`/unset, or it opts out of its stroke)
+ * and builds the paints via the shared `./vector-subpath-paint`; a binding's
+ * `ShapeEffectOverlay` renders the result as an `<svg>` sibling to the shape
+ * box (mirroring `buildStrokeOutline`), and `getComputedFillStyle`
+ * ({@link suppressesCssFill}) drops the CSS background so the flat colour does
+ * not show underneath.
+ *
+ * Restricted to a solid (or absent) fill: a gradient/pattern/image fill keeps
+ * the existing single merged clip-path box, since neither geometry kind's
+ * sub-paths can carry an independent paint SERVER (only a solid, mode-shifted
+ * colour), and the common case for both bug classes - shading/bevel highlights,
+ * `smileyFace`'s eyes - is a solid theme colour.
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { SubpathPaint } from './vector-subpath-paint.js';
+/** Everything a binding needs to paint an element's per-sub-path fill overlay. */
+export interface SubpathFillOverlay {
+    /** One paint per sub-path, in authoring order. */
+    readonly paints: readonly SubpathPaint[];
+    /** `viewBox` width, in the same coordinate space as every `paints[].d`. */
+    readonly viewBoxWidth: number;
+    /** `viewBox` height, in the same coordinate space as every `paints[].d`. */
+    readonly viewBoxHeight: number;
+}
+/**
+ * Whether a binding must drop its CSS `background-color` / `background-image`
+ * for this element because {@link buildSubpathFillOverlay} is painting the
+ * fill instead. Mirrors `suppressesCssBorder`'s role for the stroke overlay;
+ * consumed by shared `getComputedFillStyle`.
+ */
+export declare function suppressesCssFill(element: PptxElement): boolean;
+/**
+ * Build the per-sub-path fill overlay for an element, or `undefined` when a
+ * single merged fill/clip-path is correct (the ordinary case).
+ */
+export declare function buildSubpathFillOverlay(element: PptxElement): SubpathFillOverlay | undefined;
+//# sourceMappingURL=subpath-fill-overlay.d.ts.map

package/dist/pptx/render/subpath-fill-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subpath-fill-overlay.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/subpath-fill-overlay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,KAAK,EAIX,WAAW,EACX,MAAM,iBAAiB,CAAC;AASzB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAqB3D,kFAAkF;AAClF,MAAM,WAAW,kBAAkB;IAClC,kDAAkD;IAClD,QAAQ,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IACzC,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAC/B;AAoHD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAE/D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,kBAAkB,GAAG,SAAS,CAiB5F"}

package/dist/pptx/render/subtitle-settings.d.ts

@@ -0,0 +1,22 @@
+import type { ViewerOptions, ViewerOptionsStore } from './options/index.js';
+export declare const SUBTITLE_LANGUAGES: readonly ['auto', 'en-US', 'en-GB', 'fr-FR', 'de-DE', 'es-ES', 'pt-BR', 'it-IT', 'ja-JP', 'ko-KR', 'zh-CN'];
+export interface SubtitleSettings {
+    spokenLanguage: string;
+}
+/** Render familiar language names while keeping browser recognition codes in state. */
+export declare function subtitleLanguageLabel(language: string): string;
+export interface SubtitleSettingsLabels {
+    title: string;
+    language: string;
+    browserLanguage: string;
+    description: string;
+    apply: string;
+    cancel: string;
+}
+/** Browser recognition settings, independent of caption visibility and deck metadata. */
+export declare function normalizeSubtitleSettings(settings?: Partial<SubtitleSettings>): SubtitleSettings;
+export declare function subtitleSettingsFromOptions(options?: ViewerOptions): SubtitleSettings;
+export declare function updateSubtitleSettings(store: Pick<ViewerOptionsStore, 'setValue'>, settings: SubtitleSettings): void;
+export declare function subtitleRecognitionLanguage(settings: SubtitleSettings, browserLanguage?: string): string;
+export declare function subtitleSettingsLabels(t: (key: string) => string): SubtitleSettingsLabels;
+//# sourceMappingURL=subtitle-settings.d.ts.map

package/dist/pptx/render/subtitle-settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subtitle-settings.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/subtitle-settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAEnE,eAAO,MAAM,kBAAkB,YAC9B,MAAM,EACN,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,CACE,CAAC;AACX,MAAM,WAAW,gBAAgB;IAChC,cAAc,EAAE,MAAM,CAAC;CACvB;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM9D;AACD,MAAM,WAAW,sBAAsB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CACf;AAED,yFAAyF;AACzF,wBAAgB,yBAAyB,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GAAG,gBAAgB,CAOhG;AACD,wBAAgB,2BAA2B,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,gBAAgB,CAErF;AACD,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,UAAU,CAAC,EAC3C,QAAQ,EAAE,gBAAgB,GACxB,IAAI,CAMN;AACD,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,gBAAgB,EAC1B,eAAe,SAAU,GACvB,MAAM,CAER;AACD,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAAG,sBAAsB,CASzF"}