@file-viewer/pptx 3.3.1 → 3.3.3

package/dist/chart-config.d.ts

@@ -1,12 +1,10 @@
-import type { PptxChartAxis, PptxChartModel } from './chart-types.js';
-/** Common authored numeric formats; unsupported Excel formats remain in the model. */
+import type { PptxChartAxis, PptxChartModel } from "./chart-types.js";
 export declare const formatPptxChartNumber: (value: number, format?: string) => string;
 export declare const resolvePptxChartAxes: (model: PptxChartModel) => {
     category: PptxChartAxis | undefined;
     primary: PptxChartAxis | undefined;
     secondary: PptxChartAxis | undefined;
 };
-/** One category coordinate system, with every authored bar/line/area group. */
 export declare const createPptxCartesianChart: (model: PptxChartModel, library: Record<string, any>) => {
     interaction: {
         enabled: boolean;

package/dist/chart-config.js

@@ -1,4 +1,3 @@
-/** Common authored numeric formats; unsupported Excel formats remain in the model. */
 export const formatPptxChartNumber = (value, format = 'General') => {
     if (!Number.isFinite(value))
         return '';
@@ -37,7 +36,6 @@ export const resolvePptxChartAxes = (model) => {
     const category = (_b = axesFor(model.groups[0]).find(axis => axis.kind === 'category' || axis.kind === 'date')) !== null && _b !== void 0 ? _b : model.axes.find(axis => axis.kind === 'category' || axis.kind === 'date');
     return { category, primary, secondary };
 };
-/** One category coordinate system, with every authored bar/line/area group. */
 export const createPptxCartesianChart = (model, library) => {
     var _a, _b, _c, _d;
     if (!model.groups.length || model.groups.some(group => !['lineChart', 'barChart', 'areaChart'].includes(group.chartType)))
@@ -73,7 +71,6 @@ export const createPptxCartesianChart = (model, library) => {
     const groups = model.groups.flatMap((group, groupIndex) => group.options.grouping === 'stacked' || group.options.grouping === 'percentStacked'
         ? [rows.filter(row => row.groupIndex === groupIndex).map(row => row.id)] : []);
     const normalizeAll = model.groups.length === 1 && model.groups[0].options.grouping === 'percentStacked';
-    // Normalize only this stacked group, preserving an unrelated line/secondary axis.
     const totals = new Map();
     rows.forEach((row, rowIndex) => {
         if (normalizeAll || row.group.options.grouping !== 'percentStacked')

package/dist/chart-legend.d.ts

@@ -1,6 +1,4 @@
-import type { PptxChartFont, PptxChartOptions } from './chart-types.js';
-/** Billboard only provides outside bottom/right legends. Preserve the other
- * DrawingML placements without changing the authored outer chart frame. */
+import type { PptxChartFont, PptxChartOptions } from "./chart-types.js";
 export declare const createPptxChartLegend: (surface: HTMLElement, chart: any, legend?: PptxChartOptions["legend"], font?: PptxChartFont) => {
     size(): {
         width: number;

package/dist/chart-legend.js

@@ -1,6 +1,4 @@
-import { applyPptxChartFont } from './chart-text.js';
-/** Billboard only provides outside bottom/right legends. Preserve the other
- * DrawingML placements without changing the authored outer chart frame. */
+import { applyPptxChartFont } from "./chart-text.js";
 export const createPptxChartLegend = (surface, chart, legend, font) => {
     var _a, _b;
     const document = surface.ownerDocument;
@@ -28,8 +26,6 @@ export const createPptxChartLegend = (surface, chart, legend, font) => {
         else
             list.style.width = '100%';
     }
-    // Prevent the surface's 100% basis from pushing a non-overlay legend outside
-    // the frame. Flex assigns only the remaining logical area to the plot.
     surface.style.width = left ? '0' : '100%';
     surface.style.height = left ? '100%' : '0';
     surface.style.alignSelf = 'stretch';

package/dist/chart-text.d.ts

@@ -1,14 +1,7 @@
-import type { PptxChartFont, PptxChartModel } from './chart-types.js';
+import type { PptxChartFont, PptxChartModel } from "./chart-types.js";
 export declare const mergePptxChartFonts: (...fonts: Array<PptxChartFont | undefined>) => PptxChartFont;
-/** CSSOM property assignment keeps document font names out of stylesheet source. */
 export declare const applyPptxChartFont: (style: CSSStyleDeclaration, font?: PptxChartFont) => void;
-/** Apply authored fonts before Billboard measures labels, including Shadow DOM. */
 export declare const stylePptxChartText: (surface: HTMLElement, model?: PptxChartModel, chart?: any, legendFont?: PptxChartFont) => HTMLStyleElement | undefined;
-/**
- * Billboard's plugin hooks are per-chart. Its screen-space text rectangles and
- * punctuation-normalized cache keys cannot represent DrawingML coordinates or
- * distinct CJK labels. Measure fresh SVG glyph geometry in local coordinates.
- */
 export declare const createPptxChartTextPlugin: (surface: HTMLElement) => {
     $$: any;
     $beforeInit(): void;

package/dist/chart-text.js

@@ -1,6 +1,5 @@
-import { resolvePptxChartAxes } from './chart-config.js';
+import { resolvePptxChartAxes } from "./chart-config.js";
 export const mergePptxChartFonts = (...fonts) => Object.assign({}, ...fonts.map(font => Object.fromEntries(Object.entries(font || {}).filter(([, value]) => value !== undefined))));
-/** CSSOM property assignment keeps document font names out of stylesheet source. */
 export const applyPptxChartFont = (style, font) => {
     if (!font)
         return;
@@ -23,7 +22,6 @@ export const applyPptxChartFont = (style, font) => {
         style.fill = font.color;
     }
 };
-/** Apply authored fonts before Billboard measures labels, including Shadow DOM. */
 export const stylePptxChartText = (surface, model, chart, legendFont) => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     const view = (_a = surface.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;
@@ -35,8 +33,6 @@ export const stylePptxChartText = (surface, model, chart, legendFont) => {
     const selector = `.pptx-chart-surface.pptx-chart-typed[data-pptx-chart-text="${scope}"]`;
     const element = surface.ownerDocument.createElement('style');
     element.dataset.pptxChartFonts = '';
-    // Billboard replaces the bind target's children during initialization.
-    // Keep scoped rules beside that target so they also apply during measurement.
     (_b = surface.parentNode) === null || _b === void 0 ? void 0 : _b.appendChild(element);
     const sheet = element.sheet;
     if (!sheet)
@@ -77,11 +73,6 @@ export const stylePptxChartText = (surface, model, chart, legendFont) => {
         }
     return element;
 };
-/**
- * Billboard's plugin hooks are per-chart. Its screen-space text rectangles and
- * punctuation-normalized cache keys cannot represent DrawingML coordinates or
- * distinct CJK labels. Measure fresh SVG glyph geometry in local coordinates.
- */
 export const createPptxChartTextPlugin = (surface) => {
     const document = surface.ownerDocument;
     const view = document === null || document === void 0 ? void 0 : document.defaultView;
@@ -126,7 +117,6 @@ export const createPptxChartTextPlugin = (surface) => {
                             return { x: box.x, y: box.y, left: box.x, top: box.y, right: box.x + box.width,
                                 bottom: box.y + box.height, width: box.width, height: box.height };
                         }
-                        // Hidden slides still need logical font metrics before they become visible.
                         const style = view.getComputedStyle(node);
                         context !== null && context !== void 0 ? context : (context = document.createElement('canvas').getContext('2d'));
                         const size = Number.parseFloat(style.fontSize) || 10;

package/dist/chart-types.d.ts

@@ -1,4 +1,3 @@
-/** Serializable DrawingML metadata carried by the actual PPTX Worker. */
 export type PptxChartType = 'lineChart' | 'barChart' | 'areaChart' | 'scatterChart' | 'pieChart' | 'pie3DChart' | 'doughnutChart';
 export interface PptxChartFont {
     family?: string;
@@ -47,7 +46,6 @@ export interface PptxChartSeries {
         y: number | null;
     }>;
     xlabels: Record<string, string | number>;
-    /** Original indexed hierarchy, from innermost to outermost category level. */
     categoryLevels?: Array<Record<string, string>>;
 }
 export interface PptxChartAxis {

package/dist/chart.d.ts

@@ -1,16 +1,14 @@
-import type { PptxChartRenderer } from './chart-types.js';
+import type { PptxChartRenderer } from "./chart-types.js";
 export type PptxChartLibraries = {
     billboard: any;
     d3Format: typeof import('d3-format');
 };
 export type PptxChartLibraryLoader = () => Promise<PptxChartLibraries>;
-/** Register a renderer receiving the preserved Worker model, without reopening the ZIP. */
 export declare const registerPptxChartRenderer: (renderer: PptxChartRenderer | null) => void;
 export declare const registerPptxChartLibraryLoader: (loader: PptxChartLibraryLoader | null) => void;
 export type PptxPostProcessingHandle = {
     destroy: () => void;
 };
 export declare const findPptxChartTarget: (root: ParentNode, chartID: string) => HTMLElement | null;
-/** DrawingML numbering, including the authored suffix punctuation. */
 export declare const getNumericBulletText: (type: string, index: number) => string;
 export declare const renderPptxPostProcessing: (charts: unknown, root: ParentNode) => Promise<PptxPostProcessingHandle>;

package/dist/chart.js

@@ -1,9 +1,8 @@
-import { createPptxCartesianChart } from './chart-config.js';
-import { createPptxChartTextPlugin, mergePptxChartFonts, stylePptxChartText } from './chart-text.js';
-import { createPptxChartLegend } from './chart-legend.js';
+import { createPptxCartesianChart } from "./chart-config.js";
+import { createPptxChartTextPlugin, mergePptxChartFonts, stylePptxChartText } from "./chart-text.js";
+import { createPptxChartLegend } from "./chart-legend.js";
 let chartLibraryLoader = null;
 let chartRenderer = null;
-/** Register a renderer receiving the preserved Worker model, without reopening the ZIP. */
 export const registerPptxChartRenderer = (renderer) => {
     chartRenderer = renderer;
 };
@@ -47,7 +46,6 @@ const formatEastAsianNumber = (index) => {
     return digits[Math.floor(index / 10000)] + '万' +
         (remainder ? (remainder < 1000 ? digits[0] : '') + group(remainder, false) : '');
 };
-/** DrawingML numbering, including the authored suffix punctuation. */
 export const getNumericBulletText = (type, index) => {
     if (!Number.isInteger(index) || index < 1 || index > 32767) {
         return String(index);
@@ -179,8 +177,6 @@ const applyTextFitScale = (block, scale) => {
 const hasTextOverflow = (block, fitWidth = true) => block.scrollHeight > block.clientHeight + TEXT_FIT_TOLERANCE ||
     (fitWidth && block.scrollWidth > block.clientWidth + TEXT_FIT_TOLERANCE);
 const fitOverflowingTextBlock = (block, fitWidth = true) => {
-    // noAutofit/spAutoFit preserve authored typography. Only normal AutoFit may
-    // shrink text; unmarked legacy/table content retains its existing policy.
     const mode = block.dataset.pptxAutofit;
     if (mode && mode !== 'normal')
         return;
@@ -244,14 +240,10 @@ const renderChart = async (message, root) => {
     const { billboard, d3Format } = await chartLibraryLoader();
     const bb = billboard.default || billboard;
     const { area, bar, line, pie, donut, scatter } = billboard;
-    // Billboard 4 exposes grid focus as a separately registered ESM module.
-    // Bundled or custom loaders may already provide it without this export.
     if (typeof billboard.grid === 'function') {
         billboard.grid();
     }
     const chart = {
-        // A selector makes Billboard query the main document. That misses chart
-        // placeholders inside the viewer Shadow DOM and makes it fall back to body.
         bindto: chartTarget,
     };
     const chartData = payload.chartData;
@@ -276,8 +268,6 @@ const renderChart = async (message, root) => {
                 const names = {};
                 const colors = {};
                 for (const [index, point] of ((series === null || series === void 0 ? void 0 : series.values) || []).entries()) {
-                    // Keep one library id per indexed point, not per label. Duplicate/empty
-                    // labels are valid and must never merge sectors. Null is not zero.
                     if (typeof point.y !== 'number' || !Number.isFinite(point.y) || point.y === 0)
                         continue;
                     const id = `point-${index}`;
@@ -300,11 +290,6 @@ const renderChart = async (message, root) => {
                     },
                     transition: { duration: 0 },
                     onrendered() {
-                        // Billboard accepts an absolute ring width, while DrawingML specifies
-                        // a ratio. Read its finished SVG geometry and update through the public
-                        // config API. This also tracks library resize without private state or
-                        // assumptions about legend/font layout. The re-entrancy guard bounds
-                        // the corrective redraw to one pass per changed radius.
                         if (adjustingWidth || typeof this.config !== 'function')
                             return;
                         let radius = 0;
@@ -418,15 +403,10 @@ const renderChart = async (message, root) => {
             chart.legend = {
                 show: options.legend.show !== false,
                 position: options.legend.position === 'b' ? 'bottom' : 'right',
-                // The chart library cannot measure an empty SVG text node. Use an
-                // invisible measuring character only in legend presentation; names and
-                // tooltip data still retain the document's actual empty string.
                 format: (label) => label === '' ? '\u200b' : label,
             };
         }
         if (!cartesian && ['barChart', 'areaChart', 'lineChart'].includes(payload.chartType)) {
-            // Distinct series can legitimately share a display name. Billboard groups
-            // by id, so disambiguate only duplicate ids and preserve authored labels.
             const used = new Set();
             const reserved = new Set(chart.data.columns.map((column) => String(column[0])));
             const names = {};
@@ -459,8 +439,6 @@ const renderChart = async (message, root) => {
             if (Object.keys(colors).length)
                 chart.data.colors = colors;
         }
-        // Billboard resets the bind target's position to relative. Keep DrawingML
-        // placement on the outer frame; only let the library own its inner surface.
         const surface = chartTarget.ownerDocument.createElement('div');
         surface.className = 'pptx-chart-surface';
         surface.style.cssText = 'width:100%;height:100%;min-width:0;min-height:0;flex:1 1 auto';
@@ -471,10 +449,6 @@ const renderChart = async (message, root) => {
         const textPlugin = createPptxChartTextPlugin(surface);
         if (textPlugin)
             chart.plugins = [...(chart.plugins || []), textPlugin];
-        // DrawingML fixes the chart's size in slide coordinates. Billboard's
-        // automatic measurement uses transformed screen rectangles (or a visible
-        // ancestor for hidden slides), which applies presentation scaling twice.
-        // Keep fractional authored dimensions; the viewer scales the whole slide.
         const logicalSize = [((_u = chartTarget.style) === null || _u === void 0 ? void 0 : _u.width) || '', ((_v = chartTarget.style) === null || _v === void 0 ? void 0 : _v.height) || '']
             .map(value => /^\d+(?:\.\d+)?px$/.test(value) ? Number.parseFloat(value) : NaN);
         if (logicalSize.every(value => Number.isFinite(value) && value > 0)) {
@@ -538,7 +512,6 @@ export const renderPptxPostProcessing = async (charts, root) => {
                     (_a = chart.destroy) === null || _a === void 0 ? void 0 : _a.call(chart);
                 }
                 catch {
-                    // The DOM may already be detached during framework unmount.
                 }
             }
             chartInstances.length = 0;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { PptxViewer } from './viewer.js';
-export { PptxPresentation } from './presentation.js';
-export type { PptxPresentationLabels, PptxPresentationState } from './presentation.js';
-export { createPptxWorker, resolvePptxPackageWorkerUrl } from './worker.js';
-export { registerPptxChartLibraryLoader, registerPptxChartRenderer } from './chart.js';
-export type { PptxChartLibraries, PptxChartLibraryLoader } from './chart.js';
-export type { PptxChartType, PptxChartFont, PptxChartLabels, PptxChartOptions, PptxChartSeries, PptxChartAxis, PptxChartGroup, PptxChartModel, PptxChartMessage, PptxChartCollection, PptxChartRenderer, } from './chart-types.js';
-export { RECOMMENDED_ZIP_LIMITS, createDefaultPptxOptions, resolvePptxEngineOptions, } from './options.js';
-export type { NativePptxEngineOptions, PptxDiagnosticError, PptxDiagnosticErrorCode, PptxFitMode, PptxListOptions, PptxSlideSize, PptxViewerOptions, PptxWorkerFactoryOptions, PptxWorkerMessage, PptxZipLimits, } from './types.js';
+export { PptxViewer } from "./viewer.js";
+export { PptxPresentation } from "./presentation.js";
+export type { PptxPresentationLabels, PptxPresentationState } from "./presentation.js";
+export { createPptxWorker, resolvePptxPackageWorkerUrl } from "./worker.js";
+export { registerPptxChartLibraryLoader, registerPptxChartRenderer } from "./chart.js";
+export type { PptxChartLibraries, PptxChartLibraryLoader } from "./chart.js";
+export type { PptxChartType, PptxChartFont, PptxChartLabels, PptxChartOptions, PptxChartSeries, PptxChartAxis, PptxChartGroup, PptxChartModel, PptxChartMessage, PptxChartCollection, PptxChartRenderer, } from "./chart-types.js";
+export { RECOMMENDED_ZIP_LIMITS, createDefaultPptxOptions, resolvePptxEngineOptions, } from "./options.js";
+export type { NativePptxEngineOptions, PptxDiagnosticError, PptxDiagnosticErrorCode, PptxFitMode, PptxListOptions, PptxSlideSize, PptxViewerOptions, PptxWorkerFactoryOptions, PptxWorkerMessage, PptxZipLimits, } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
-export { PptxViewer } from './viewer.js';
-export { PptxPresentation } from './presentation.js';
-export { createPptxWorker, resolvePptxPackageWorkerUrl } from './worker.js';
-export { registerPptxChartLibraryLoader, registerPptxChartRenderer } from './chart.js';
-export { RECOMMENDED_ZIP_LIMITS, createDefaultPptxOptions, resolvePptxEngineOptions, } from './options.js';
+export { PptxViewer } from "./viewer.js";
+export { PptxPresentation } from "./presentation.js";
+export { createPptxWorker, resolvePptxPackageWorkerUrl } from "./worker.js";
+export { registerPptxChartLibraryLoader, registerPptxChartRenderer } from "./chart.js";
+export { RECOMMENDED_ZIP_LIMITS, createDefaultPptxOptions, resolvePptxEngineOptions, } from "./options.js";

package/dist/options.d.ts

@@ -1,4 +1,4 @@
-import type { NativePptxEngineOptions, PptxZipLimits } from './types.js';
+import type { NativePptxEngineOptions, PptxZipLimits } from "./types.js";
 export declare const RECOMMENDED_ZIP_LIMITS: Required<PptxZipLimits>;
 export declare const createDefaultPptxOptions: () => NativePptxEngineOptions;
 export declare const resolvePptxEngineOptions: (options?: Partial<NativePptxEngineOptions>) => NativePptxEngineOptions;

package/dist/presentation.d.ts

@@ -1,4 +1,4 @@
-import type { PptxViewer } from './viewer.js';
+import type { PptxViewer } from "./viewer.js";
 export interface PptxPresentationState {
     active: boolean;
     slideNumber: number;
@@ -10,14 +10,6 @@ export interface PptxPresentationLabels {
     next?: string;
     previous?: string;
 }
-/**
- * Full-screen slideshow for a rendered PPTX deck.
- *
- * The slides stay where the viewer put them: the whole scale box is moved into an overlay and the
- * inactive slots are hidden with CSS, so the engine's scoped `.flyfish-pptx-content .slide` rules
- * keep applying and no node is cloned. A placeholder marks the original position so exiting puts
- * everything back exactly where it was.
- */
 export declare class PptxPresentation {
     private readonly viewer;
     private readonly labels;
@@ -40,21 +32,10 @@ export declare class PptxPresentation {
     goTo(slideNumber: number): void;
     next(): void;
     previous(): void;
-    /** Scale the active slide to fit the overlay, letterboxing whichever axis has slack. */
     layout(): void;
     destroy(): void;
     private slots;
-    /**
-     * The nodes the slideshow toggles between. Windowed decks wrap each slide in a
-     * slot; the default (non-windowed) deck appends slides directly to the content
-     * node, so those are the containers there.
-     */
     private slideContainers;
-    /**
-     * Chromium reports the fullscreen element of a shadow root on the shadow root
-     * itself while document.fullscreenElement stays on the host, so both have to
-     * be checked before deciding who owns fullscreen.
-     */
     private isFullscreenElement;
     private scheduleLayout;
     private notify;

package/dist/presentation.js

@@ -1,12 +1,4 @@
 const clamp = (value, min, max) => Math.min(Math.max(value, min), max);
-/**
- * Full-screen slideshow for a rendered PPTX deck.
- *
- * The slides stay where the viewer put them: the whole scale box is moved into an overlay and the
- * inactive slots are hidden with CSS, so the engine's scoped `.flyfish-pptx-content .slide` rules
- * keep applying and no node is cloned. A placeholder marks the original position so exiting puts
- * everything back exactly where it was.
- */
 export class PptxPresentation {
     constructor(viewer, labels = {}, fullscreen = true) {
         this.overlay = null;
@@ -62,11 +54,8 @@ export class PptxPresentation {
         this.overlay = overlay;
         this.stage = stage;
         this.counter = counter;
-        // Keep the overlay inside whichever root holds the slide styles, or the engine's scoped CSS
-        // would not reach the slides once they move.
         const styleRoot = this.viewer.presentationRoot;
         styleRoot.appendChild(overlay);
-        // Park a comment where the scale box lived so exit() can restore the exact position.
         this.placeholder = documentRef.createComment('flyfish-pptx-presentation');
         this.viewer.saveScrollPosition();
         this.viewer.scaleBox.replaceWith(this.placeholder);
@@ -80,13 +69,9 @@ export class PptxPresentation {
                 this.ownsFullscreen = this.isFullscreenElement(overlay);
             }
             catch {
-                // Fullscreen needs a user gesture and can be blocked by permissions policy. The overlay is
-                // position:fixed, so the slideshow still fills the viewport without it.
                 this.ownsFullscreen = false;
             }
         }
-        // exit() may have run while fullscreen was being requested. Leave the
-        // browser out of fullscreen rather than stranded with no overlay.
         if (this.overlay !== overlay) {
             if (this.ownsFullscreen) {
                 void ((_b = documentRef.exitFullscreen) === null || _b === void 0 ? void 0 : _b.call(documentRef).catch(() => undefined));
@@ -105,8 +90,6 @@ export class PptxPresentation {
             return;
         }
         const documentRef = this.viewer.target.ownerDocument || document;
-        // Capture before the overlay leaves the DOM: a detached node's getRootNode()
-        // is the document, so the fullscreen check would fail after removal.
         const shouldExitFullscreen = this.ownsFullscreen && this.isFullscreenElement(overlay);
         this.detach();
         if (this.layoutFrame) {
@@ -149,11 +132,8 @@ export class PptxPresentation {
         }
         this.current = clamp(Math.round(slideNumber) || 1, 1, total);
         this.viewer.ensureSlideRendered(this.current);
-        // Rendering the neighbour keeps the next step instant without defeating virtualization.
         this.viewer.ensureSlideRendered(this.current + 1);
         const containers = this.slideContainers();
-        // Windowed decks tag each slot with its slide number; non-windowed decks
-        // append slides in order, so the active one is found by index.
         const byNumber = containers.some(container => Boolean(container.dataset.slideNumber));
         containers.forEach((container, index) => {
             const isActive = byNumber
@@ -179,7 +159,6 @@ export class PptxPresentation {
             this.goTo(this.current - 1);
         }
     }
-    /** Scale the active slide to fit the overlay, letterboxing whichever axis has slack. */
     layout() {
         const overlay = this.overlay;
         if (!overlay) {
@@ -191,7 +170,6 @@ export class PptxPresentation {
             }
             return index === this.current - 1;
         });
-        // Windowed decks wrap the slide in a slot; non-windowed decks are the slide.
         const slide = container && container.classList.contains('flyfish-pptx-slide-slot')
             ? container.firstElementChild
             : container;
@@ -220,11 +198,6 @@ export class PptxPresentation {
     slots() {
         return Array.from(this.viewer.content.querySelectorAll(':scope > .flyfish-pptx-slide-slot'));
     }
-    /**
-     * The nodes the slideshow toggles between. Windowed decks wrap each slide in a
-     * slot; the default (non-windowed) deck appends slides directly to the content
-     * node, so those are the containers there.
-     */
     slideContainers() {
         const slots = this.slots();
         if (slots.length > 0) {
@@ -232,11 +205,6 @@ export class PptxPresentation {
         }
         return Array.from(this.viewer.content.querySelectorAll(':scope > .slide'));
     }
-    /**
-     * Chromium reports the fullscreen element of a shadow root on the shadow root
-     * itself while document.fullscreenElement stays on the host, so both have to
-     * be checked before deciding who owns fullscreen.
-     */
     isFullscreenElement(overlay) {
         const documentRef = this.viewer.target.ownerDocument || document;
         if (documentRef.fullscreenElement === overlay) {
@@ -275,8 +243,6 @@ export class PptxPresentation {
         });
         this.on(view, 'resize', () => this.scheduleLayout());
         this.on(documentRef, 'fullscreenchange', () => {
-            // Leaving fullscreen with the browser's own Esc must close the slideshow too, otherwise the
-            // overlay would stay up as a plain fixed layer.
             if (this.ownsFullscreen && !this.isFullscreenElement(overlay)) {
                 this.ownsFullscreen = false;
                 this.exit();
@@ -295,7 +261,6 @@ export class PptxPresentation {
         if (!overlay || ((_a = event.target) === null || _a === void 0 ? void 0 : _a.closest('.flyfish-pptx-presentation-exit'))) {
             return;
         }
-        // PowerPoint advances on click; the left edge is the only place that goes back.
         const bounds = overlay.getBoundingClientRect();
         const ratio = (event.clientX - bounds.left) / (bounds.width || 1);
         if (ratio < 0.2) {
@@ -309,16 +274,12 @@ export class PptxPresentation {
         if (!this.active || event.altKey || event.metaKey || event.ctrlKey) {
             return;
         }
-        // Enter/Space on a focused control (the exit button) must activate that
-        // control, not advance the slide. Let the browser's default run instead.
         const target = event.target;
         if (target &&
             typeof target.closest === 'function' &&
             target.closest('button, a, input, textarea, select, [contenteditable="true"], [contenteditable=""]')) {
             return;
         }
-        // With two slideshows open, a key pressed inside the other overlay belongs
-        // to that overlay; only the focused one advances.
         if (target && typeof target.closest === 'function') {
             const otherOverlay = target.closest('.flyfish-pptx-presentation');
             if (otherOverlay && otherOverlay !== this.overlay) {

package/dist/styles.d.ts

@@ -1,8 +1,3 @@
-/**
- * The legacy engine emits class-only selector lists. Prefix each top-level
- * class rule so light-DOM consumers do not inherit generic `.slide` or
- * generated `._css_*` rules from a renderer-local style element.
- */
 export declare const scopePptxContentStyleText: (cssText: string) => string;
 export declare const pptxViewerCss: string;
 export declare const ensurePptxViewerStyles: (documentRef: Document, root?: Document | ShadowRoot) => void;

package/dist/styles.js

@@ -51,11 +51,6 @@ const legacyPptxCss = `
 
 `;
 const PPTX_CONTENT_STYLE_SCOPE = '.flyfish-pptx-content';
-/**
- * The legacy engine emits class-only selector lists. Prefix each top-level
- * class rule so light-DOM consumers do not inherit generic `.slide` or
- * generated `._css_*` rules from a renderer-local style element.
- */
 export const scopePptxContentStyleText = (cssText) => cssText.replace(/(^|})\s*(\.[^{}]+)\{/g, (_match, boundary, selectorList) => {
     const scopedSelectors = selectorList
         .split(',')

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import type { PptxPresentationLabels, PptxPresentationState } from './presentation.js';
-import type { PptxChartCollection } from './chart-types.js';
+import type { PptxPresentationLabels, PptxPresentationState } from "./presentation.js";
+import type { PptxChartCollection } from "./chart-types.js";
 export type PptxFitMode = 'contain' | 'none';
 export interface PptxZipLimits {
     maxFileBytes?: number;

package/dist/viewer.d.ts

@@ -1,5 +1,5 @@
-import type { PptxPresentationState } from './presentation.js';
-import type { PptxViewerOptions } from './types.js';
+import type { PptxPresentationState } from "./presentation.js";
+import type { PptxViewerOptions } from "./types.js";
 export declare class PptxViewer {
     static open(buffer: ArrayBuffer, target: HTMLElement, options?: PptxViewerOptions): Promise<PptxViewer>;
     readonly target: HTMLElement;
@@ -41,19 +41,9 @@ export declare class PptxViewer {
     get presenting(): boolean;
     get presentationSlideNumber(): number;
     private get styleRoot();
-    /**
-     * Where the slideshow overlay is mounted. It has to share a root with the injected slide styles,
-     * or the engine's scoped CSS stops applying once the slides move into the overlay.
-     */
     get presentationRoot(): ShadowRoot | HTMLElement;
-    /** Force a slide out of the virtualized window so the slideshow can show it immediately. */
     ensureSlideRendered(slideNumber: number): Element | null;
     refreshLayout(): void;
-    /**
-     * Remember where the deck was scrolled before the slideshow moves the scale
-     * box into the overlay. Moving it collapses the scroller and clamps scrollTop
-     * to zero, so the position has to be captured up front and restored on exit.
-     */
     saveScrollPosition(): void;
     restoreScrollPosition(): void;
     emitPresentationChange(state: PptxPresentationState): void;
@@ -89,7 +79,6 @@ export declare class PptxViewer {
     private findSlideWindowTarget;
     private postProcessRenderedContent;
     private postProcessSlideRecord;
-    /** Materializes every lazy slide only for the duration of an export snapshot. */
     cloneForExport(): Promise<HTMLElement>;
     private complete;
     private fail;

package/dist/viewer.js

@@ -1,9 +1,9 @@
-import { renderPptxPostProcessing } from './chart.js';
-import { resolvePptxEngineOptions, RECOMMENDED_ZIP_LIMITS } from './options.js';
-import { PptxPresentation } from './presentation.js';
-import { sanitizePptxCss, sanitizePptxMarkup } from './sanitize.js';
-import { ensurePptxViewerStyles } from './styles.js';
-import { createPptxWorker } from './worker.js';
+import { renderPptxPostProcessing } from "./chart.js";
+import { resolvePptxEngineOptions, RECOMMENDED_ZIP_LIMITS } from "./options.js";
+import { PptxPresentation } from "./presentation.js";
+import { sanitizePptxCss, sanitizePptxMarkup } from "./sanitize.js";
+import { ensurePptxViewerStyles } from "./styles.js";
+import { createPptxWorker } from "./worker.js";
 const clamp = (value, min, max) => {
     return Math.min(max, Math.max(min, value));
 };
@@ -97,10 +97,6 @@ export class PptxViewer {
         this.previewThumbnailDataUrl = null;
         this.slideSize = null;
         this.slideRecords = [];
-        // Total slides received from the worker. The windowed path mirrors this in
-        // slideRecords, but the default (non-windowed) path appends slides straight
-        // into the content node without creating records, so the deck size has to be
-        // counted independently of the virtualization bookkeeping.
         this.totalSlides = 0;
         this.savedScroll = null;
         this.pendingScrollRestore = null;
@@ -164,10 +160,6 @@ export class PptxViewer {
             ? root
             : documentRef;
     }
-    /**
-     * Where the slideshow overlay is mounted. It has to share a root with the injected slide styles,
-     * or the engine's scoped CSS stops applying once the slides move into the overlay.
-     */
     get presentationRoot() {
         const documentRef = this.target.ownerDocument || document;
         const styleRoot = this.styleRoot;
@@ -176,7 +168,6 @@ export class PptxViewer {
         }
         return documentRef.body || documentRef.documentElement;
     }
-    /** Force a slide out of the virtualized window so the slideshow can show it immediately. */
     ensureSlideRendered(slideNumber) {
         const record = this.slideRecords.find(item => item.slideNumber === slideNumber);
         if (!record) {
@@ -190,11 +181,6 @@ export class PptxViewer {
     refreshLayout() {
         this.scheduleResize();
     }
-    /**
-     * Remember where the deck was scrolled before the slideshow moves the scale
-     * box into the overlay. Moving it collapses the scroller and clamps scrollTop
-     * to zero, so the position has to be captured up front and restored on exit.
-     */
     saveScrollPosition() {
         const view = this.target.ownerDocument.defaultView || window;
         const HTMLElementCtor = view.HTMLElement;
@@ -536,9 +522,6 @@ export class PptxViewer {
         }
         const windowOptions = this.getSlideWindowOptions();
         const indexesToRender = this.getWindowedSlideIndexes(windowOptions);
-        // While presenting, the active slide and its neighbour live inside the fixed
-        // overlay, outside the scroll-view geometry the windowing code measures. Keep
-        // them mounted so a resize cannot unmount the slide that is on screen.
         const presentation = this.presentation;
         if (presentation === null || presentation === void 0 ? void 0 : presentation.active) {
             const activeIndex = this.slideRecords.findIndex(record => record.slideNumber === presentation.slideNumber);
@@ -711,7 +694,6 @@ export class PptxViewer {
         }
         await record.postProcessPromise;
     }
-    /** Materializes every lazy slide only for the duration of an export snapshot. */
     async cloneForExport() {
         if (!this.shouldWindowSlides()) {
             return this.target.cloneNode(true);
@@ -878,7 +860,6 @@ export class PptxViewer {
     }
     resize() {
         var _a, _b, _c;
-        // While presenting, the slideshow owns the transform of the same nodes.
         if ((_a = this.presentation) === null || _a === void 0 ? void 0 : _a.active) {
             this.presentation.layout();
             return;
@@ -901,8 +882,6 @@ export class PptxViewer {
         this.scaleBox.style.width = `${Math.ceil(slideWidth * effectiveScale)}px`;
         this.scaleBox.style.height = `${Math.ceil(this.content.scrollHeight * effectiveScale)}px`;
         this.scaleBox.style.minHeight = '';
-        // The scale box height is recomputed above; only now can the saved scroll
-        // position be applied without the scroller clamping it back to zero.
         if (this.pendingScrollRestore) {
             const { top, left } = this.pendingScrollRestore;
             this.pendingScrollRestore = null;

package/dist/worker-location.d.ts

@@ -1,2 +1 @@
-/** Distinguish an emitted asset from an untouched dependency-relative URL. */
 export declare const isResolvedPptxWorkerLocation: (moduleUrl: URL, assetUrl: URL) => boolean;

package/dist/worker-location.js

@@ -1,7 +1,4 @@
-/** Distinguish an emitted asset from an untouched dependency-relative URL. */
 export const isResolvedPptxWorkerLocation = (moduleUrl, assetUrl) => {
-    // Keep the comparison URL dynamic: a bundler must only rewrite the static
-    // new URL reference in worker.ts, not both sides of this comparison.
     const relativePath = ['worker', 'pptx.worker.js'].join('/');
     const dependencyRelativeUrl = new URL(relativePath, moduleUrl);
     return assetUrl.href !== dependencyRelativeUrl.href || /\/dist\/worker\.[cm]?js$/.test(moduleUrl.pathname);

package/dist/worker.d.ts

@@ -1,4 +1,3 @@
-import type { PptxWorkerFactoryOptions } from './types.js';
-/** Returns only a Worker URL that the active bundler has emitted or serves directly. */
+import type { PptxWorkerFactoryOptions } from "./types.js";
 export declare const resolvePptxPackageWorkerUrl: () => string | undefined;
 export declare const createPptxWorker: (options?: PptxWorkerFactoryOptions) => Worker;

package/dist/worker.js

@@ -1,14 +1,10 @@
-import { isResolvedPptxWorkerLocation } from './worker-location.js';
+import { isResolvedPptxWorkerLocation } from "./worker-location.js";
 const viteOptimizedWorkerPathPattern = /\/\.?vite\/deps\/worker\/pptx\.worker\.js$/;
 const viteSourceWorkerModulePattern = /\/src\/worker\.[cm]?[jt]s$/;
 const angularCachePath = '/.angular/cache/';
 const viteOptimizedPptxSourcePattern = /\/\/\s+(node_modules\/(?:\.pnpm\/[^\n]+?\/node_modules\/)?@file-viewer\/pptx\/dist\/worker\.js)\b/;
 const resolveBundledPptxWorkerUrl = () => {
     const moduleUrl = new URL(import.meta.url);
-    // Workspace demos and source-linked consumer projects let Vite serve this
-    // TypeScript module directly from /@fs/.../src/worker.ts. The built Worker
-    // remains under dist/worker, so resolving ./worker from the source module
-    // points at a directory that does not exist.
     if (viteSourceWorkerModulePattern.test(moduleUrl.pathname)) {
         return new URL('../dist/worker/pptx.worker.js', moduleUrl);
     }
@@ -31,8 +27,6 @@ const resolveViteOptimizedPptxWorkerUrl = (defaultPptxWorkerUrl) => {
     }
     try {
         const request = new XMLHttpRequest();
-        // Vite dev-only fallback: inspect the optimized module to recover the real
-        // package path when @file-viewer/pptx is only a transitive pnpm dependency.
         request.open('GET', import.meta.url, false);
         request.send(null);
         if ((request.status > 0 && request.status < 200) || request.status >= 400) {
@@ -66,17 +60,12 @@ const resolvePptxWorkerUrl = (allowDependencyRelativeUrl) => {
             const optimizedUrl = resolveViteOptimizedPptxWorkerUrl(workerUrl);
             return optimizedUrl ? String(optimizedUrl) : undefined;
         }
-        // An untouched dependency-relative URL points below the application bundle,
-        // not this package. Renderers with copied-asset discovery must not select it.
         return allowDependencyRelativeUrl ? workerUrl.href : undefined;
     }
     catch {
-        // An inlined module without a resolvable package base can still use the
-        // host's standard copied assets or an explicitly configured Worker URL.
     }
     return undefined;
 };
-/** Returns only a Worker URL that the active bundler has emitted or serves directly. */
 export const resolvePptxPackageWorkerUrl = () => {
     return resolvePptxWorkerUrl(false);
 };
@@ -90,7 +79,6 @@ export const createPptxWorker = (options = {}) => {
             type: (_a = options.workerType) !== null && _a !== void 0 ? _a : 'module',
         });
     }
-    // Direct PptxViewer users have no renderer-level copied-asset discovery.
     const workerUrl = resolvePptxWorkerUrl(true);
     if (!workerUrl) {
         throw new Error('PPTX Worker URL is unavailable. Run file-viewer-copy-assets or provide workerUrl.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/pptx",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "private": false,
   "type": "module",
   "description": "Native PPTX renderer extracted from File Viewer",