@a3s-lab/office 0.1.0

package/dist/0~7614.js

@@ -0,0 +1,1037 @@
+import jszip from "jszip";
+import { workSpreadsheetChartSupportsErrorBars, workSpreadsheetChartSupportsGrouping, parseXml, firstDescendant, normalizeWorkSpreadsheetChartSmoothLines, workSpreadsheetChartSupportsSeriesAnalysis, descendants, normalizeWorkSpreadsheetChartSeriesStyle, attribute, directChildren, xmlNamespacePrefix, normalizeWorkSpreadsheetChartOverlap, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartSupportsBarSpacing, directChild, normalizeWorkSpreadsheetChartGrouping, workSpreadsheetChartSupportsSmoothLines, normalizeWorkSpreadsheetTrendline, workSpreadsheetChartUsesNumericXAxis, workSpreadsheetChartSupportsTrendlines } from "./8715.js";
+import { normalizePresentationChartDataLabelPosition, normalizePresentationChartDataLabels, normalizePresentationChartSeriesStyle } from "./0~work-presentation-charts.js";
+import { parseXlsxChartSeriesStyle, xlsxChartSeriesMarkerXml, parseXlsxTrendline, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, parseXlsxChartPlotLayout, parseXlsxChartLegend, xlsxChartSeriesShapePropertiesXml, parseXlsxErrorBars } from "./4104.js";
+import { createWorkSlideTransition } from "./0~work-presentation-transition.js";
+const PRESENTATION_NAMESPACE = 'http://schemas.openxmlformats.org/presentationml/2006/main';
+const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+const OFFICE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/relationships';
+const PACKAGE_RELATIONSHIPS_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/relationships';
+const CONTENT_TYPES_NAMESPACE = 'http://schemas.openxmlformats.org/package/2006/content-types';
+const COMMENTS_RELATIONSHIP = `${OFFICE_RELATIONSHIPS_NAMESPACE}/comments`;
+const COMMENT_AUTHORS_RELATIONSHIP = `${OFFICE_RELATIONSHIPS_NAMESPACE}/commentAuthors`;
+const COMMENTS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.comments+xml';
+const COMMENT_AUTHORS_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.presentationml.commentAuthors+xml';
+async function loadPptxCommentAuthors(archive, presentationRelationships) {
+    const relationship = Array.from(presentationRelationships.values()).find((item)=>item.type.endsWith('/commentAuthors'));
+    if (!relationship || !archive.has(relationship.target)) return new Map();
+    const document = await archive.xml(relationship.target);
+    return new Map(descendants(document, 'cmAuthor').map((author)=>{
+        const id = attribute(author, 'id')?.trim() ?? '';
+        return [
+            id,
+            {
+                id,
+                name: attribute(author, 'name')?.trim() || '未知审阅者',
+                initials: attribute(author, 'initials')?.trim() || ''
+            }
+        ];
+    }));
+}
+async function readPptxSlideComments(archive, relationships, authors, slideNumber, slideWidthEmu, slideHeightEmu) {
+    const result = {
+        comments: [],
+        hasLegacyComments: false,
+        hasUnsupportedThreadedComments: false,
+        hasUnreadableComments: false,
+        hasMalformedMetadata: false
+    };
+    const commentRelationships = Array.from(relationships.values()).filter((item)=>item.type.endsWith('/comments'));
+    for (const relationship of commentRelationships){
+        if (!archive.has(relationship.target)) {
+            result.hasUnreadableComments = true;
+            continue;
+        }
+        const document = await archive.xml(relationship.target);
+        const root = document.documentElement;
+        if (root.namespaceURI !== PRESENTATION_NAMESPACE || 'cmLst' !== root.localName) {
+            result.hasUnsupportedThreadedComments = true;
+            continue;
+        }
+        result.hasLegacyComments = true;
+        for (const [index, element] of directChildren(root, 'cm').entries()){
+            const authorId = attribute(element, 'authorId')?.trim() ?? '';
+            const author = authors.get(authorId);
+            const sourceIndex = attribute(element, 'idx')?.trim() || String(index + 1);
+            const position = firstDescendant(element, 'pos');
+            const sourceDate = attribute(element, 'dt');
+            if (!author || !normalizeDate(sourceDate) || !position || !validCoordinate(attribute(position ?? element, 'x'), slideWidthEmu) || !validCoordinate(attribute(position ?? element, 'y'), slideHeightEmu)) result.hasMalformedMetadata = true;
+            result.comments.push({
+                id: `pptx-comment-${slideNumber}-${safeIdPart(sourceIndex)}-${index + 1}`,
+                author: author?.name ?? '未知审阅者',
+                initials: author?.initials || void 0,
+                date: normalizeDate(sourceDate),
+                text: firstDescendant(element, 'text')?.textContent ?? '',
+                x: coordinatePercent(attribute(position ?? element, 'x'), slideWidthEmu),
+                y: coordinatePercent(attribute(position ?? element, 'y'), slideHeightEmu)
+            });
+        }
+    }
+    return result;
+}
+async function patchPptxComments(buffer, slides, slideWidth, slideHeight) {
+    if (!slides.some((slide)=>slide.comments?.length)) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const authors = collectExportAuthors(slides);
+    const slideWidthEmu = Math.round(914400 * slideWidth);
+    const slideHeightEmu = Math.round(914400 * slideHeight);
+    const commentParts = [];
+    for (const [slideIndex, slide] of slides.entries()){
+        if (!slide.comments?.length) continue;
+        const partPath = `ppt/comments/comment${slideIndex + 1}.xml`;
+        commentParts.push(partPath);
+        archive.file(partPath, serializeSlideComments(slide.comments, authors, slideWidthEmu, slideHeightEmu));
+        await upsertRelationship(archive, `ppt/slides/slide${slideIndex + 1}.xml`, COMMENTS_RELATIONSHIP, `../comments/comment${slideIndex + 1}.xml`);
+    }
+    archive.file('ppt/commentAuthors.xml', serializeCommentAuthors(authors));
+    await upsertRelationship(archive, 'ppt/presentation.xml', COMMENT_AUTHORS_RELATIONSHIP, 'commentAuthors.xml');
+    await upsertContentTypes(archive, commentParts);
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function collectExportAuthors(slides) {
+    const authors = new Map();
+    for (const comment of slides.flatMap((slide)=>slide.comments ?? [])){
+        const name = comment.author.trim() || 'A3S Work';
+        const initials = comment.initials?.trim() || commentInitials(name);
+        const key = authorKey(name, initials);
+        if (!authors.has(key)) authors.set(key, {
+            id: String(authors.size),
+            name,
+            initials,
+            nextIndex: 1,
+            lastIndex: 0,
+            colorIndex: authors.size % 8
+        });
+    }
+    return authors;
+}
+function serializeSlideComments(comments, authors, slideWidthEmu, slideHeightEmu) {
+    const document = presentationDocument('cmLst');
+    for (const comment of comments){
+        const name = comment.author.trim() || 'A3S Work';
+        const initials = comment.initials?.trim() || commentInitials(name);
+        const author = authors.get(authorKey(name, initials));
+        if (!author) continue;
+        const index = author.nextIndex;
+        author.nextIndex += 1;
+        author.lastIndex = Math.max(author.lastIndex, index);
+        const element = document.createElementNS(PRESENTATION_NAMESPACE, 'p:cm');
+        element.setAttribute('authorId', author.id);
+        element.setAttribute('dt', commentDate(comment.date));
+        element.setAttribute('idx', String(index));
+        const position = document.createElementNS(PRESENTATION_NAMESPACE, 'p:pos');
+        position.setAttribute('x', String(percentCoordinate(comment.x, slideWidthEmu)));
+        position.setAttribute('y', String(percentCoordinate(comment.y, slideHeightEmu)));
+        const text = document.createElementNS(PRESENTATION_NAMESPACE, 'p:text');
+        text.textContent = comment.text;
+        element.append(position, text);
+        document.documentElement.append(element);
+    }
+    return new XMLSerializer().serializeToString(document);
+}
+function serializeCommentAuthors(authors) {
+    const document = presentationDocument('cmAuthorLst');
+    for (const author of authors.values()){
+        const element = document.createElementNS(PRESENTATION_NAMESPACE, 'p:cmAuthor');
+        element.setAttribute('id', author.id);
+        element.setAttribute('name', author.name);
+        element.setAttribute('initials', author.initials);
+        element.setAttribute('lastIdx', String(author.lastIndex));
+        element.setAttribute('clrIdx', String(author.colorIndex));
+        document.documentElement.append(element);
+    }
+    return new XMLSerializer().serializeToString(document);
+}
+async function upsertRelationship(archive, sourcePart, type, target) {
+    const path = relationshipPartPath(sourcePart);
+    const entry = archive.file(path);
+    const document = entry ? parseXml(await entry.async('text'), path) : parseXml(`<Relationships xmlns="${PACKAGE_RELATIONSHIPS_NAMESPACE}"/>`, path);
+    const root = document.documentElement;
+    const existing = directChildren(root, 'Relationship').find((item)=>attribute(item, 'Type') === type);
+    if (existing) existing.setAttribute('Target', target);
+    else {
+        const relationship = document.createElementNS(PACKAGE_RELATIONSHIPS_NAMESPACE, 'Relationship');
+        relationship.setAttribute('Id', nextRelationshipId(root));
+        relationship.setAttribute('Type', type);
+        relationship.setAttribute('Target', target);
+        root.append(relationship);
+    }
+    archive.file(path, new XMLSerializer().serializeToString(document));
+}
+async function upsertContentTypes(archive, commentParts) {
+    const path = '[Content_Types].xml';
+    const entry = archive.file(path);
+    if (!entry) throw new Error('PPTX content types part is missing.');
+    const document = parseXml(await entry.async('text'), path);
+    upsertContentType(document, '/ppt/commentAuthors.xml', COMMENT_AUTHORS_CONTENT_TYPE);
+    for (const part of commentParts)upsertContentType(document, `/${part}`, COMMENTS_CONTENT_TYPE);
+    archive.file(path, new XMLSerializer().serializeToString(document));
+}
+function upsertContentType(document, partName, contentType) {
+    const root = document.documentElement;
+    const existing = directChildren(root, 'Override').find((item)=>attribute(item, 'PartName') === partName);
+    if (existing) return void existing.setAttribute('ContentType', contentType);
+    const override = document.createElementNS(CONTENT_TYPES_NAMESPACE, 'Override');
+    override.setAttribute('PartName', partName);
+    override.setAttribute('ContentType', contentType);
+    root.append(override);
+}
+function presentationDocument(rootName) {
+    return parseXml(`<p:${rootName} xmlns:a="${DRAWING_NAMESPACE}" xmlns:r="${OFFICE_RELATIONSHIPS_NAMESPACE}" xmlns:p="${PRESENTATION_NAMESPACE}"/>`, `PPTX ${rootName}`);
+}
+function relationshipPartPath(sourcePart) {
+    const separator = sourcePart.lastIndexOf('/');
+    const directory = separator >= 0 ? sourcePart.slice(0, separator + 1) : '';
+    const fileName = separator >= 0 ? sourcePart.slice(separator + 1) : sourcePart;
+    return `${directory}_rels/${fileName}.rels`;
+}
+function nextRelationshipId(root) {
+    const used = new Set(directChildren(root, 'Relationship').map((item)=>attribute(item, 'Id') ?? ''));
+    let index = 1;
+    while(used.has(`rId${index}`))index += 1;
+    return `rId${index}`;
+}
+function coordinatePercent(value, size) {
+    const coordinate = Number(value);
+    if (!Number.isFinite(coordinate) || coordinate < 0 || size <= 0) return 50;
+    return Math.round(10000 * clamp(coordinate / size * 100, 0, 100)) / 10000;
+}
+function validCoordinate(value, size) {
+    const coordinate = Number(value);
+    return null !== value && Number.isFinite(coordinate) && coordinate >= 0 && coordinate <= size;
+}
+function percentCoordinate(value, size) {
+    return Math.round(clamp(Number.isFinite(value) ? value : 50, 0, 100) / 100 * size);
+}
+function commentDate(value) {
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : new Date().toISOString();
+}
+function normalizeDate(value) {
+    if (!value) return '';
+    const time = Date.parse(value);
+    return Number.isFinite(time) ? new Date(time).toISOString() : '';
+}
+function commentInitials(author) {
+    const parts = author.trim().split(/\s+/).filter(Boolean);
+    if (!parts.length) return 'AW';
+    return parts.slice(0, 2).map((part)=>Array.from(part)[0] ?? '').join('').toUpperCase();
+}
+function authorKey(author, initials) {
+    return `${author}\u0000${initials}`;
+}
+function safeIdPart(value) {
+    const normalized = value.replace(/[^a-z0-9_-]/gi, '-').replace(/-+/g, '-');
+    return normalized || 'comment';
+}
+function clamp(value, minimum, maximum) {
+    return Math.min(Math.max(value, minimum), maximum);
+}
+const CHART_TYPES = [
+    'barChart',
+    'lineChart',
+    'pieChart',
+    'doughnutChart',
+    'areaChart',
+    'radarChart',
+    'scatterChart',
+    'bubbleChart'
+];
+const DATA_LABEL_ANCHORS = new Set([
+    'dropLines',
+    'hiLowLines',
+    'upDownBars',
+    'marker',
+    'smooth',
+    'gapWidth',
+    'overlap',
+    'firstSliceAng',
+    'holeSize',
+    'bubble3D',
+    'bubbleScale',
+    'showNegBubbles',
+    'sizeRepresents',
+    'axId',
+    'extLst'
+]);
+function readPptxChartDataLabels(chartNode, chartType) {
+    if (!chartNode) return {
+        diagnostics: []
+    };
+    const diagnostics = [];
+    const series = directChildren(chartNode, 'ser');
+    const chartLabels = directChild(chartNode, 'dLbls');
+    const seriesLabels = series.flatMap((item)=>directChildren(item, 'dLbls'));
+    const source = chartLabels ?? seriesLabels[0];
+    if (!source || pptxBooleanElement(source, 'delete')) return {
+        diagnostics
+    };
+    if (chartLabels && seriesLabels.length) diagnostics.push({
+        code: 'pptx.chart.data-label-overrides',
+        message: 'Per-series data-label overrides were normalized to the chart-level editable settings.'
+    });
+    else if (!chartLabels && (seriesLabels.length !== series.length || new Set(seriesLabels.map(dataLabelSignature)).size > 1)) diagnostics.push({
+        code: 'pptx.chart.data-label-overrides',
+        message: 'Different per-series data-label settings were normalized to one editable chart-level setting.'
+    });
+    const allLabelNodes = [
+        ...chartLabels ? [
+            chartLabels
+        ] : [],
+        ...seriesLabels
+    ];
+    if (allLabelNodes.some((labels)=>directChildren(labels, 'dLbl').length > 0)) diagnostics.push({
+        code: 'pptx.chart.data-label-overrides',
+        message: 'Per-point data-label overrides were normalized to the chart-level editable settings.'
+    });
+    const rawPosition = attribute(directChild(source, 'dLblPos') ?? source, 'val');
+    const parsedPosition = pptxDataLabelPosition(rawPosition);
+    const normalizedPosition = normalizePresentationChartDataLabelPosition(parsedPosition, chartType);
+    if (rawPosition && (!parsedPosition || normalizedPosition !== parsedPosition)) diagnostics.push({
+        code: 'pptx.chart.data-label-position',
+        message: `The data-label position “${rawPosition}” was normalized for this editable chart type.`
+    });
+    const separatorElement = directChild(source, 'separator');
+    const separator = separatorElement?.textContent ?? void 0;
+    if (separator && separator.length > 64) diagnostics.push({
+        code: 'pptx.chart.data-label-separator',
+        message: 'The data-label separator exceeded 64 characters and was truncated.'
+    });
+    const showPercentage = pptxBooleanElement(source, 'showPercent');
+    const showBubbleSize = pptxBooleanElement(source, 'showBubbleSize');
+    if (showPercentage && 'pie' !== chartType && 'doughnut' !== chartType) diagnostics.push({
+        code: 'pptx.chart.data-label-content',
+        message: 'Percentage data labels are supported only for editable pie and doughnut charts.'
+    });
+    if (showBubbleSize && 'bubble' !== chartType) diagnostics.push({
+        code: 'pptx.chart.data-label-content',
+        message: 'Bubble-size data labels are supported only for editable bubble charts.'
+    });
+    if (pptxBooleanElement(source, 'showLegendKey') || pptxBooleanElement(source, 'showLeaderLines')) diagnostics.push({
+        code: 'pptx.chart.data-label-content',
+        message: 'Legend-key or leader-line data-label options were normalized.'
+    });
+    if ([
+        'numFmt',
+        'spPr',
+        'txPr',
+        'extLst'
+    ].some((name)=>directChildren(source, name).length > 0)) diagnostics.push({
+        code: 'pptx.chart.data-label-format',
+        message: 'Advanced data-label number and text formatting is normalized by the editable chart model.'
+    });
+    return {
+        dataLabels: normalizePresentationChartDataLabels({
+            ...pptxBooleanElement(source, 'showVal') ? {
+                showValue: true
+            } : {},
+            ...pptxBooleanElement(source, 'showCatName') ? {
+                showCategoryName: true
+            } : {},
+            ...pptxBooleanElement(source, 'showSerName') ? {
+                showSeriesName: true
+            } : {},
+            ...showPercentage ? {
+                showPercentage: true
+            } : {},
+            ...showBubbleSize ? {
+                showBubbleSize: true
+            } : {},
+            ...void 0 !== separator ? {
+                separator
+            } : {},
+            position: normalizedPosition
+        }, chartType),
+        diagnostics
+    };
+}
+async function patchPptxChartDataLabels(buffer, slides) {
+    const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
+                element.chart
+            ] : []));
+    if (!charts.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const chartPaths = Object.keys(archive.files).filter((path)=>/^ppt\/charts\/chart\d+\.xml$/.test(path)).sort((left, right)=>chartPartNumber(left) - chartPartNumber(right));
+    if (chartPaths.length !== charts.length) throw new Error(`PPTX chart export produced ${chartPaths.length} chart part(s) for ${charts.length} chart element(s).`);
+    for (const [index, path] of chartPaths.entries()){
+        const entry = archive.file(path);
+        if (!entry) continue;
+        const document = parseXml(await entry.async('text'), path);
+        const chartNode = CHART_TYPES.map((name)=>firstDescendant(document, name)).find(Boolean);
+        if (!chartNode) throw new Error(`PPTX chart part is missing a supported chart node: ${path}`);
+        writePptxChartDataLabels(document, chartNode, charts[index]);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxChartDataLabels(document, chartNode, chart) {
+    for (const element of directChildren(chartNode, 'dLbls'))element.remove();
+    for (const series of directChildren(chartNode, 'ser'))for (const element of directChildren(series, 'dLbls'))element.remove();
+    if (!chart.dataLabels) return;
+    const labels = normalizePresentationChartDataLabels(chart.dataLabels, chart.type);
+    const namespace = chartNode.namespaceURI;
+    const prefix = xmlNamespacePrefix(chartNode, namespace) ?? chartNode.prefix ?? 'c';
+    const container = document.createElementNS(namespace, `${prefix}:dLbls`);
+    appendChartElement(document, container, prefix, 'dLblPos', {
+        val: pptxDataLabelPositionValue(normalizePresentationChartDataLabelPosition(labels.position, chart.type))
+    });
+    appendChartElement(document, container, prefix, 'showLegendKey', {
+        val: '0'
+    });
+    appendChartElement(document, container, prefix, 'showVal', {
+        val: labels.showValue ? '1' : '0'
+    });
+    appendChartElement(document, container, prefix, 'showCatName', {
+        val: labels.showCategoryName ? '1' : '0'
+    });
+    appendChartElement(document, container, prefix, 'showSerName', {
+        val: labels.showSeriesName ? '1' : '0'
+    });
+    appendChartElement(document, container, prefix, 'showPercent', {
+        val: labels.showPercentage ? '1' : '0'
+    });
+    appendChartElement(document, container, prefix, 'showBubbleSize', {
+        val: labels.showBubbleSize ? '1' : '0'
+    });
+    if (void 0 !== labels.separator) {
+        const separator = appendChartElement(document, container, prefix, 'separator');
+        separator.textContent = labels.separator;
+    }
+    appendChartElement(document, container, prefix, 'showLeaderLines', {
+        val: '0'
+    });
+    const anchor = directChildren(chartNode).find((child)=>DATA_LABEL_ANCHORS.has(child.localName)) ?? null;
+    chartNode.insertBefore(container, anchor);
+}
+function appendChartElement(document, parent, prefix, localName, attributes = {}) {
+    const element = document.createElementNS(parent.namespaceURI, `${prefix}:${localName}`);
+    for (const [name, value] of Object.entries(attributes))element.setAttribute(name, value);
+    parent.append(element);
+    return element;
+}
+function pptxDataLabelPosition(value) {
+    if ('ctr' === value) return 'center';
+    if ('inBase' === value) return 'insideBase';
+    if ('inEnd' === value) return 'insideEnd';
+    if ('outEnd' === value) return 'outsideEnd';
+    if ('l' === value) return 'left';
+    if ('r' === value) return 'right';
+    if ('t' === value) return 'above';
+    if ('b' === value) return 'below';
+    if ('bestFit' === value) return 'bestFit';
+}
+function pptxDataLabelPositionValue(position) {
+    if ('center' === position) return 'ctr';
+    if ('insideBase' === position) return 'inBase';
+    if ('insideEnd' === position) return 'inEnd';
+    if ('outsideEnd' === position) return 'outEnd';
+    if ('left' === position) return 'l';
+    if ('right' === position) return 'r';
+    if ('above' === position) return 't';
+    if ('below' === position) return 'b';
+    return 'bestFit';
+}
+function pptxBooleanElement(parent, localName) {
+    const element = directChild(parent, localName);
+    if (!element) return false;
+    const value = attribute(element, 'val');
+    return null === value || '1' === value || 'true' === value.toLocaleLowerCase();
+}
+function dataLabelSignature(element) {
+    return [
+        attribute(directChild(element, 'dLblPos') ?? element, 'val') ?? '',
+        String(pptxBooleanElement(element, 'showVal')),
+        String(pptxBooleanElement(element, 'showCatName')),
+        String(pptxBooleanElement(element, 'showSerName')),
+        String(pptxBooleanElement(element, 'showPercent')),
+        String(pptxBooleanElement(element, 'showBubbleSize')),
+        directChild(element, 'separator')?.textContent ?? ''
+    ].join('|');
+}
+function chartPartNumber(path) {
+    return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
+}
+const work_pptx_chart_layout_style_CHART_TYPES = [
+    'barChart',
+    'lineChart',
+    'pieChart',
+    'doughnutChart',
+    'areaChart',
+    'radarChart',
+    'scatterChart',
+    'bubbleChart'
+];
+const work_pptx_chart_layout_style_DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+function readPptxChartLayoutAndSeriesStyles(document, chartNode, chartType, seriesNodes) {
+    const diagnostics = [];
+    const legend = firstDescendant(document, 'legend');
+    const parsedLegend = parseXlsxChartLegend(document);
+    if (legend && !isSupportedXlsxChartLegend(document)) diagnostics.push({
+        code: 'pptx.chart.format.legend',
+        message: 'Manual legend layout, entry overrides, or advanced legend formatting was normalized.'
+    });
+    const hasLayout = Boolean(chartNode && chartHasEditableLayoutElements(chartNode));
+    const layout = chartNode && hasLayout ? parseXlsxChartPlotLayout(chartNode, chartType) : {};
+    if (chartNode && hasLayout && !isSupportedXlsxChartPlotLayout(chartNode)) diagnostics.push({
+        code: 'pptx.chart.format.layout',
+        message: 'Invalid grouping, spacing, overlap, or mixed smoothing settings were normalized.'
+    });
+    const seriesStyles = seriesNodes.map((series)=>parseXlsxChartSeriesStyle(series));
+    if (chartNode && seriesNodes.some((series)=>!isSupportedXlsxChartSeriesFormatting(series, chartNode.localName) || directChildren(series, 'dPt').length > 0)) diagnostics.push({
+        code: 'pptx.chart.format.series',
+        message: 'Theme, gradient, pattern, effect, custom dash, or per-point series formatting was normalized to portable series appearance.'
+    });
+    if (!workSpreadsheetChartSupportsSeriesAnalysis({
+        type: chartType,
+        ...layout
+    }) && seriesNodes.some((series)=>directChild(series, 'trendline') || directChild(series, 'errBars'))) diagnostics.push({
+        code: 'pptx.chart.format.series-analysis',
+        message: 'Trendlines and error bars were removed because stacked chart layouts do not support series analysis.'
+    });
+    return {
+        ...legend ? {
+            legendOverlay: normalizeWorkSpreadsheetChartLegendOverlay(parsedLegend.legendOverlay)
+        } : {},
+        layout,
+        seriesStyles,
+        diagnostics
+    };
+}
+async function patchPptxChartLayoutAndSeriesStyles(buffer, slides) {
+    const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
+                element.chart
+            ] : []));
+    if (!charts.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const chartPaths = Object.keys(archive.files).filter((path)=>/^ppt\/charts\/chart\d+\.xml$/.test(path)).sort((left, right)=>work_pptx_chart_layout_style_chartPartNumber(left) - work_pptx_chart_layout_style_chartPartNumber(right));
+    if (chartPaths.length !== charts.length) throw new Error(`PPTX chart export produced ${chartPaths.length} chart part(s) for ${charts.length} chart element(s).`);
+    for (const [index, chart] of charts.entries()){
+        const path = chartPaths[index];
+        const entry = archive.file(path);
+        if (!entry) throw new Error(`PPTX chart export is missing chart part: ${path}`);
+        const document = parseXml(await entry.async('text'), path);
+        const chartNode = work_pptx_chart_layout_style_CHART_TYPES.map((name)=>firstDescendant(document, name)).find(Boolean);
+        if (!chartNode) throw new Error(`PPTX chart part is missing a supported chart node: ${path}`);
+        writePptxChartLayoutAndSeriesStyles(document, chartNode, chart);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxChartLayoutAndSeriesStyles(document, chartNode, chart) {
+    writeLegendOverlay(document, chart);
+    writePlotLayout(document, chartNode, chart);
+    const seriesNodes = directChildren(chartNode, 'ser');
+    if (seriesNodes.length !== chart.series.length) throw new Error(`PPTX chart export produced ${seriesNodes.length} native series for ${chart.series.length} editable series.`);
+    for (const [seriesIndex, seriesNode] of seriesNodes.entries())writeSeriesStyle(document, seriesNode, chart.series[seriesIndex].style, chart.type);
+}
+function writeLegendOverlay(document, chart) {
+    if (!chart.showLegend) return;
+    const chartRoot = firstDescendant(document, 'chart');
+    const legend = chartRoot ? directChild(chartRoot, 'legend') : void 0;
+    if (!legend) return;
+    for (const overlay of directChildren(legend, 'overlay'))overlay.remove();
+    const anchor = directChildren(legend).find((child)=>[
+            'spPr',
+            'txPr',
+            'extLst'
+        ].includes(child.localName)) ?? null;
+    insertChartSetting(document, legend, 'overlay', normalizeWorkSpreadsheetChartLegendOverlay(chart.legendOverlay) ? '1' : '0', anchor);
+}
+function writePlotLayout(document, chartNode, chart) {
+    if (workSpreadsheetChartSupportsGrouping(chart.type)) replaceChartSetting(document, chartNode, 'grouping', normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type), directChildren(chartNode).find((child)=>[
+            'varyColors',
+            'ser'
+        ].includes(child.localName)) ?? null);
+    if (workSpreadsheetChartSupportsBarSpacing(chart.type)) {
+        const grouping = normalizeWorkSpreadsheetChartGrouping(chart.grouping, chart.type);
+        for (const name of [
+            'gapWidth',
+            'overlap'
+        ])for (const child of directChildren(chartNode, name))child.remove();
+        const anchor = directChildren(chartNode).find((child)=>[
+                'axId',
+                'extLst'
+            ].includes(child.localName)) ?? null;
+        insertChartSetting(document, chartNode, 'gapWidth', String(normalizeWorkSpreadsheetChartGapWidth(chart.gapWidth)), anchor);
+        insertChartSetting(document, chartNode, 'overlap', String(normalizeWorkSpreadsheetChartOverlap(chart.overlap, grouping)), anchor);
+    }
+    if (workSpreadsheetChartSupportsSmoothLines(chart.type)) {
+        for (const child of directChildren(chartNode, 'smooth'))child.remove();
+        for (const series of directChildren(chartNode, 'ser'))for (const child of directChildren(series, 'smooth'))child.remove();
+        const anchor = directChildren(chartNode).find((child)=>[
+                'axId',
+                'extLst'
+            ].includes(child.localName)) ?? null;
+        insertChartSetting(document, chartNode, 'smooth', normalizeWorkSpreadsheetChartSmoothLines(chart.smoothLines) ? '1' : '0', anchor);
+    }
+}
+function writeSeriesStyle(document, seriesNode, source, chartType) {
+    const style = normalizePresentationChartSeriesStyle(source, chartType);
+    for (const shape of directChildren(seriesNode, 'spPr'))shape.remove();
+    for (const marker of directChildren(seriesNode, 'marker'))marker.remove();
+    if (!style) return;
+    const shapeXml = xlsxChartSeriesShapePropertiesXml(style);
+    if (shapeXml) {
+        const anchor = directChildren(seriesNode).find((child)=>[
+                'marker',
+                'dPt',
+                'dLbls',
+                'trendline',
+                'errBars',
+                'cat',
+                'xVal',
+                'val',
+                'yVal',
+                'bubbleSize',
+                'smooth',
+                'extLst'
+            ].includes(child.localName));
+        seriesNode.insertBefore(chartFragmentElement(document, seriesNode, shapeXml), anchor ?? null);
+    }
+    const normalized = normalizeWorkSpreadsheetChartSeriesStyle(style);
+    if (!normalized?.marker) return;
+    const markerXml = xlsxChartSeriesMarkerXml(style, true);
+    const anchor = directChildren(seriesNode).find((child)=>[
+            'dPt',
+            'dLbls',
+            'trendline',
+            'errBars',
+            'cat',
+            'xVal',
+            'val',
+            'yVal',
+            'bubbleSize',
+            'smooth',
+            'extLst'
+        ].includes(child.localName));
+    seriesNode.insertBefore(chartFragmentElement(document, seriesNode, markerXml), anchor ?? null);
+}
+function chartFragmentElement(document, parent, xml) {
+    const namespace = parent.namespaceURI ?? 'http://schemas.openxmlformats.org/drawingml/2006/chart';
+    const parsed = parseXml(`<c:root xmlns:c="${namespace}" xmlns:a="${work_pptx_chart_layout_style_DRAWING_NAMESPACE}">${xml}</c:root>`, 'PPTX chart formatting fragment');
+    const element = parsed.documentElement.firstElementChild;
+    if (!element) throw new Error('PPTX chart formatting fragment did not contain an element.');
+    return document.importNode(element, true);
+}
+function replaceChartSetting(document, parent, localName, value, anchor) {
+    for (const child of directChildren(parent, localName))child.remove();
+    insertChartSetting(document, parent, localName, value, anchor);
+}
+function insertChartSetting(document, parent, localName, value, anchor) {
+    const prefix = xmlNamespacePrefix(parent, parent.namespaceURI) ?? parent.prefix ?? 'c';
+    const element = document.createElementNS(parent.namespaceURI, `${prefix}:${localName}`);
+    element.setAttribute('val', value);
+    parent.insertBefore(element, anchor);
+    return element;
+}
+function chartHasEditableLayoutElements(chartNode) {
+    return [
+        'grouping',
+        'gapWidth',
+        'overlap'
+    ].some((name)=>directChildren(chartNode, name).length > 0) || 'lineChart' === chartNode.localName && (directChildren(chartNode, 'smooth').length > 0 || directChildren(chartNode, 'ser').some((series)=>directChildren(series, 'smooth').length > 0));
+}
+function work_pptx_chart_layout_style_chartPartNumber(path) {
+    return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
+}
+const work_pptx_chart_series_analysis_CHART_TYPES = [
+    'barChart',
+    'lineChart',
+    'pieChart',
+    'doughnutChart',
+    'areaChart',
+    'radarChart',
+    'scatterChart',
+    'bubbleChart'
+];
+function readPptxChartSeriesAnalysis(seriesNode, chartType) {
+    const diagnostics = [];
+    const trendlineNodes = directChildren(seriesNode, 'trendline');
+    const errorBarNodes = directChildren(seriesNode, 'errBars');
+    if (!workSpreadsheetChartSupportsTrendlines(chartType) && trendlineNodes.length || !workSpreadsheetChartSupportsErrorBars(chartType) && errorBarNodes.length) diagnostics.push({
+        code: 'pptx.chart.series-analysis-type',
+        message: 'Trendlines or error bars on this chart type were omitted because the editable chart type does not support them.'
+    });
+    const trendlines = workSpreadsheetChartSupportsTrendlines(chartType) ? trendlineNodes.flatMap((node)=>{
+        const trendline = parseXlsxTrendline(node);
+        if (!trendline) {
+            diagnostics.push({
+                code: 'pptx.chart.trendline-type',
+                message: 'An unsupported or incomplete trendline was omitted from the editable chart.'
+            });
+            return [];
+        }
+        readTrendlineDiagnostics(node, diagnostics);
+        return [
+            trendline
+        ];
+    }) : [];
+    const directions = new Set();
+    const errorBars = workSpreadsheetChartSupportsErrorBars(chartType) ? errorBarNodes.flatMap((node)=>{
+        const errorBar = parseXlsxErrorBars(node, chartType);
+        if (!errorBar) {
+            diagnostics.push({
+                code: 'pptx.chart.error-bars-type',
+                message: 'Unsupported or incomplete error-bar settings were omitted from the editable chart.'
+            });
+            return [];
+        }
+        if (directions.has(errorBar.direction)) {
+            diagnostics.push({
+                code: 'pptx.chart.error-bars-duplicate',
+                message: `Multiple ${errorBar.direction.toUpperCase()} error bars on one series were normalized to the first editable setting.`
+            });
+            return [];
+        }
+        directions.add(errorBar.direction);
+        readErrorBarDiagnostics(node, errorBar, diagnostics);
+        return [
+            errorBar
+        ];
+    }) : [];
+    return {
+        ...trendlines.length ? {
+            trendlines
+        } : {},
+        ...errorBars.length ? {
+            errorBars
+        } : {},
+        diagnostics
+    };
+}
+async function patchPptxChartSeriesAnalysis(buffer, slides) {
+    const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
+                element.chart
+            ] : []));
+    if (!charts.some(chartHasSeriesAnalysis)) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const chartPaths = Object.keys(archive.files).filter((path)=>/^ppt\/charts\/chart\d+\.xml$/.test(path)).sort((left, right)=>work_pptx_chart_series_analysis_chartPartNumber(left) - work_pptx_chart_series_analysis_chartPartNumber(right));
+    if (chartPaths.length !== charts.length) throw new Error(`PPTX chart export produced ${chartPaths.length} chart part(s) for ${charts.length} chart element(s).`);
+    for (const [index, chart] of charts.entries()){
+        const path = chartPaths[index];
+        const entry = archive.file(path);
+        if (!entry) throw new Error(`PPTX chart export is missing chart part: ${path}`);
+        const document = parseXml(await entry.async('text'), path);
+        const chartNode = work_pptx_chart_series_analysis_CHART_TYPES.map((name)=>firstDescendant(document, name)).find(Boolean);
+        if (!chartNode) throw new Error(`PPTX chart part is missing a supported chart node: ${path}`);
+        writePptxChartSeriesAnalysis(document, chartNode, chart);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxChartSeriesAnalysis(document, chartNode, chart) {
+    const seriesNodes = directChildren(chartNode, 'ser');
+    if (seriesNodes.length !== chart.series.length) throw new Error(`PPTX chart export produced ${seriesNodes.length} native series for ${chart.series.length} editable series.`);
+    for (const [seriesIndex, seriesNode] of seriesNodes.entries()){
+        for (const name of [
+            'trendline',
+            'errBars'
+        ])for (const child of directChildren(seriesNode, name))child.remove();
+        const series = chart.series[seriesIndex];
+        const anchor = directChildren(seriesNode).find((child)=>[
+                'cat',
+                'val',
+                'xVal',
+                'yVal',
+                'bubbleSize',
+                'smooth',
+                'extLst'
+            ].includes(child.localName)) ?? null;
+        if (workSpreadsheetChartSupportsSeriesAnalysis(chart) && workSpreadsheetChartSupportsTrendlines(chart.type)) for (const source of series.trendlines ?? [])seriesNode.insertBefore(createTrendlineElement(document, seriesNode, source), anchor);
+        if (workSpreadsheetChartSupportsSeriesAnalysis(chart) && workSpreadsheetChartSupportsErrorBars(chart.type)) {
+            const directions = new Set();
+            for (const source of series.errorBars ?? []){
+                const errorBars = normalizeWorkSpreadsheetErrorBars(source, chart.type);
+                if ('x' !== errorBars.direction || workSpreadsheetChartUsesNumericXAxis(chart.type)) {
+                    if (!directions.has(errorBars.direction)) {
+                        directions.add(errorBars.direction);
+                        seriesNode.insertBefore(createErrorBarsElement(document, seriesNode, errorBars), anchor);
+                    }
+                }
+            }
+        }
+    }
+}
+function readTrendlineDiagnostics(node, diagnostics) {
+    if (directChild(node, 'trendlineLbl')) diagnostics.push({
+        code: 'pptx.chart.trendline-label',
+        message: 'Manual trendline-label positioning and formatting were normalized to the editable equation and R-squared display.'
+    });
+    if ([
+        'spPr',
+        'extLst'
+    ].some((name)=>directChildren(node, name).length > 0)) diagnostics.push({
+        code: 'pptx.chart.trendline-format',
+        message: 'Advanced trendline styling and extensions are normalized by the editable chart model.'
+    });
+    const type = attribute(directChild(node, 'trendlineType') ?? node, 'val');
+    const parameter = 'poly' === type ? numericSetting(node, 'order') : 'movingAvg' === type ? numericSetting(node, 'period') : void 0;
+    const parameterInvalid = 'poly' === type && (void 0 === parameter || parameter < 2 || parameter > 6 || !Number.isInteger(parameter)) || 'movingAvg' === type && (void 0 === parameter || parameter < 2 || parameter > 255 || !Number.isInteger(parameter));
+    const forecastInvalid = [
+        'forward',
+        'backward'
+    ].some((name)=>{
+        const value = numericSetting(node, name);
+        return void 0 !== directChild(node, name) && (void 0 === value || value < 0);
+    });
+    if (parameterInvalid || forecastInvalid) diagnostics.push({
+        code: 'pptx.chart.trendline-parameter',
+        message: 'Trendline order, period, or forecast values were normalized to the editable range.'
+    });
+}
+function readErrorBarDiagnostics(node, errorBars, diagnostics) {
+    if ([
+        'spPr',
+        'extLst'
+    ].some((name)=>directChildren(node, name).length > 0)) diagnostics.push({
+        code: 'pptx.chart.error-bars-format',
+        message: 'Advanced error-bar styling and extensions are normalized by the editable chart model.'
+    });
+    const incompatibleCustomSource = 'custom' === errorBars.valueType && ('plus' === errorBars.barType && directChild(node, 'minus') || 'minus' === errorBars.barType && directChild(node, 'plus'));
+    const value = numericSetting(node, 'val');
+    const invalidValue = void 0 !== directChild(node, 'val') && (void 0 === value || value < 0) && 'standardError' !== errorBars.valueType && 'custom' !== errorBars.valueType;
+    if (incompatibleCustomSource || invalidValue) diagnostics.push({
+        code: 'pptx.chart.error-bars-value',
+        message: 'Error-bar values or custom sources were normalized to the editable direction and non-negative range.'
+    });
+}
+function createTrendlineElement(document, parent, source) {
+    const trendline = normalizeWorkSpreadsheetTrendline(source);
+    const container = createChartElement(document, parent, 'trendline');
+    if (trendline.name) appendTextElement(document, container, 'name', trendline.name);
+    appendSetting(document, container, 'trendlineType', trendlineTypeValue(trendline.type));
+    if ('polynomial' === trendline.type) appendSetting(document, container, 'order', trendline.order ?? 2);
+    if ('movingAverage' === trendline.type) appendSetting(document, container, 'period', trendline.period ?? 2);
+    if (trendline.forward) appendSetting(document, container, 'forward', trendline.forward);
+    if (trendline.backward) appendSetting(document, container, 'backward', trendline.backward);
+    if (void 0 !== trendline.intercept) appendSetting(document, container, 'intercept', trendline.intercept);
+    if (trendline.displayRSquared) appendSetting(document, container, 'dispRSq', 1);
+    if (trendline.displayEquation) appendSetting(document, container, 'dispEq', 1);
+    return container;
+}
+function createErrorBarsElement(document, parent, errorBars) {
+    const container = createChartElement(document, parent, 'errBars');
+    appendSetting(document, container, 'errDir', errorBars.direction);
+    appendSetting(document, container, 'errBarType', errorBars.barType);
+    appendSetting(document, container, 'errValType', errorBarValueType(errorBars.valueType));
+    if (false === errorBars.showEndCaps) appendSetting(document, container, 'noEndCap', 1);
+    if ('custom' === errorBars.valueType) {
+        if ('minus' !== errorBars.barType) appendCustomErrorSource(document, container, 'plus', errorBars.plusReference, errorBars.plusValues);
+        if ('plus' !== errorBars.barType) appendCustomErrorSource(document, container, 'minus', errorBars.minusReference, errorBars.minusValues);
+    } else if ('fixedValue' === errorBars.valueType || 'percentage' === errorBars.valueType || 'standardDeviation' === errorBars.valueType) appendSetting(document, container, 'val', errorBars.value ?? ('percentage' === errorBars.valueType ? 5 : 1));
+    return container;
+}
+function appendCustomErrorSource(document, parent, localName, reference, values) {
+    if (!reference?.trim() && !values?.length) return;
+    const container = work_pptx_chart_series_analysis_appendChartElement(document, parent, localName);
+    if (reference?.trim()) {
+        const numberReference = work_pptx_chart_series_analysis_appendChartElement(document, container, 'numRef');
+        appendTextElement(document, numberReference, 'f', reference.trim().replace(/^=/, ''));
+        if (values?.length) appendNumberCollection(document, numberReference, 'numCache', values);
+        return;
+    }
+    appendNumberCollection(document, container, 'numLit', values ?? []);
+}
+function appendNumberCollection(document, parent, localName, values) {
+    const collection = work_pptx_chart_series_analysis_appendChartElement(document, parent, localName);
+    appendTextElement(document, collection, 'formatCode', 'General');
+    appendSetting(document, collection, 'ptCount', values.length);
+    for (const [index, value] of values.entries()){
+        const point = appendSetting(document, collection, 'pt', index, 'idx');
+        appendTextElement(document, point, 'v', String(finiteNumber(value)));
+    }
+}
+function appendSetting(document, parent, localName, value, attributeName = 'val') {
+    const element = work_pptx_chart_series_analysis_appendChartElement(document, parent, localName);
+    element.setAttribute(attributeName, String(value));
+    return element;
+}
+function appendTextElement(document, parent, localName, value) {
+    const element = work_pptx_chart_series_analysis_appendChartElement(document, parent, localName);
+    element.textContent = value;
+    return element;
+}
+function work_pptx_chart_series_analysis_appendChartElement(document, parent, localName) {
+    const prefix = xmlNamespacePrefix(parent, parent.namespaceURI) ?? parent.prefix ?? 'c';
+    const element = document.createElementNS(parent.namespaceURI, `${prefix}:${localName}`);
+    parent.append(element);
+    return element;
+}
+function createChartElement(document, parent, localName) {
+    const prefix = xmlNamespacePrefix(parent, parent.namespaceURI) ?? parent.prefix ?? 'c';
+    return document.createElementNS(parent.namespaceURI, `${prefix}:${localName}`);
+}
+function trendlineTypeValue(type) {
+    if ('exponential' === type) return 'exp';
+    if ('logarithmic' === type) return 'log';
+    if ('polynomial' === type) return 'poly';
+    if ('movingAverage' === type) return 'movingAvg';
+    return type;
+}
+function errorBarValueType(type) {
+    if ('fixedValue' === type) return 'fixedVal';
+    if ('standardDeviation' === type) return 'stdDev';
+    if ('standardError' === type) return 'stdErr';
+    if ('custom' === type) return 'cust';
+    return 'percentage';
+}
+function chartHasSeriesAnalysis(chart) {
+    return workSpreadsheetChartSupportsSeriesAnalysis(chart) && chart.series.some((series)=>series.trendlines?.length || series.errorBars?.length);
+}
+function numericSetting(parent, localName) {
+    const element = directChild(parent, localName);
+    if (!element) return;
+    const value = Number(attribute(element, 'val'));
+    return Number.isFinite(value) ? value : void 0;
+}
+function finiteNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? number : 0;
+}
+function work_pptx_chart_series_analysis_chartPartNumber(path) {
+    return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
+}
+const EFFECT_TYPES = new Set([
+    'fade',
+    'push',
+    'wipe',
+    'split',
+    'cut'
+]);
+const CARDINAL_DIRECTIONS = {
+    l: 'left',
+    r: 'right',
+    u: 'up',
+    d: 'down'
+};
+const OOXML_DIRECTIONS = {
+    left: 'l',
+    right: 'r',
+    up: 'u',
+    down: 'd',
+    in: 'in',
+    out: 'out'
+};
+function readPptxTransition(document) {
+    const element = directChild(document.documentElement, 'transition');
+    if (!element) return {
+        present: false,
+        diagnostics: []
+    };
+    const diagnostics = [];
+    if (directChild(element, 'sndAc')) diagnostics.push({
+        code: 'pptx.transition.sound',
+        message: 'Transition sounds remain in the original PPTX only.'
+    });
+    const effect = directChildren(element).find((child)=>![
+            'sndAc',
+            'extLst'
+        ].includes(child.localName));
+    if (!effect || !EFFECT_TYPES.has(effect.localName)) {
+        diagnostics.push({
+            code: 'pptx.transition.type',
+            message: effect ? `The “${effect.localName}” slide transition remains in the original PPTX only.` : 'The source slide has a transition container without a supported effect.'
+        });
+        return {
+            present: true,
+            diagnostics
+        };
+    }
+    const base = createWorkSlideTransition(effect.localName);
+    const transition = {
+        ...base,
+        speed: readSpeed(element, diagnostics),
+        advanceOnClick: readBoolean(attribute(element, 'advClick'), true)
+    };
+    const advanceAfterMs = nonnegativeInteger(attribute(element, 'advTm'));
+    if (void 0 !== advanceAfterMs) transition.advanceAfterMs = advanceAfterMs;
+    else if (null !== attribute(element, 'advTm')) diagnostics.push({
+        code: 'pptx.transition.timing',
+        message: 'An invalid automatic-advance delay was ignored.'
+    });
+    if ('push' === transition.type || 'wipe' === transition.type) transition.direction = CARDINAL_DIRECTIONS[attribute(effect, 'dir') ?? ''] ?? 'left';
+    if ('split' === transition.type) {
+        transition.direction = 'in' === attribute(effect, 'dir') ? 'in' : 'out';
+        transition.orientation = 'vert' === attribute(effect, 'orient') ? 'vertical' : 'horizontal';
+    }
+    if (readBoolean(attribute(effect, 'thruBlk'), false)) diagnostics.push({
+        code: 'pptx.transition.through-black',
+        message: 'The through-black transition option is normalized to the basic effect.'
+    });
+    return {
+        present: true,
+        transition,
+        diagnostics
+    };
+}
+async function patchPptxTransitions(buffer, slides) {
+    if (!slides.some((slide)=>slide.transition)) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    for (const [index, slide] of slides.entries()){
+        const path = `ppt/slides/slide${index + 1}.xml`;
+        const entry = archive.file(path);
+        if (!entry) continue;
+        const document = parseXml(await entry.async('text'), path);
+        writePptxTransition(document, slide.transition);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxTransition(document, transition) {
+    const root = document.documentElement;
+    directChild(root, 'transition')?.remove();
+    if (!transition) return;
+    const namespace = root.namespaceURI;
+    const prefix = xmlNamespacePrefix(root, namespace) ?? root.prefix ?? 'p';
+    const element = document.createElementNS(namespace, `${prefix}:transition`);
+    element.setAttribute('spd', 'medium' === transition.speed ? 'med' : transition.speed);
+    element.setAttribute('advClick', transition.advanceOnClick ? '1' : '0');
+    if (void 0 !== transition.advanceAfterMs) element.setAttribute('advTm', String(Math.max(0, Math.trunc(transition.advanceAfterMs))));
+    const effect = document.createElementNS(namespace, `${prefix}:${transition.type}`);
+    if ('push' === transition.type || 'wipe' === transition.type) effect.setAttribute('dir', OOXML_DIRECTIONS[transition.direction ?? 'left'] ?? 'l');
+    if ('split' === transition.type) {
+        effect.setAttribute('orient', 'vertical' === transition.orientation ? 'vert' : 'horz');
+        effect.setAttribute('dir', 'in' === transition.direction ? 'in' : 'out');
+    }
+    element.append(effect);
+    const anchor = directChildren(root).find((child)=>[
+            'timing',
+            'extLst'
+        ].includes(child.localName)) ?? null;
+    root.insertBefore(element, anchor);
+}
+function readSpeed(element, diagnostics) {
+    const value = attribute(element, 'spd');
+    if ('fast' === value || 'slow' === value) return value;
+    if (null === value || 'med' === value) return 'medium';
+    diagnostics.push({
+        code: 'pptx.transition.speed',
+        message: `The transition speed “${value}” was normalized to medium.`
+    });
+    return 'medium';
+}
+function readBoolean(value, fallback) {
+    if (null === value) return fallback;
+    return '1' === value || 'true' === value.toLowerCase();
+}
+function nonnegativeInteger(value) {
+    if (null === value) return;
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : void 0;
+}
+export { loadPptxCommentAuthors, patchPptxChartDataLabels, patchPptxChartLayoutAndSeriesStyles, patchPptxChartSeriesAnalysis, patchPptxComments, patchPptxTransitions, readPptxChartDataLabels, readPptxChartLayoutAndSeriesStyles, readPptxChartSeriesAnalysis, readPptxSlideComments, readPptxTransition };