@a3s-lab/office 0.1.0

package/dist/0~work-pptx-import.js

@@ -0,0 +1,1138 @@
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, firstDescendant, descendants, directChild, childPath, attribute } from "./8715.js";
+import { normalizeRadarStyle, normalizePresentationChartLegendPosition, presentationChartUsesNumericXAxis, normalizePresentationBubbleScale, normalizePresentationBubbleSizeRepresents, withPresentationChartLayout, normalizeDoughnutHoleSize, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
+import { loadPptxCommentAuthors, readPptxSlideComments, readPptxChartLayoutAndSeriesStyles, readPptxTransition, readPptxChartSeriesAnalysis, readPptxChartDataLabels } from "./0~7614.js";
+import { parseXlsxChartAxes } from "./4104.js";
+import { createOfficeId as createWorkId } from "./1134.js";
+import { scaledPresentationVisuals } from "./0~work-presentation-visual-scale.js";
+async function loadPptxTheme(archive, presentationRelationships) {
+    const defaults = {
+        dk1: '#000000',
+        lt1: '#ffffff',
+        dk2: '#1f497d',
+        lt2: '#eeece1',
+        accent1: '#4472c4',
+        accent2: '#ed7d31',
+        accent3: '#a5a5a5',
+        accent4: '#ffc000',
+        accent5: '#5b9bd5',
+        accent6: '#70ad47',
+        hlink: '#0563c1',
+        folHlink: '#954f72',
+        tx1: '#000000',
+        tx2: '#1f497d',
+        bg1: '#ffffff',
+        bg2: '#eeece1'
+    };
+    const masterRelationship = Array.from(presentationRelationships.values()).find((item)=>item.type.endsWith('/slideMaster'));
+    if (!masterRelationship || !archive.has(masterRelationship.target)) return defaults;
+    const masterRelationships = await archive.relationships(masterRelationship.target);
+    const themeRelationship = Array.from(masterRelationships.values()).find((item)=>item.type.endsWith('/theme'));
+    if (!themeRelationship || !archive.has(themeRelationship.target)) return defaults;
+    const document1 = await archive.xml(themeRelationship.target);
+    const colorScheme = firstDescendant(document1, 'clrScheme');
+    if (!colorScheme) return defaults;
+    for (const slot of directChildren(colorScheme)){
+        const color = drawingColor(slot, defaults);
+        if (color) defaults[slot.localName] = color.color;
+    }
+    return defaults;
+}
+function readPptxBackground(document1, theme) {
+    const background = firstDescendant(document1, 'bg');
+    if (!background) return;
+    return readPptxFill(background, theme, '#ffffff').color;
+}
+function readPptxFill(container, theme, fallback) {
+    if (!container) return {
+        color: fallback
+    };
+    if (firstDescendant(container, 'noFill')) return {
+        color: 'transparent'
+    };
+    const solidFill = firstDescendant(container, 'solidFill');
+    const color = drawingColor(solidFill ?? container, theme);
+    return color ?? {
+        color: fallback
+    };
+}
+function supportedPptxShapeType(value) {
+    const shapes = {
+        rect: 'rect',
+        roundRect: 'roundRect',
+        ellipse: 'ellipse',
+        triangle: 'triangle',
+        rtTriangle: 'triangle',
+        diamond: 'diamond',
+        line: 'line'
+    };
+    return shapes[value];
+}
+function pptxTextAlignment(value) {
+    if ('ctr' === value) return 'center';
+    if ('r' === value) return 'right';
+    return 'left';
+}
+function pptxVerticalAlignment(value) {
+    if ('ctr' === value) return 'middle';
+    if ('b' === value) return 'bottom';
+    return 'top';
+}
+function drawingColor(container, theme) {
+    const colorNames = [
+        'srgbClr',
+        'scrgbClr',
+        'sysClr',
+        'schemeClr',
+        'prstClr'
+    ];
+    const colorNode = directChildren(container).find((node)=>colorNames.includes(node.localName)) ?? colorNames.map((name)=>firstDescendant(container, name)).find(Boolean);
+    if (!colorNode) return;
+    let color;
+    if ('srgbClr' === colorNode.localName) color = normalizeColor(attribute(colorNode, 'val'));
+    else if ('sysClr' === colorNode.localName) color = normalizeColor(attribute(colorNode, 'lastClr'));
+    else if ('schemeClr' === colorNode.localName) color = theme[attribute(colorNode, 'val') ?? ''];
+    else if ('prstClr' === colorNode.localName) color = presetColor(attribute(colorNode, 'val'));
+    else {
+        const red = numberAttribute(colorNode, 'r', 0) / 100000 * 255;
+        const green = numberAttribute(colorNode, 'g', 0) / 100000 * 255;
+        const blue = numberAttribute(colorNode, 'b', 0) / 100000 * 255;
+        color = rgbToHex(red, green, blue);
+    }
+    if (!color) return;
+    const tint = numberAttribute(firstDescendant(colorNode, 'tint'), 'val', 0) / 100000;
+    const shadeNode = firstDescendant(colorNode, 'shade');
+    const shade = shadeNode ? numberAttribute(shadeNode, 'val', 100000) / 100000 : 1;
+    color = modifyColor(color, tint, shade);
+    const alphaNode = firstDescendant(colorNode, 'alpha');
+    return {
+        color,
+        opacity: alphaNode ? numberAttribute(alphaNode, 'val', 100000) / 100000 : void 0
+    };
+}
+function normalizeColor(value) {
+    if (!value) return;
+    const normalized = value.replace(/^#/, '');
+    return /^[0-9a-f]{6}$/i.test(normalized) ? `#${normalized.toLowerCase()}` : void 0;
+}
+function presetColor(value) {
+    const colors = {
+        black: '#000000',
+        white: '#ffffff',
+        red: '#ff0000',
+        green: '#008000',
+        blue: '#0000ff',
+        yellow: '#ffff00',
+        orange: '#ffa500',
+        purple: '#800080',
+        gray: '#808080',
+        grey: '#808080'
+    };
+    return value ? colors[value] : void 0;
+}
+function modifyColor(color, tint, shade) {
+    const red = Number.parseInt(color.slice(1, 3), 16);
+    const green = Number.parseInt(color.slice(3, 5), 16);
+    const blue = Number.parseInt(color.slice(5, 7), 16);
+    return rgbToHex((red + (255 - red) * tint) * shade, (green + (255 - green) * tint) * shade, (blue + (255 - blue) * tint) * shade);
+}
+function rgbToHex(red, green, blue) {
+    return `#${[
+        red,
+        green,
+        blue
+    ].map((value)=>Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, '0')).join('')}`;
+}
+function numberAttribute(element, name, fallback) {
+    if (!element) return fallback;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : fallback;
+}
+async function loadPptxSlideInheritance(archive, slideRelationships, theme) {
+    const layoutRelationship = Array.from(slideRelationships.values()).find((item)=>item.type.endsWith('/slideLayout'));
+    const layout = layoutRelationship ? await loadPptxDesignPart(archive, layoutRelationship.target, theme, 'Slide layout') : void 0;
+    const masterRelationship = layout ? Array.from(layout.relationships.values()).find((item)=>item.type.endsWith('/slideMaster')) : void 0;
+    const master = masterRelationship ? await loadPptxDesignPart(archive, masterRelationship.target, theme, 'Slide master') : void 0;
+    const placeholders = new Map();
+    for (const part of [
+        master,
+        layout
+    ])if (part) for (const shape of descendants(part.document, 'sp')){
+        const box = pptxRawElementBox(shape);
+        const placeholder = pptxPlaceholder(shape);
+        if (box && placeholder) {
+            placeholders.set(placeholder.key, box);
+            placeholders.set(`type:${placeholder.type}`, box);
+        }
+    }
+    return {
+        layout,
+        master,
+        placeholders
+    };
+}
+function pptxRawElementBox(node) {
+    const xfrm = 'graphicFrame' === node.localName ? directChild(node, 'xfrm') : 'grpSp' === node.localName ? childPath(node, 'grpSpPr', 'xfrm') : childPath(node, 'spPr', 'xfrm');
+    if (!xfrm) return;
+    const offset = directChild(xfrm, 'off');
+    const extent = directChild(xfrm, 'ext');
+    if (!offset || !extent) return;
+    return {
+        x: work_pptx_layout_import_numberAttribute(offset, 'x', 0),
+        y: work_pptx_layout_import_numberAttribute(offset, 'y', 0),
+        width: Math.abs(work_pptx_layout_import_numberAttribute(extent, 'cx', 0)),
+        height: Math.abs(work_pptx_layout_import_numberAttribute(extent, 'cy', 0)),
+        rotation: work_pptx_layout_import_numberAttribute(xfrm, 'rot', 0) / 60000 || void 0
+    };
+}
+function pptxPlaceholderBox(node, placeholders) {
+    const placeholder = pptxPlaceholder(node);
+    if (!placeholder) return;
+    return placeholders.get(placeholder.key) ?? placeholders.get(`type:${placeholder.type}`);
+}
+function pptxPlaceholder(node) {
+    const placeholder = firstDescendant(node, 'ph');
+    if (!placeholder) return;
+    const index = attribute(placeholder, 'idx')?.trim();
+    const type = attribute(placeholder, 'type')?.trim() || 'body';
+    return {
+        key: index ? `idx:${index}` : `type:${type}`,
+        type
+    };
+}
+function pptxShowsMasterElements(document1) {
+    const value = attribute(document1.documentElement, 'showMasterSp');
+    return '0' !== value && 'false' !== value;
+}
+async function loadPptxDesignPart(archive, path, theme, fallbackName) {
+    if (!archive.has(path)) return;
+    const document1 = await archive.xml(path);
+    const commonSlideData = directChild(document1.documentElement, 'cSld');
+    return {
+        path,
+        document: document1,
+        relationships: await archive.relationships(path),
+        name: attribute(commonSlideData ?? document1.documentElement, 'name')?.trim() || `${fallbackName} ${partNumber(path)}`,
+        background: readPptxBackground(document1, theme),
+        showMasterElements: pptxShowsMasterElements(document1),
+        sourceType: attribute(document1.documentElement, 'type')?.trim() || void 0
+    };
+}
+function partNumber(path) {
+    return /(\d+)(?:\.xml)?$/i.exec(path)?.[1] ?? '1';
+}
+function work_pptx_layout_import_numberAttribute(element, name, fallback) {
+    if (!element) return fallback;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : fallback;
+}
+function readPptxChartAxisDiagnostics(document1) {
+    const plotArea = firstDescendant(document1, 'plotArea');
+    if (!plotArea) return [];
+    const axes = directChildren(plotArea).filter((child)=>'catAx' === child.localName || 'valAx' === child.localName || 'dateAx' === child.localName);
+    const diagnostics = [];
+    if (axes.length > 2 || axes.some((axis)=>[
+            't',
+            'r'
+        ].includes(attribute(directChild(axis, 'axPos') ?? axis, 'val') ?? ''))) diagnostics.push({
+        code: 'pptx.chart.axis-secondary',
+        message: 'Secondary or additional chart axes were normalized to the editable primary horizontal and vertical axes.'
+    });
+    if (axes.some((axis)=>'dateAx' === axis.localName)) diagnostics.push({
+        code: 'pptx.chart.axis-date',
+        message: 'Date-axis units and calendar behavior were normalized to an editable category axis.'
+    });
+    if (axes.some((axis)=>directChild(directChild(axis, 'scaling') ?? axis, 'logBase'))) diagnostics.push({
+        code: 'pptx.chart.axis-logarithmic',
+        message: 'Logarithmic chart-axis scaling was normalized to the editable linear scale.'
+    });
+    if (axes.some((axis)=>directChild(axis, 'minorUnit'))) diagnostics.push({
+        code: 'pptx.chart.axis-minor-unit',
+        message: 'Minor chart-axis units were normalized because only the primary unit is editable.'
+    });
+    if (axes.some((axis)=>directChild(axis, 'dispUnits'))) diagnostics.push({
+        code: 'pptx.chart.axis-display-units',
+        message: 'Chart-axis display units were flattened into the editable number format.'
+    });
+    if (axes.some((axis)=>directChild(axis, 'minorGridlines') || directChild(axis, 'minorTickMark') || directChild(axis, 'tickMarkSkip'))) diagnostics.push({
+        code: 'pptx.chart.axis-minor-display',
+        message: 'Minor gridlines, minor tick marks, or tick-mark intervals were normalized to primary-axis settings.'
+    });
+    if (axes.some((axis)=>directChild(axis, 'crossesAt'))) diagnostics.push({
+        code: 'pptx.chart.axis-crossing',
+        message: 'Custom chart-axis crossing points were normalized to automatic crossing.'
+    });
+    return diagnostics;
+}
+function readPptxChart(document1) {
+    const diagnostics = [];
+    const chartTypes = [
+        'barChart',
+        'lineChart',
+        'pieChart',
+        'doughnutChart',
+        'areaChart',
+        'radarChart',
+        'scatterChart',
+        'bubbleChart'
+    ];
+    const chartNode = chartTypes.map((name)=>firstDescendant(document1, name)).find(Boolean);
+    if (!chartNode) diagnostics.push({
+        code: 'pptx.chart.type',
+        feature: 'Charts',
+        message: 'This chart type is shown as a basic column chart and will be normalized on export.'
+    });
+    const localName = chartNode?.localName;
+    const barDirection = attribute(firstDescendant(chartNode, 'barDir') ?? document1.documentElement, 'val');
+    const type = 'scatterChart' === localName ? 'scatter' : 'bubbleChart' === localName ? 'bubble' : 'lineChart' === localName ? 'line' : 'pieChart' === localName ? 'pie' : 'doughnutChart' === localName ? 'doughnut' : 'radarChart' === localName ? 'radar' : 'areaChart' === localName ? 'area' : 'bar' === barDirection ? 'bar' : 'column';
+    const numericXAxis = presentationChartUsesNumericXAxis(type);
+    const seriesNodes = chartNode ? directChildren(chartNode, 'ser') : descendants(document1, 'ser');
+    const formatting = readPptxChartLayoutAndSeriesStyles(document1, chartNode, type, seriesNodes);
+    const xValues = seriesNodes.map((node)=>cachedValues(directChild(node, 'xVal')).map(finiteNumber));
+    const seriesAnalysis = seriesNodes.map((node)=>readPptxChartSeriesAnalysis(node, type));
+    const series = seriesNodes.map((node, index)=>({
+            name: cachedValues(directChild(node, 'tx'))[0] ?? `Series ${index + 1}`,
+            values: cachedValues(directChild(node, numericXAxis ? 'yVal' : 'val')).map(finiteNumber),
+            ...'bubble' === type ? {
+                bubbleSizes: cachedValues(directChild(node, 'bubbleSize')).map(finiteNumber)
+            } : {},
+            ...seriesAnalysis[index]?.trendlines ? {
+                trendlines: seriesAnalysis[index].trendlines
+            } : {},
+            ...seriesAnalysis[index]?.errorBars ? {
+                errorBars: seriesAnalysis[index].errorBars
+            } : {},
+            ...formatting.seriesStyles[index] ? {
+                style: formatting.seriesStyles[index]
+            } : {}
+        }));
+    diagnostics.push(...seriesAnalysis.flatMap((result)=>result.diagnostics.map((diagnostic)=>({
+                ...diagnostic,
+                feature: 'Chart series analysis'
+            }))));
+    const categories = numericXAxis ? (xValues[0] ?? []).map((value)=>String(value)) : cachedValues(directChild(seriesNodes[0] ?? document1.documentElement, 'cat'));
+    if (numericXAxis && new Set(xValues.map((values)=>values.join('|'))).size > 1) diagnostics.push({
+        code: 'pptx.chart.xy-values',
+        feature: 'XY chart data',
+        message: 'Different per-series X values were normalized to the first series shared X-value list.'
+    });
+    const chartRoot = firstDescendant(document1, 'chart');
+    const legend = directChild(chartRoot ?? document1.documentElement, 'legend');
+    const title = chartText(directChild(chartRoot ?? document1.documentElement, 'title'));
+    const axes = parseXlsxChartAxes(document1, type, false, true);
+    diagnostics.push(...readPptxChartAxisDiagnostics(document1).map((diagnostic)=>({
+            ...diagnostic,
+            feature: 'Chart axes'
+        })));
+    diagnostics.push(...formatting.diagnostics.map((diagnostic)=>({
+            ...diagnostic,
+            feature: 'Chart formatting'
+        })));
+    const chart = {
+        type,
+        title,
+        categories,
+        series,
+        showLegend: Boolean(legend),
+        ...legend ? {
+            legendPosition: pptxLegendPosition(legend)
+        } : {},
+        ...void 0 !== formatting.legendOverlay ? {
+            legendOverlay: formatting.legendOverlay
+        } : {},
+        ...formatting.layout,
+        ...axes ? {
+            axes
+        } : {}
+    };
+    const dataLabelResult = readPptxChartDataLabels(chartNode, type);
+    if (dataLabelResult.dataLabels) chart.dataLabels = dataLabelResult.dataLabels;
+    diagnostics.push(...dataLabelResult.diagnostics.map((diagnostic)=>({
+            ...diagnostic,
+            feature: 'Chart data labels'
+        })));
+    if ('doughnut' === type) readDoughnutSettings(chartNode, document1, chart, diagnostics);
+    if ('radar' === type) readRadarSettings(chartNode, document1, chart, diagnostics);
+    if ('scatter' === type) readScatterSettings(chartNode, chart, diagnostics);
+    if ('bubble' === type) readBubbleSettings(chartNode, chart, diagnostics);
+    return {
+        chart: withPresentationChartLayout(chart),
+        diagnostics
+    };
+}
+function pptxLegendPosition(legend) {
+    const value = attribute(directChild(legend, 'legendPos') ?? legend, 'val');
+    const position = 'l' === value ? 'left' : 't' === value ? 'top' : 'b' === value ? 'bottom' : 'tr' === value ? 'topRight' : 'right';
+    return normalizePresentationChartLegendPosition(position);
+}
+function chartText(node) {
+    if (!node) return;
+    const richText = descendants(node, 't').map((part)=>part.textContent ?? '').join('').trim();
+    if (richText) return richText;
+    const cachedText = descendants(node, 'v').map((part)=>part.textContent ?? '').join('').trim();
+    return cachedText || void 0;
+}
+function readDoughnutSettings(chartNode, document1, chart, diagnostics) {
+    const holeSize = firstDescendant(chartNode ?? document1.documentElement, 'holeSize');
+    const holeSizeValue = attribute(holeSize ?? document1.documentElement, 'val');
+    const rawHoleSize = null === holeSizeValue ? void 0 : Number(holeSizeValue);
+    chart.doughnutHoleSize = normalizeDoughnutHoleSize(rawHoleSize);
+    if (holeSize && (void 0 === rawHoleSize || !Number.isFinite(rawHoleSize) || rawHoleSize < 10 || rawHoleSize > 90)) diagnostics.push({
+        code: 'pptx.chart.doughnut-hole',
+        feature: 'Chart formatting',
+        message: 'The doughnut hole size was outside the editable 10–90% range and was normalized.'
+    });
+}
+function readRadarSettings(chartNode, document1, chart, diagnostics) {
+    const radarStyle = attribute(firstDescendant(chartNode ?? document1.documentElement, 'radarStyle') ?? chartNode ?? document1.documentElement, 'val');
+    chart.radarStyle = normalizeRadarStyle('standard' === radarStyle || 'marker' === radarStyle || 'filled' === radarStyle ? radarStyle : void 0);
+    if (radarStyle && ![
+        'standard',
+        'marker',
+        'filled'
+    ].includes(radarStyle)) diagnostics.push({
+        code: 'pptx.chart.radar-style',
+        feature: 'Chart formatting',
+        message: `The radar style “${radarStyle}” was normalized to the standard editable style.`
+    });
+}
+function readScatterSettings(chartNode, chart, diagnostics) {
+    if (!chartNode) return;
+    const rawStyle = attribute(directChild(chartNode, 'scatterStyle') ?? chartNode, 'val');
+    chart.scatterStyle = normalizePresentationScatterStyle(rawStyle);
+    if (rawStyle && ![
+        'marker',
+        'line',
+        'lineMarker',
+        'smooth',
+        'smoothMarker'
+    ].includes(rawStyle)) diagnostics.push({
+        code: 'pptx.chart.scatter-style',
+        feature: 'Chart formatting',
+        message: `The scatter style “${rawStyle}” was normalized to the editable line-and-marker style.`
+    });
+}
+function readBubbleSettings(chartNode, chart, diagnostics) {
+    if (!chartNode) return;
+    const source = chartNode;
+    const scaleElement = directChild(source, 'bubbleScale');
+    const rawScale = scaleElement ? Number(attribute(scaleElement, 'val')) : void 0;
+    chart.bubbleScale = normalizePresentationBubbleScale(rawScale);
+    if (scaleElement && (void 0 === rawScale || !Number.isFinite(rawScale) || rawScale < 5 || rawScale > 300)) diagnostics.push({
+        code: 'pptx.chart.bubble-scale',
+        feature: 'Chart formatting',
+        message: 'The bubble scale was outside the editable 5–300% range and was normalized.'
+    });
+    chart.showNegativeBubbles = pptxBooleanElement(source, 'showNegBubbles');
+    const rawSizeRepresents = attribute(directChild(source, 'sizeRepresents') ?? source, 'val');
+    chart.bubbleSizeRepresents = normalizePresentationBubbleSizeRepresents('w' === rawSizeRepresents ? 'width' : rawSizeRepresents);
+    if (rawSizeRepresents && 'area' !== rawSizeRepresents && 'w' !== rawSizeRepresents) diagnostics.push({
+        code: 'pptx.chart.bubble-size',
+        feature: 'Chart formatting',
+        message: `The bubble-size representation “${rawSizeRepresents}” was normalized to area.`
+    });
+    if (descendants(source, 'bubble3D').some((element)=>pptxBooleanValue(element))) diagnostics.push({
+        code: 'pptx.chart.bubble-3d',
+        feature: 'Chart formatting',
+        message: '3D bubble effects were normalized to editable 2D bubbles.'
+    });
+}
+function cachedValues(parent) {
+    if (!parent) return [];
+    const multiLevelCache = firstDescendant(parent, 'multiLvlStrCache');
+    if (multiLevelCache) {
+        const levels = directChildren(multiLevelCache, 'lvl').map((level)=>cachedPoints(level));
+        const length = Math.max(0, ...levels.map((level)=>level.length));
+        return Array.from({
+            length
+        }, (_, index)=>levels.map((level)=>level[index]?.trim()).filter(Boolean).join(' / '));
+    }
+    const cache = firstDescendant(parent, 'strCache') ?? firstDescendant(parent, 'numCache') ?? firstDescendant(parent, 'strLit') ?? firstDescendant(parent, 'numLit');
+    if (!cache) {
+        const value = firstDescendant(parent, 'v')?.textContent;
+        return null == value ? [] : [
+            value
+        ];
+    }
+    return cachedPoints(cache);
+}
+function cachedPoints(cache) {
+    return descendants(cache, 'pt').sort((left, right)=>work_pptx_chart_import_numberAttribute(left, 'idx', 0) - work_pptx_chart_import_numberAttribute(right, 'idx', 0)).map((point)=>firstDescendant(point, 'v')?.textContent ?? '');
+}
+function work_pptx_chart_import_numberAttribute(element, name, fallback) {
+    if (!element) return fallback;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : fallback;
+}
+function finiteNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : 0;
+}
+function pptxBooleanElement(parent, localName) {
+    const element = directChild(parent, localName);
+    return element ? pptxBooleanValue(element) : false;
+}
+function pptxBooleanValue(element) {
+    const value = attribute(element, 'val');
+    return null === value || '1' === value || 'true' === value.toLocaleLowerCase();
+}
+const EMU_PER_INCH = 914400;
+const DEFAULT_SLIDE_WIDTH = 13.333;
+const DEFAULT_SLIDE_HEIGHT = 7.5;
+const MAX_EMBEDDED_IMAGE_BYTES = 11534336;
+async function importPptxPresentation(file) {
+    const archive = await OoxmlPackage.load(await file.arrayBuffer());
+    if (!archive.has('ppt/presentation.xml')) throw new Error('The selected file is not a valid PPTX presentation.');
+    const presentation = await archive.xml('ppt/presentation.xml');
+    const presentationRelationships = await archive.relationships('ppt/presentation.xml');
+    const size = firstDescendant(presentation, 'sldSz');
+    const slideWidthEmu = positiveNumber(attribute(size ?? presentation.documentElement, 'cx')) ?? 12192000;
+    const slideHeightEmu = positiveNumber(attribute(size ?? presentation.documentElement, 'cy')) ?? 6858000;
+    const theme = await loadPptxTheme(archive, presentationRelationships);
+    const commentAuthors = await loadPptxCommentAuthors(archive, presentationRelationships);
+    const issues = [];
+    const imageBudget = {
+        bytes: 0
+    };
+    const designs = {
+        masterByPath: new Map(),
+        layoutByPath: new Map(),
+        masters: [],
+        layouts: []
+    };
+    await loadPptxPresentationDesigns(archive, presentationRelationships, slideWidthEmu, slideHeightEmu, theme, issues, imageBudget, designs);
+    const slideParts = orderedSlideParts(presentation, presentationRelationships);
+    if (!slideParts.length) throw new Error('The PPTX presentation does not contain any slides.');
+    const slides = [];
+    for (const [index, slidePart] of slideParts.entries())slides.push(await parseSlide(archive, slidePart, index + 1, slideWidthEmu, slideHeightEmu, theme, commentAuthors, issues, imageBudget, designs));
+    if (designs.layouts.length || designs.masters.length) issues.push({
+        code: 'pptx.layouts',
+        severity: 'info',
+        feature: 'Slide layouts and masters',
+        message: `${designs.layouts.length} slide layout(s) and ${designs.masters.length} slide master(s) retain inherited backgrounds, artwork, placeholder geometry, and native layout assignments.`
+    });
+    if (designs.masters.length > 1) issues.push({
+        code: 'pptx.masters.multiple',
+        severity: 'warning',
+        feature: 'Slide layouts and masters',
+        message: `${designs.masters.length} source master trees remain separately editable in Work. PPTX export preserves their visual inheritance per layout while normalizing them into the generated master hierarchy.`
+    });
+    addFontDiagnostics(slides, issues);
+    return {
+        content: {
+            type: 'presentation',
+            slides,
+            width: slideWidthEmu / EMU_PER_INCH || DEFAULT_SLIDE_WIDTH,
+            height: slideHeightEmu / EMU_PER_INCH || DEFAULT_SLIDE_HEIGHT,
+            masters: designs.masters.length ? designs.masters : void 0,
+            layouts: designs.layouts.length ? designs.layouts : void 0
+        },
+        compatibility: {
+            sourceFormat: 'PPTX',
+            sourceName: file.name,
+            assessedAt: Date.now(),
+            issues: deduplicateIssues(issues)
+        }
+    };
+}
+async function parseSlide(archive, slidePart, slideNumber, slideWidthEmu, slideHeightEmu, theme, commentAuthors, issues, imageBudget, designs) {
+    const document1 = await archive.xml(slidePart);
+    const relationships = await archive.relationships(slidePart);
+    const inheritance = await loadPptxSlideInheritance(archive, relationships, theme);
+    const context = {
+        archive,
+        slideNumber,
+        slideWidthEmu,
+        slideHeightEmu,
+        relationships,
+        placeholders: inheritance.placeholders,
+        theme,
+        issues,
+        imageBudget,
+        location: `幻灯片 ${slideNumber}`
+    };
+    const design = await ensurePptxDesignDefinitions(archive, inheritance.layout, inheritance.master, context, designs);
+    const elements = [];
+    const shapeTree = firstDescendant(document1, 'spTree');
+    for (const child of shapeTree ? directChildren(shapeTree) : [])elements.push(...await parseSlideNode(child, context));
+    const resolvedElements = inheritPptxPlaceholderStyles(elements, design.master, design.layout);
+    const transition = readPptxTransition(document1);
+    const commentResult = await readPptxSlideComments(archive, relationships, commentAuthors, slideNumber, slideWidthEmu, slideHeightEmu);
+    if (commentResult.comments.length) addIssue(context, 'pptx.comments', 'Comments', `${commentResult.comments.length} traditional slide comment(s), authors, dates, and positions are preserved and editable.`, 'info');
+    if (commentResult.hasUnsupportedThreadedComments) addIssue(context, 'pptx.comments.threaded', 'Modern comments', 'Modern threaded replies, mentions, and resolved state remain in the original PPTX only.');
+    if (commentResult.hasUnreadableComments) addIssue(context, 'pptx.comments.unreadable', 'Comments', 'One or more slide comment parts could not be read and remain in the original PPTX only.');
+    if (commentResult.hasMalformedMetadata) addIssue(context, 'pptx.comments.metadata', 'Comment metadata', 'One or more traditional comments had a missing author, date, or position; unavailable metadata was normalized.');
+    if (transition.present) {
+        addIssue(context, 'pptx.transition', 'Slide transitions', transition.transition ? 'Basic slide transitions and advance timing are preserved, editable, and replayed in presentation preview.' : 'This slide transition is not editable and remains in the original PPTX only.', transition.transition ? 'info' : 'warning');
+        for (const diagnostic of transition.diagnostics)addIssue(context, diagnostic.code, 'Slide transitions', diagnostic.message);
+    }
+    if (firstDescendant(document1, 'timing')) addIssue(context, 'pptx.animation', 'Animations', 'Object animations are not replayed and will be omitted on export.');
+    for (const relationship of relationships.values())if (relationship.type.includes('/audio') || relationship.type.includes('/video') || relationship.type.includes('/media')) addIssue(context, 'pptx.media', 'Embedded media', 'Audio and video remain in the original file but are not playable yet.');
+    else if (relationship.type.endsWith('/oleObject') || relationship.type.endsWith('/package')) addIssue(context, 'pptx.ole', 'Embedded objects', 'Embedded Office or OLE objects remain in the original file only.');
+    const slideBackground = readPptxBackground(document1, theme);
+    return {
+        id: createWorkId('slide'),
+        name: readSlideName(document1, slideNumber),
+        layoutId: design.layout?.id,
+        background: slideBackground ?? inheritance.layout?.background ?? inheritance.master?.background ?? '#ffffff',
+        useLayoutBackground: !slideBackground,
+        showMasterElements: pptxShowsMasterElements(document1) ? void 0 : false,
+        elements: resolvedElements,
+        notes: await readSpeakerNotes(archive, relationships, context),
+        comments: commentResult.comments.length ? commentResult.comments : void 0,
+        transition: transition.transition
+    };
+}
+async function loadPptxPresentationDesigns(archive, relationships, slideWidthEmu, slideHeightEmu, theme, issues, imageBudget, registry) {
+    const context = {
+        archive,
+        slideNumber: 0,
+        slideWidthEmu,
+        slideHeightEmu,
+        relationships,
+        placeholders: new Map(),
+        theme,
+        issues,
+        imageBudget,
+        location: '母版与布局'
+    };
+    for (const relationship of relationships.values()){
+        if (!relationship.type.endsWith('/slideMaster')) continue;
+        const part = await loadPptxDesignPart(archive, relationship.target, theme, 'Slide master');
+        if (part) await ensurePptxMaster(archive, part, context, registry);
+    }
+}
+async function ensurePptxDesignDefinitions(archive, layoutPart, masterPart, context, registry) {
+    const master = masterPart ? await ensurePptxMaster(archive, masterPart, context, registry) : layoutPart ? ensureFallbackPptxMaster(registry) : void 0;
+    const layout = layoutPart && master ? await ensurePptxLayout(layoutPart, master.id, context, registry) : void 0;
+    return {
+        master,
+        layout
+    };
+}
+async function ensurePptxMaster(archive, part, context, registry) {
+    const existing = registry.masterByPath.get(part.path);
+    if (existing) return existing;
+    const master = {
+        id: `pptx-master-${registry.masters.length + 1}`,
+        name: part.name,
+        background: part.background ?? '#ffffff',
+        elements: await parsePptxDesignElements(part, context)
+    };
+    registry.masterByPath.set(part.path, master);
+    registry.masters.push(master);
+    for (const relationship of part.relationships.values()){
+        if (!relationship.type.endsWith('/slideLayout')) continue;
+        const layoutPart = await loadPptxDesignPart(archive, relationship.target, context.theme, 'Slide layout');
+        if (layoutPart) await ensurePptxLayout(layoutPart, master.id, context, registry);
+    }
+    return master;
+}
+async function ensurePptxLayout(part, masterId, context, registry) {
+    const existing = registry.layoutByPath.get(part.path);
+    if (existing) return existing;
+    const layout = {
+        id: `pptx-layout-${registry.layouts.length + 1}`,
+        name: part.name,
+        masterId,
+        background: part.background,
+        elements: await parsePptxDesignElements(part, context),
+        showMasterElements: part.showMasterElements ? void 0 : false,
+        sourceType: part.sourceType
+    };
+    registry.layoutByPath.set(part.path, layout);
+    registry.layouts.push(layout);
+    return layout;
+}
+function ensureFallbackPptxMaster(registry) {
+    const path = 'pptx:fallback-master';
+    const existing = registry.masterByPath.get(path);
+    if (existing) return existing;
+    const master = {
+        id: `pptx-master-${registry.masters.length + 1}`,
+        name: 'Imported master',
+        background: '#ffffff',
+        elements: []
+    };
+    registry.masterByPath.set(path, master);
+    registry.masters.push(master);
+    return master;
+}
+async function parsePptxDesignElements(part, context) {
+    const partContext = {
+        ...context,
+        relationships: part.relationships,
+        placeholders: new Map()
+    };
+    const elements = [];
+    const shapeTree = firstDescendant(part.document, 'spTree');
+    for (const child of shapeTree ? directChildren(shapeTree) : [])elements.push(...await parseSlideNode(child, partContext));
+    return elements;
+}
+function inheritPptxPlaceholderStyles(elements, master, layout) {
+    const definitions = new Map();
+    const addDefinitions = (candidates)=>{
+        for (const candidate of candidates){
+            const placeholder = candidate.placeholder;
+            if (!placeholder) continue;
+            const inheritedDefinition = placeholder.inheritsStyle ? definitions.get(placeholder.key) ?? definitions.get(`type:${placeholder.type}`) : void 0;
+            const definition = inheritedDefinition ? inheritPptxPlaceholderStyle(candidate, inheritedDefinition) : candidate;
+            definitions.set(placeholder.key, definition);
+            definitions.set(`type:${placeholder.type}`, definition);
+        }
+    };
+    if (layout?.showMasterElements !== false) addDefinitions(master?.elements ?? []);
+    addDefinitions(layout?.elements ?? []);
+    return elements.map((element)=>{
+        const placeholder = element.placeholder;
+        if (!placeholder?.inheritsStyle) return element;
+        const definition = definitions.get(placeholder.key) ?? definitions.get(`type:${placeholder.type}`);
+        return definition ? inheritPptxPlaceholderStyle(element, definition) : element;
+    });
+}
+function inheritPptxPlaceholderStyle(element, definition) {
+    return {
+        ...element,
+        fontSize: definition.fontSize,
+        color: definition.color,
+        fill: definition.fill,
+        bold: definition.bold,
+        align: definition.align,
+        fontFamily: definition.fontFamily,
+        italic: definition.italic,
+        underline: definition.underline,
+        verticalAlign: definition.verticalAlign,
+        textRuns: element.textRuns?.map((run)=>({
+                ...run,
+                fontSize: run.fontSize ?? definition.fontSize,
+                color: run.color ?? definition.color,
+                bold: run.bold ?? definition.bold,
+                italic: run.italic ?? definition.italic,
+                underline: run.underline ?? definition.underline,
+                fontFamily: run.fontFamily ?? definition.fontFamily
+            }))
+    };
+}
+async function parseSlideNode(node, context, transform) {
+    if ('sp' === node.localName) return [
+        withImportedGroupTransform(parseShape(node, context, transform), transform)
+    ];
+    if ('pic' === node.localName) return [
+        withImportedGroupTransform(await parsePicture(node, context, transform), transform)
+    ];
+    if ('graphicFrame' === node.localName) return [
+        withImportedGroupTransform(await parseGraphicFrame(node, context, transform), transform)
+    ];
+    if ('cxnSp' === node.localName) return [
+        withImportedGroupTransform(parseConnector(node, context, transform), transform)
+    ];
+    if ('grpSp' === node.localName) return parseGroup(node, context, transform);
+    if ([
+        'contentPart',
+        'oleObj'
+    ].includes(node.localName)) addIssue(context, 'pptx.content-part', 'Embedded content', 'An embedded slide object remains available in the original PPTX only.');
+    return [];
+}
+function parseShape(node, context, transform) {
+    const box = elementBox(node, context, transform);
+    const text = parseText(firstDescendant(node, 'txBody'), context);
+    const placeholder = pptxPlaceholder(node);
+    const ownBox = pptxRawElementBox(node);
+    const properties = directChild(node, 'spPr');
+    const fill = readPptxFill(properties, context.theme, text.text ? 'transparent' : '#dce6fb');
+    const geometry = attribute(firstDescendant(properties, 'prstGeom') ?? node, 'prst') ?? 'rect';
+    const shapeType = supportedPptxShapeType(geometry);
+    if (!shapeType) addIssue(context, `pptx.shape.${geometry}`, 'Shape geometry', `The “${geometry}” shape is shown as a rectangle and will be normalized on export.`);
+    const line = firstDescendant(properties, 'ln');
+    const border = readPptxFill(line, context.theme, 'transparent' === fill.color ? '#657087' : fill.color);
+    const isTextBox = '1' === attribute(firstDescendant(node, 'cNvSpPr') ?? node, 'txBox');
+    const isTextPlaceholder = placeholder && ![
+        'pic',
+        'chart',
+        'tbl',
+        'media',
+        'obj'
+    ].includes(placeholder.type);
+    const altText = readAlternativeText(node);
+    return {
+        id: createWorkId('element'),
+        type: 'line' === shapeType ? 'line' : isTextPlaceholder || isTextBox || text.text && 'transparent' === fill.color ? 'text' : 'shape',
+        ...box,
+        text: text.text,
+        fontSize: text.fontSize,
+        color: text.color,
+        fill: fill.color,
+        bold: text.bold,
+        align: text.align,
+        shapeType: shapeType ?? 'rect',
+        radius: 'roundRect' === shapeType ? 5 : void 0,
+        opacity: fill.opacity,
+        borderColor: border.color,
+        borderWidth: work_pptx_import_numberAttribute(line, 'w', 0) / 12700 || void 0,
+        fontFamily: text.fontFamily,
+        italic: text.italic,
+        underline: text.underline,
+        verticalAlign: text.verticalAlign,
+        textRuns: text.runs.length ? text.runs : void 0,
+        href: text.href,
+        altText,
+        placeholder: placeholder ? {
+            ...placeholder,
+            prompt: text.text.trim() || void 0,
+            inheritsGeometry: ownBox ? void 0 : true,
+            inheritsStyle: text.explicitStyle ? void 0 : true
+        } : void 0
+    };
+}
+async function parsePicture(node, context, transform) {
+    const box = elementBox(node, context, transform);
+    const properties = firstDescendant(node, 'blip');
+    const relationshipId = attribute(properties ?? node, 'r:embed') ?? attribute(properties ?? node, 'embed');
+    const relationship = relationshipId ? context.relationships.get(relationshipId) : void 0;
+    const name = attribute(firstDescendant(node, 'cNvPr') ?? node, 'name') ?? 'Imported picture';
+    const placeholder = pptxPlaceholder(node);
+    const base = {
+        id: createWorkId('element'),
+        type: 'image',
+        ...box,
+        text: '',
+        fontSize: 12,
+        color: '#536078',
+        fill: '#eef1f6',
+        bold: false,
+        align: 'center',
+        altText: readAlternativeText(node) || name,
+        placeholder
+    };
+    if (!relationship || 'External' === relationship.targetMode || !context.archive.has(relationship.target)) {
+        addIssue(context, 'pptx.image.linked', 'Linked pictures', `The linked picture “${name}” could not be embedded.`);
+        return {
+            ...base,
+            type: 'shape',
+            text: `图片：${name}`
+        };
+    }
+    const bytes = await context.archive.bytes(relationship.target);
+    if (context.imageBudget.bytes + bytes.byteLength > MAX_EMBEDDED_IMAGE_BYTES) {
+        addIssue(context, 'pptx.image.limit', 'Large pictures', `The picture “${name}” exceeds the safe native-artifact image budget and remains in the original file only.`);
+        return {
+            ...base,
+            type: 'shape',
+            text: `大型图片：${name}`
+        };
+    }
+    context.imageBudget.bytes += bytes.byteLength;
+    const contentType = contentTypeForPart(relationship.target);
+    const sourceRectangle = firstDescendant(node, 'srcRect');
+    if (sourceRectangle && Array.from(sourceRectangle.attributes).some((item)=>0 !== Number(item.value))) addIssue(context, 'pptx.image.crop', 'Picture cropping', `Crop settings for “${name}” will be normalized on export.`);
+    return {
+        ...base,
+        fill: 'transparent',
+        image: {
+            dataUrl: bytesToDataUrl(bytes, contentType),
+            contentType,
+            name
+        }
+    };
+}
+async function parseGraphicFrame(node, context, transform) {
+    const box = elementBox(node, context, transform);
+    const table = firstDescendant(node, 'tbl');
+    if (table) {
+        const rows = directChildren(table, 'tr').map((row)=>directChildren(row, 'tc').map((cell)=>directChildren(firstDescendant(cell, 'txBody') ?? cell, 'p').map((paragraph)=>descendants(paragraph, 't').map((text)=>text.textContent ?? '').join('')).join('\n')));
+        if (descendants(table, 'tc').some((cell)=>[
+                'gridSpan',
+                'rowSpan',
+                'hMerge',
+                'vMerge'
+            ].some((name)=>attribute(cell, name)))) addIssue(context, 'pptx.table.merge', 'Merged table cells', 'Merged table cells are flattened for editing and export.');
+        return {
+            id: createWorkId('element'),
+            type: 'table',
+            ...box,
+            text: '',
+            fontSize: 12,
+            color: '#172033',
+            fill: '#ffffff',
+            bold: false,
+            align: 'left',
+            borderColor: '#cbd2de',
+            borderWidth: 1,
+            table: {
+                rows,
+                headerRows: rows.length > 1 ? 1 : 0
+            },
+            altText: readAlternativeText(node)
+        };
+    }
+    const chartReference = firstDescendant(node, 'chart');
+    const relationshipId = attribute(chartReference ?? node, 'r:id') ?? attribute(chartReference ?? node, 'id');
+    const relationship = relationshipId ? context.relationships.get(relationshipId) : void 0;
+    if (relationship?.type.endsWith('/chart') && context.archive.has(relationship.target)) {
+        const result = readPptxChart(await context.archive.xml(relationship.target));
+        for (const diagnostic of result.diagnostics)addIssue(context, diagnostic.code, diagnostic.feature, diagnostic.message);
+        const chart = result.chart;
+        return {
+            id: createWorkId('element'),
+            type: 'chart',
+            ...box,
+            text: chart.title ?? '',
+            fontSize: 12,
+            color: '#172033',
+            fill: '#ffffff',
+            bold: false,
+            align: 'center',
+            borderColor: '#d9dee8',
+            borderWidth: 1,
+            chart,
+            altText: readAlternativeText(node)
+        };
+    }
+    addIssue(context, 'pptx.graphic-frame', 'SmartArt and diagrams', 'A SmartArt or diagram object remains in the original PPTX only.');
+    return {
+        id: createWorkId('element'),
+        type: 'shape',
+        ...box,
+        text: 'SmartArt / 图示',
+        fontSize: 14,
+        color: '#536078',
+        fill: '#eef1f6',
+        bold: true,
+        align: 'center',
+        shapeType: 'rect'
+    };
+}
+function parseConnector(node, context, transform) {
+    const box = elementBox(node, context, transform);
+    const properties = directChild(node, 'spPr');
+    const line = firstDescendant(properties, 'ln');
+    const color = readPptxFill(line, context.theme, '#657087');
+    return {
+        id: createWorkId('element'),
+        type: 'line',
+        ...box,
+        text: '',
+        fontSize: 12,
+        color: color.color,
+        fill: 'transparent',
+        bold: false,
+        align: 'left',
+        shapeType: 'line',
+        borderColor: color.color,
+        borderWidth: work_pptx_import_numberAttribute(line, 'w', 12700) / 12700
+    };
+}
+async function parseGroup(node, context, parentTransform) {
+    const xfrm = childPath(node, 'grpSpPr', 'xfrm');
+    if (0 !== work_pptx_import_numberAttribute(xfrm, 'rot', 0) || booleanAttribute(xfrm, 'flipH') || booleanAttribute(xfrm, 'flipV')) addIssue(context, 'pptx.group.transform', 'Group transform', 'Group rotation or reflection is retained in the original PPTX but is not applied to browser editing geometry.');
+    const offset = directChild(xfrm ?? node, 'off');
+    const extent = directChild(xfrm ?? node, 'ext');
+    const childOffset = directChild(xfrm ?? node, 'chOff');
+    const childExtent = directChild(xfrm ?? node, 'chExt');
+    const group = {
+        x: work_pptx_import_numberAttribute(offset, 'x', 0),
+        y: work_pptx_import_numberAttribute(offset, 'y', 0),
+        width: work_pptx_import_numberAttribute(extent, 'cx', context.slideWidthEmu),
+        height: work_pptx_import_numberAttribute(extent, 'cy', context.slideHeightEmu)
+    };
+    const viewport = {
+        x: work_pptx_import_numberAttribute(childOffset, 'x', 0),
+        y: work_pptx_import_numberAttribute(childOffset, 'y', 0),
+        width: work_pptx_import_numberAttribute(childExtent, 'cx', group.width),
+        height: work_pptx_import_numberAttribute(childExtent, 'cy', group.height)
+    };
+    const localVisualScale = pptxGroupVisualScale(group, viewport);
+    const transform = {
+        groupIds: [
+            ...parentTransform?.groupIds ?? [],
+            createWorkId('element-group')
+        ],
+        visualScale: (parentTransform?.visualScale ?? 1) * localVisualScale,
+        map: (box)=>{
+            const mapped = {
+                ...box,
+                x: group.x + (box.x - viewport.x) * group.width / Math.max(1, viewport.width),
+                y: group.y + (box.y - viewport.y) * group.height / Math.max(1, viewport.height),
+                width: box.width * group.width / Math.max(1, viewport.width),
+                height: box.height * group.height / Math.max(1, viewport.height)
+            };
+            return parentTransform ? parentTransform.map(mapped) : mapped;
+        }
+    };
+    const elements = [];
+    for (const child of directChildren(node))elements.push(...await parseSlideNode(child, context, transform));
+    return elements;
+}
+function withImportedGroupTransform(element, transform) {
+    if (!transform?.groupIds.length) return element;
+    return {
+        ...element,
+        ...scaledPresentationVisuals(element, transform.visualScale),
+        groupIds: [
+            ...transform.groupIds
+        ]
+    };
+}
+function pptxGroupVisualScale(group, viewport) {
+    const scaleX = Math.abs(group.width) / Math.max(1, Math.abs(viewport.width));
+    const scaleY = Math.abs(group.height) / Math.max(1, Math.abs(viewport.height));
+    const scale = Math.min(scaleX, scaleY);
+    return Number.isFinite(scale) && scale > 0 ? scale : 1;
+}
+function parseText(body, context) {
+    const runs = [];
+    const paragraphs = body ? directChildren(body, 'p') : [];
+    let align = 'left';
+    let explicitStyle = false;
+    for (const [paragraphIndex, paragraph] of paragraphs.entries()){
+        const paragraphProperties = directChild(paragraph, 'pPr');
+        if (paragraphProperties && (paragraphProperties.attributes.length || paragraphProperties.children.length)) explicitStyle = true;
+        if (0 === paragraphIndex) align = pptxTextAlignment(attribute(paragraphProperties ?? paragraph, 'algn'));
+        const bullet = directChild(paragraphProperties ?? paragraph, 'buChar');
+        const autoNumber = directChild(paragraphProperties ?? paragraph, 'buAutoNum');
+        if (bullet || autoNumber) {
+            explicitStyle = true;
+            runs.push({
+                text: bullet ? `${attribute(bullet, 'char') ?? '•'} ` : `${paragraphIndex + 1}. `
+            });
+        }
+        for (const child of directChildren(paragraph)){
+            if ('br' === child.localName) {
+                runs.push({
+                    text: '\n'
+                });
+                continue;
+            }
+            if ('r' !== child.localName && 'fld' !== child.localName) continue;
+            const text = directChild(child, 't')?.textContent ?? '';
+            if (!text) continue;
+            const runProperties = directChild(child, 'rPr') ?? directChild(paragraphProperties ?? paragraph, 'defRPr');
+            if (runProperties) explicitStyle = true;
+            const color = runProperties ? readPptxFill(runProperties, context.theme, '#172033').color : void 0;
+            const hyperlink = firstDescendant(runProperties, 'hlinkClick');
+            const relationshipId = attribute(hyperlink ?? child, 'r:id') ?? attribute(hyperlink ?? child, 'id');
+            const relationship = relationshipId ? context.relationships.get(relationshipId) : void 0;
+            const fontSize = runProperties ? positiveNumber(attribute(runProperties, 'sz')) : void 0;
+            runs.push({
+                text,
+                fontSize: fontSize ? fontSize / 100 : void 0,
+                color,
+                bold: runProperties ? booleanAttribute(runProperties, 'b') : void 0,
+                italic: runProperties ? booleanAttribute(runProperties, 'i') : void 0,
+                underline: runProperties ? Boolean(attribute(runProperties, 'u') && 'none' !== attribute(runProperties, 'u')) : void 0,
+                fontFamily: runProperties ? attribute(directChild(runProperties, 'latin') ?? runProperties, 'typeface') ?? attribute(directChild(runProperties, 'ea') ?? runProperties, 'typeface') ?? void 0 : void 0,
+                href: relationship?.targetMode === 'External' ? relationship.target : void 0
+            });
+        }
+        if (paragraphIndex < paragraphs.length - 1) runs.push({
+            text: '\n'
+        });
+    }
+    const first = runs.find((run)=>'\n' !== run.text);
+    const bodyProperties = body ? directChild(body, 'bodyPr') : void 0;
+    if (bodyProperties?.attributes.length) explicitStyle = true;
+    return {
+        text: runs.map((run)=>run.text).join(''),
+        runs,
+        align,
+        verticalAlign: pptxVerticalAlignment(bodyProperties ? attribute(bodyProperties, 'anchor') : null),
+        fontSize: first?.fontSize ?? 18,
+        color: first?.color ?? '#172033',
+        bold: first?.bold ?? false,
+        italic: first?.italic ?? false,
+        underline: first?.underline ?? false,
+        fontFamily: first?.fontFamily,
+        href: runs.find((run)=>run.href)?.href,
+        explicitStyle
+    };
+}
+function elementBox(node, context, transform) {
+    const raw = pptxRawElementBox(node) ?? pptxPlaceholderBox(node, context.placeholders) ?? {
+        x: 0.1 * context.slideWidthEmu,
+        y: 0.1 * context.slideHeightEmu,
+        width: 0.4 * context.slideWidthEmu,
+        height: 0.15 * context.slideHeightEmu
+    };
+    const mapped = transform ? transform.map(raw) : raw;
+    return {
+        x: mapped.x / context.slideWidthEmu * 100,
+        y: mapped.y / context.slideHeightEmu * 100,
+        width: Math.max(0.5, mapped.width / context.slideWidthEmu * 100),
+        height: Math.max(0.5, mapped.height / context.slideHeightEmu * 100),
+        rotation: mapped.rotation
+    };
+}
+async function readSpeakerNotes(archive, relationships, context) {
+    const relationship = Array.from(relationships.values()).find((item)=>item.type.endsWith('/notesSlide'));
+    if (!relationship || !archive.has(relationship.target)) return;
+    const document1 = await archive.xml(relationship.target);
+    const bodies = descendants(document1, 'sp').filter((shape)=>'body' === attribute(firstDescendant(directChild(shape, 'nvSpPr'), 'ph') ?? shape, 'type')).map((shape)=>parseText(firstDescendant(shape, 'txBody'), context).text.trim()).filter(Boolean);
+    return bodies.join('\n\n') || void 0;
+}
+function orderedSlideParts(presentation, relationships) {
+    return descendants(presentation, 'sldId').map((node)=>{
+        const id = attribute(node, 'r:id') ?? attribute(node, 'id');
+        return id ? relationships.get(id) : void 0;
+    }).filter((relationship)=>Boolean(relationship?.type.endsWith('/slide'))).map((relationship)=>relationship.target);
+}
+function readSlideName(document1, slideNumber) {
+    const titleShape = descendants(document1, 'sp').find((shape)=>{
+        const type = attribute(firstDescendant(directChild(shape, 'nvSpPr'), 'ph') ?? shape, 'type');
+        return 'title' === type || 'ctrTitle' === type;
+    });
+    const title = titleShape ? descendants(titleShape, 't').map((node)=>node.textContent ?? '').join('').trim() : '';
+    return title || `幻灯片 ${slideNumber}`;
+}
+function readAlternativeText(node) {
+    const properties = firstDescendant(node, 'cNvPr');
+    return attribute(properties ?? node, 'descr')?.trim() || attribute(properties ?? node, 'title')?.trim() || void 0;
+}
+function addIssue(context, code, feature, message, severity = 'warning') {
+    context.issues.push({
+        code,
+        severity,
+        feature,
+        message,
+        location: context.location ?? `幻灯片 ${context.slideNumber}`
+    });
+}
+function addFontDiagnostics(slides, issues) {
+    const fonts = new Set();
+    for (const slide of slides)for (const element of slide.elements){
+        if (element.fontFamily) fonts.add(element.fontFamily);
+        for (const run of element.textRuns ?? [])if (run.fontFamily) fonts.add(run.fontFamily);
+    }
+    for (const font of fonts){
+        if (font.startsWith('+m') || font.startsWith('+mj') || font.startsWith('+mn')) continue;
+        const available = 'function' == typeof document.fonts?.check ? document.fonts.check(`12px "${font}"`) : true;
+        if (!available) issues.push({
+            code: `pptx.font.${font.toLowerCase()}`,
+            severity: 'warning',
+            feature: 'Font substitution',
+            message: `The font “${font}” is unavailable in this browser and may be substituted in preview and export.`
+        });
+    }
+}
+function deduplicateIssues(issues) {
+    const seen = new Set();
+    return issues.filter((issue)=>{
+        const key = `${issue.code}:${issue.location ?? ''}:${issue.message}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+function booleanAttribute(element, name) {
+    if (!element) return false;
+    const value = attribute(element, name);
+    return '1' === value || 'true' === value;
+}
+function work_pptx_import_numberAttribute(element, name, fallback) {
+    if (!element) return fallback;
+    const value = Number(attribute(element, name));
+    return Number.isFinite(value) ? value : fallback;
+}
+function positiveNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : void 0;
+}
+export { importPptxPresentation };