@a3s-lab/office 0.1.0

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

@@ -0,0 +1,1009 @@
+import jszip from "jszip";
+import { normalizeRadarStyle, presentationChartShowsLegend, presentationChartAxes, presentationChartBubbleSizes, normalizePresentationBubbleScale, presentationChartUsesNumericXAxis, normalizePresentationBubbleSizeRepresents, normalizePresentationChartLegendPosition, presentationChartXValues, normalizeDoughnutHoleSize, presentationChartSupportsAxisTitles, normalizePresentationScatterStyle } from "./0~work-presentation-charts.js";
+import { directChildren, xmlNamespacePrefix, parseXml, firstDescendant, workSpreadsheetChartAxisDefaultLabelPosition, workSpreadsheetChartAxisIsValueAxis, directChild, descendants, childPath, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, attribute, workSpreadsheetChartAxisIsCategoryAxis } from "./8715.js";
+import { presentationGroupPath, withPresentationDesign } from "./0~1403.js";
+import { patchPptxChartLayoutAndSeriesStyles, patchPptxTransitions, patchPptxComments, patchPptxChartDataLabels, patchPptxChartSeriesAnalysis } from "./0~7614.js";
+const DRAWING_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+async function patchPptxChartAxes(buffer, slides) {
+    const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
+                element.chart
+            ] : []));
+    if (!charts.some((chart)=>presentationChartAxes(chart))) 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, chart] of charts.entries()){
+        const axes = presentationChartAxes(chart);
+        if (!axes) continue;
+        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 plotArea = firstDescendant(document, 'plotArea');
+        if (!plotArea) throw new Error(`PPTX chart part is missing its plot area: ${path}`);
+        const bottom = findChartAxis(plotArea, 'bottom');
+        const left = findChartAxis(plotArea, 'left');
+        if (!bottom || !left) throw new Error(`PPTX chart part is missing an editable primary axis: ${path}`);
+        writePptxChartAxis(document, bottom, chart, 'bottom', axes.bottom);
+        writePptxChartAxis(document, left, chart, 'left', axes.left);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxChartAxis(document, axisNode, chart, position, axis) {
+    writeScaling(document, axisNode, axis, workSpreadsheetChartAxisIsValueAxis(chart.type, position));
+    replaceAxisTitle(document, axisNode, axis);
+    replaceAxisValueElement(document, axisNode, 'majorTickMark', nativeTickMark(axis?.majorTickMark), [
+        'minorTickMark',
+        'tickLblPos',
+        'spPr',
+        'txPr',
+        'crossAx',
+        'extLst'
+    ]);
+    replaceAxisValueElement(document, axisNode, 'tickLblPos', axis?.labelPosition ?? workSpreadsheetChartAxisDefaultLabelPosition(chart.type, position), [
+        'spPr',
+        'txPr',
+        'crossAx',
+        'extLst'
+    ]);
+    const valueAxis = workSpreadsheetChartAxisIsValueAxis(chart.type, position);
+    if (valueAxis) {
+        replaceAxisGridlines(document, axisNode, axis?.showMajorGridlines ?? workSpreadsheetChartAxisShowsMajorGridlinesByDefault(chart.type, position));
+        replaceAxisNumberFormat(document, axisNode, axis);
+        replaceAxisValueElement(document, axisNode, 'majorUnit', Number.isFinite(axis?.majorUnit) && Number(axis?.majorUnit) > 0 ? String(Number(axis?.majorUnit)) : void 0, [
+            'minorUnit',
+            'dispUnits',
+            'extLst'
+        ]);
+    }
+    if (workSpreadsheetChartAxisIsCategoryAxis(chart.type, position)) replaceAxisValueElement(document, axisNode, 'tickLblSkip', Number.isInteger(axis?.labelInterval) && Number(axis?.labelInterval) >= 1 ? String(Number(axis?.labelInterval)) : void 0, [
+        'tickMarkSkip',
+        'noMultiLvlLbl',
+        'extLst'
+    ]);
+}
+function findChartAxis(plotArea, position) {
+    const nativePosition = 'bottom' === position ? 'b' : 'l';
+    return directChildren(plotArea).find((child)=>('catAx' === child.localName || 'valAx' === child.localName || 'dateAx' === child.localName) && attribute(directChild(child, 'axPos') ?? child, 'val') === nativePosition);
+}
+function writeScaling(document, axisNode, axis, includeBounds) {
+    const scaling = directChild(axisNode, 'scaling') ?? createChartElement(document, axisNode, 'scaling');
+    if (!scaling.parentElement) {
+        const anchor = directChildren(axisNode).find((child)=>'axId' !== child.localName) ?? null;
+        axisNode.insertBefore(scaling, anchor);
+    }
+    for (const name of [
+        'orientation',
+        'max',
+        'min'
+    ])for (const child of directChildren(scaling, name))child.remove();
+    appendChartValue(document, scaling, 'orientation', axis?.reverseOrder ? 'maxMin' : 'minMax');
+    if (includeBounds && Number.isFinite(axis?.maximum)) appendChartValue(document, scaling, 'max', String(Number(axis?.maximum)));
+    if (includeBounds && Number.isFinite(axis?.minimum)) appendChartValue(document, scaling, 'min', String(Number(axis?.minimum)));
+}
+function replaceAxisGridlines(document, axisNode, visible) {
+    removeDirectChildren(axisNode, 'majorGridlines');
+    if (!visible) return;
+    const element = createChartElement(document, axisNode, 'majorGridlines');
+    insertBeforeNames(axisNode, element, [
+        'minorGridlines',
+        'title',
+        'numFmt',
+        'majorTickMark',
+        'minorTickMark',
+        'tickLblPos',
+        'spPr',
+        'txPr',
+        'crossAx',
+        'extLst'
+    ]);
+}
+function replaceAxisNumberFormat(document, axisNode, axis) {
+    removeDirectChildren(axisNode, 'numFmt');
+    const element = createChartElement(document, axisNode, 'numFmt');
+    const numberFormat = axis?.numberFormat?.trim();
+    element.setAttribute('formatCode', numberFormat || 'General');
+    element.setAttribute('sourceLinked', numberFormat ? axis?.numberFormatSourceLinked === true ? '1' : '0' : axis?.numberFormatSourceLinked === false ? '0' : '1');
+    insertBeforeNames(axisNode, element, [
+        'majorTickMark',
+        'minorTickMark',
+        'tickLblPos',
+        'spPr',
+        'txPr',
+        'crossAx',
+        'extLst'
+    ]);
+}
+function replaceAxisTitle(document, axisNode, axis) {
+    removeDirectChildren(axisNode, 'title');
+    const title = axis?.title?.trim();
+    const reference = axis?.titleReference?.trim().replace(/^=/, '');
+    if (!title && !reference) return;
+    const titleNode = createChartElement(document, axisNode, 'title');
+    const text = appendChartElement(document, titleNode, 'tx');
+    if (reference) {
+        const stringReference = appendChartElement(document, text, 'strRef');
+        appendChartText(document, stringReference, 'f', reference);
+        const cache = appendChartElement(document, stringReference, 'strCache');
+        appendChartValue(document, cache, 'ptCount', '1');
+        const point = appendChartValue(document, cache, 'pt', '0', 'idx');
+        appendChartText(document, point, 'v', title ?? '');
+    } else {
+        const rich = appendChartElement(document, text, 'rich');
+        appendDrawingElement(document, rich, 'bodyPr');
+        appendDrawingElement(document, rich, 'lstStyle');
+        const paragraph = appendDrawingElement(document, rich, 'p');
+        const run = appendDrawingElement(document, paragraph, 'r');
+        const runProperties = appendDrawingElement(document, run, 'rPr');
+        runProperties.setAttribute('lang', 'zh-CN');
+        runProperties.setAttribute('sz', '1400');
+        const textNode = appendDrawingElement(document, run, 't');
+        textNode.textContent = title ?? '';
+        const endProperties = appendDrawingElement(document, paragraph, 'endParaRPr');
+        endProperties.setAttribute('lang', 'zh-CN');
+    }
+    appendChartElement(document, titleNode, 'layout');
+    appendChartValue(document, titleNode, 'overlay', '0');
+    insertBeforeNames(axisNode, titleNode, [
+        'numFmt',
+        'majorTickMark',
+        'minorTickMark',
+        'tickLblPos',
+        'spPr',
+        'txPr',
+        'crossAx',
+        'extLst'
+    ]);
+}
+function replaceAxisValueElement(document, axisNode, localName, value, anchors) {
+    removeDirectChildren(axisNode, localName);
+    if (void 0 === value) return;
+    const element = createChartElement(document, axisNode, localName);
+    element.setAttribute('val', value);
+    insertBeforeNames(axisNode, element, anchors);
+}
+function nativeTickMark(value) {
+    if ('inside' === value) return 'in';
+    if ('outside' === value) return 'out';
+    if ('cross' === value) return 'cross';
+    return 'none';
+}
+function removeDirectChildren(parent, localName) {
+    for (const child of directChildren(parent, localName))child.remove();
+}
+function insertBeforeNames(parent, element, names) {
+    const anchor = directChildren(parent).find((child)=>names.includes(child.localName)) ?? null;
+    parent.insertBefore(element, anchor);
+}
+function appendChartValue(document, parent, localName, value, attributeName = 'val') {
+    const element = appendChartElement(document, parent, localName);
+    element.setAttribute(attributeName, value);
+    return element;
+}
+function appendChartText(document, parent, localName, value) {
+    const element = appendChartElement(document, parent, localName);
+    element.textContent = value;
+    return element;
+}
+function appendChartElement(document, parent, localName) {
+    const element = createChartElement(document, parent, 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 appendDrawingElement(document, parent, localName) {
+    const prefix = xmlNamespacePrefix(parent, DRAWING_NAMESPACE) ?? 'a';
+    const element = document.createElementNS(DRAWING_NAMESPACE, `${prefix}:${localName}`);
+    parent.append(element);
+    return element;
+}
+function chartPartNumber(path) {
+    return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
+}
+async function patchPptxChartXySettings(buffer, slides) {
+    const charts = slides.flatMap((slide)=>slide.elements.flatMap((element)=>'chart' === element.type && element.chart ? [
+                element.chart
+            ] : []));
+    if (!charts.some((chart)=>'scatter' === chart.type || 'bubble' === chart.type)) 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_xy_chartPartNumber(left) - work_pptx_chart_xy_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()){
+        if ('scatter' !== chart.type && 'bubble' !== chart.type) continue;
+        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 = firstDescendant(document, 'scatter' === chart.type ? 'scatterChart' : 'bubbleChart');
+        if (!chartNode) throw new Error(`PPTX chart part does not contain the expected ${chart.type} chart: ${path}`);
+        writePptxChartXySettings(document, chartNode, chart);
+        archive.file(path, new XMLSerializer().serializeToString(document));
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function writePptxChartXySettings(document, chartNode, chart) {
+    if ('scatter' === chart.type) return void replaceChartSetting(document, chartNode, 'scatterStyle', normalizePresentationScatterStyle(chart.scatterStyle), directChildren(chartNode).find((child)=>'scatterStyle' !== child.localName) ?? null);
+    if ('bubble' !== chart.type) return;
+    const anchor = directChildren(chartNode).find((child)=>'axId' === child.localName) ?? null;
+    for (const name of [
+        'bubble3D',
+        'bubbleScale',
+        'showNegBubbles',
+        'sizeRepresents'
+    ])for (const child of directChildren(chartNode, name))child.remove();
+    insertChartSetting(document, chartNode, 'bubble3D', '0', anchor);
+    insertChartSetting(document, chartNode, 'bubbleScale', String(normalizePresentationBubbleScale(chart.bubbleScale)), anchor);
+    insertChartSetting(document, chartNode, 'showNegBubbles', chart.showNegativeBubbles ? '1' : '0', anchor);
+    insertChartSetting(document, chartNode, 'sizeRepresents', 'width' === normalizePresentationBubbleSizeRepresents(chart.bubbleSizeRepresents) ? 'w' : 'area', anchor);
+    for (const series of directChildren(chartNode, 'ser')){
+        const bubble3D = directChild(series, 'bubble3D');
+        if (bubble3D) bubble3D.setAttribute('val', '0');
+    }
+}
+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 work_pptx_chart_xy_chartPartNumber(path) {
+    return Number(/chart(\d+)\.xml$/.exec(path)?.[1] ?? Number.MAX_SAFE_INTEGER);
+}
+const EXPORT_MARKER_PREFIX = '__A3S_OFFICE_EXPORT__';
+const PRESENTATIONML_NAMESPACE = 'http://schemas.openxmlformats.org/presentationml/2006/main';
+const DRAWINGML_NAMESPACE = 'http://schemas.openxmlformats.org/drawingml/2006/main';
+const GROUPABLE_PART = /^ppt\/(?:slides|slideLayouts|slideMasters)\/[^/]+\.xml$/;
+class PptxGroupExportRegistry {
+    bindings = new Map();
+    roleCounts = new Map();
+    markerSequence = 0;
+    get size() {
+        return this.bindings.size;
+    }
+    objectName(scope, element, role) {
+        const groupPath = presentationGroupPath(element);
+        if (!groupPath.length) return;
+        const roleCount = (this.roleCounts.get(role) ?? 0) + 1;
+        this.roleCounts.set(role, roleCount);
+        this.markerSequence += 1;
+        const marker = `${EXPORT_MARKER_PREFIX}${this.markerSequence}`;
+        this.bindings.set(marker, {
+            displayName: `${pptxRoleName(role)} ${roleCount}`,
+            groupPath,
+            groupScope: scope,
+            marker
+        });
+        return marker;
+    }
+    binding(marker) {
+        return this.bindings.get(marker);
+    }
+    values() {
+        return this.bindings.values();
+    }
+}
+async function patchPptxNativeGroups(buffer, registry) {
+    if (!registry.size) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const found = new Map();
+    const partPaths = Object.keys(archive.files).filter((path)=>GROUPABLE_PART.test(path)).sort();
+    for (const partPath of partPaths){
+        const entry = archive.file(partPath);
+        if (!entry) continue;
+        const source = await entry.async('text');
+        if (!source.includes(EXPORT_MARKER_PREFIX)) continue;
+        const document = parseXml(source, partPath);
+        let changed = false;
+        for (const shapeTree of descendants(document, 'spTree'))changed = patchPptxShapeTree(shapeTree, registry, found) || changed;
+        if (changed) archive.file(partPath, new XMLSerializer().serializeToString(document));
+    }
+    for (const binding of registry.values()){
+        const count = found.get(binding.marker) ?? 0;
+        if (1 !== count) throw new Error(`PPTX group export expected one generated object for ${binding.displayName}, but found ${count}.`);
+    }
+    return archive.generateAsync({
+        type: 'arraybuffer',
+        compression: 'DEFLATE'
+    });
+}
+function patchPptxShapeTree(shapeTree, registry, found) {
+    const sceneNodes = directChildren(shapeTree).filter(isPptxSceneNode).map((node, order)=>{
+        const properties = firstDescendant(node, 'cNvPr');
+        const objectName = properties ? attribute(properties, 'name') : null;
+        if (!objectName?.startsWith(EXPORT_MARKER_PREFIX)) return {
+            node,
+            order
+        };
+        const binding = registry.binding(objectName);
+        if (!binding) throw new Error(`PPTX group export found an unknown object marker in the generated package: ${objectName}.`);
+        found.set(binding.marker, (found.get(binding.marker) ?? 0) + 1);
+        properties?.setAttribute('name', binding.displayName);
+        return {
+            binding,
+            node,
+            order
+        };
+    });
+    if (!sceneNodes.some((item)=>item.binding)) return false;
+    const roots = new Map();
+    const rootNodes = sceneNodes.filter((item)=>!item.binding);
+    for (const item of sceneNodes){
+        if (!item.binding) continue;
+        let siblings = roots;
+        let bucket;
+        for (const groupId of item.binding.groupPath){
+            const key = groupBucketKey(item.binding.groupScope, groupId);
+            bucket = siblings.get(key);
+            if (!bucket) {
+                bucket = {
+                    children: new Map(),
+                    directNodes: [],
+                    order: item.order
+                };
+                siblings.set(key, bucket);
+            }
+            bucket.order = Math.max(bucket.order, item.order);
+            siblings = bucket.children;
+        }
+        bucket?.directNodes.push(item);
+    }
+    const nextId = pptxNonVisualIdFactory(shapeTree);
+    for (const item of sceneNodes)item.node.remove();
+    let groupNumber = 0;
+    const renderedRoots = [
+        ...rootNodes,
+        ...Array.from(roots.values()).map((bucket)=>({
+                node: renderPptxGroup(bucket, shapeTree.ownerDocument, nextId, ()=>{
+                    groupNumber += 1;
+                    return groupNumber;
+                }),
+                order: bucket.order
+            }))
+    ].sort((left, right)=>left.order - right.order);
+    const extensionList = directChild(shapeTree, 'extLst') ?? null;
+    for (const item of renderedRoots)shapeTree.insertBefore(item.node, extensionList);
+    normalizePptxNonVisualIds(shapeTree);
+    return true;
+}
+function renderPptxGroup(bucket, document, nextId, nextGroupNumber) {
+    const nonVisualId = nextId();
+    const groupNumber = nextGroupNumber();
+    const children = [
+        ...bucket.directNodes,
+        ...Array.from(bucket.children.values()).map((child)=>({
+                node: renderPptxGroup(child, document, nextId, nextGroupNumber),
+                order: child.order
+            }))
+    ].sort((left, right)=>left.order - right.order).map((item)=>item.node);
+    const bounds = unionPptxBounds(children.map(pptxNodeBounds));
+    const group = document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:grpSp');
+    const nonVisual = document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:nvGrpSpPr');
+    const properties = document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:cNvPr');
+    properties.setAttribute('id', String(nonVisualId));
+    properties.setAttribute('name', `Group ${groupNumber}`);
+    nonVisual.append(properties, document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:cNvGrpSpPr'), document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:nvPr'));
+    const groupProperties = document.createElementNS(PRESENTATIONML_NAMESPACE, 'p:grpSpPr');
+    groupProperties.append(pptxIdentityGroupTransform(document, bounds));
+    group.append(nonVisual, groupProperties, ...children);
+    return group;
+}
+function pptxIdentityGroupTransform(document, bounds) {
+    const transform = document.createElementNS(DRAWINGML_NAMESPACE, 'a:xfrm');
+    const x = Math.round(bounds.left);
+    const y = Math.round(bounds.top);
+    const width = Math.max(1, Math.round(bounds.right - bounds.left));
+    const height = Math.max(1, Math.round(bounds.bottom - bounds.top));
+    transform.append(pptxPositionNode(document, 'a:off', x, y), pptxExtentNode(document, 'a:ext', width, height), pptxPositionNode(document, 'a:chOff', x, y), pptxExtentNode(document, 'a:chExt', width, height));
+    return transform;
+}
+function pptxPositionNode(document, name, x, y) {
+    const node = document.createElementNS(DRAWINGML_NAMESPACE, name);
+    node.setAttribute('x', String(x));
+    node.setAttribute('y', String(y));
+    return node;
+}
+function pptxExtentNode(document, name, width, height) {
+    const node = document.createElementNS(DRAWINGML_NAMESPACE, name);
+    node.setAttribute('cx', String(width));
+    node.setAttribute('cy', String(height));
+    return node;
+}
+function pptxNodeBounds(node) {
+    const transform = ('grpSp' === node.localName ? childPath(node, 'grpSpPr', 'xfrm') : 'graphicFrame' === node.localName ? directChild(node, 'xfrm') : childPath(node, 'spPr', 'xfrm')) ?? firstDescendant(node, 'xfrm');
+    const offset = directChild(transform ?? node, 'off');
+    const extent = directChild(transform ?? node, 'ext');
+    const x = finitePptxCoordinate(offset, 'x');
+    const y = finitePptxCoordinate(offset, 'y');
+    const width = finitePptxCoordinate(extent, 'cx');
+    const height = finitePptxCoordinate(extent, 'cy');
+    if (void 0 === x || void 0 === y || void 0 === width || void 0 === height) {
+        const name = attribute(firstDescendant(node, 'cNvPr') ?? node, 'name');
+        throw new Error(`PPTX group export could not resolve generated geometry for ${name || node.localName}.`);
+    }
+    return {
+        left: x,
+        top: y,
+        right: x + width,
+        bottom: y + height
+    };
+}
+function unionPptxBounds(bounds) {
+    if (!bounds.length) throw new Error('PPTX group export cannot create an empty native group.');
+    return {
+        left: Math.min(...bounds.map((item)=>item.left)),
+        top: Math.min(...bounds.map((item)=>item.top)),
+        right: Math.max(...bounds.map((item)=>item.right)),
+        bottom: Math.max(...bounds.map((item)=>item.bottom))
+    };
+}
+function finitePptxCoordinate(node, name) {
+    if (!node) return;
+    const raw = attribute(node, name);
+    if (null === raw || '' === raw.trim()) return;
+    const value = Number(raw);
+    return Number.isFinite(value) ? value : void 0;
+}
+function pptxNonVisualIdFactory(shapeTree) {
+    const used = new Set(descendants(shapeTree, 'cNvPr').map((node)=>Number(attribute(node, 'id'))).filter((value)=>Number.isInteger(value) && value > 0));
+    let candidate = 1;
+    return ()=>{
+        while(used.has(candidate))candidate += 1;
+        const value = candidate;
+        used.add(value);
+        candidate += 1;
+        return value;
+    };
+}
+function normalizePptxNonVisualIds(shapeTree) {
+    const used = new Set();
+    let candidate = 1;
+    const nextId = ()=>{
+        while(used.has(candidate))candidate += 1;
+        const value = candidate;
+        used.add(value);
+        candidate += 1;
+        return value;
+    };
+    for (const properties of descendants(shapeTree, 'cNvPr')){
+        const current = Number(attribute(properties, 'id'));
+        if (Number.isInteger(current) && current > 0 && !used.has(current)) {
+            used.add(current);
+            continue;
+        }
+        properties.setAttribute('id', String(nextId()));
+    }
+}
+function groupBucketKey(scope, groupId) {
+    return `${scope}\u0000${groupId}`;
+}
+function isPptxSceneNode(node) {
+    return [
+        'contentPart',
+        'cxnSp',
+        'graphicFrame',
+        'grpSp',
+        'pic',
+        'sp'
+    ].includes(node.localName);
+}
+function pptxRoleName(role) {
+    if ('image' === role) return 'Picture';
+    return `${role[0]?.toUpperCase() ?? ''}${role.slice(1)}`;
+}
+function definePptxSlideLayouts(presentation, source, slideWidth, slideHeight, groups) {
+    const content = withPresentationDesign(source);
+    const bindings = new Map();
+    const usedNames = new Set();
+    for (const layout of content.layouts ?? []){
+        const master = content.masters?.find((candidate)=>candidate.id === layout.masterId);
+        const masterName = uniqueMasterName(layout.name, usedNames);
+        const placeholders = effectivePlaceholders(master, layout);
+        const inherited = scopedLayoutElements(master, layout).filter(({ element })=>!element.placeholder);
+        const groupedPlaceholders = placeholders.filter(({ element })=>presentationGroupPath(element).length);
+        const nativePlaceholders = placeholders.filter(({ element })=>!presentationGroupPath(element).length);
+        const placeholderNames = new Map(nativePlaceholders.map(({ element }, index)=>[
+                element.placeholder?.key ?? `placeholder:${index + 1}`,
+                placeholderName(element, index)
+            ]));
+        const objects = [
+            ...inherited.flatMap(({ element, groupScope })=>slideMasterObjects(element, slideWidth, slideHeight, groups, groupScope)),
+            ...groupedPlaceholders.flatMap(({ element, groupScope })=>slideMasterObjects(element, slideWidth, slideHeight, groups, groupScope)),
+            ...nativePlaceholders.map(({ element }, index)=>slideMasterPlaceholder(element, placeholderNames.get(element.placeholder?.key ?? `placeholder:${index + 1}`) ?? placeholderName(element, index), slideWidth, slideHeight))
+        ];
+        presentation.defineSlideMaster({
+            title: masterName,
+            background: {
+                color: colorValue(layout.background ?? master?.background ?? '#ffffff')
+            },
+            objects
+        });
+        bindings.set(layout.id, {
+            masterName,
+            placeholderNames
+        });
+    }
+    return {
+        content,
+        bindings
+    };
+}
+function effectivePlaceholders(master, layout) {
+    const placeholders = new Map();
+    for (const item of scopedLayoutElements(master, layout))if (item.element.placeholder) placeholders.set(item.element.placeholder.key, item);
+    return Array.from(placeholders.values());
+}
+function scopedLayoutElements(master, layout) {
+    return [
+        ...false === layout.showMasterElements ? [] : (master?.elements ?? []).map((element)=>({
+                element,
+                groupScope: `master:${master?.id ?? layout.masterId}`
+            })),
+        ...layout.elements.map((element)=>({
+                element,
+                groupScope: `layout:${layout.id}`
+            }))
+    ];
+}
+function slideMasterObjects(element, slideWidth, slideHeight, groups, groupScope) {
+    const box = elementBox(element, slideWidth, slideHeight);
+    if ('image' === element.type && element.image) {
+        const objectName = groups.objectName(groupScope, element, 'image');
+        return [
+            {
+                image: {
+                    data: element.image.dataUrl,
+                    ...box,
+                    rotate: element.rotation,
+                    altText: element.altText,
+                    ...objectName ? {
+                        objectName
+                    } : {}
+                }
+            }
+        ];
+    }
+    if ('line' === element.type) {
+        const objectName = groups.objectName(groupScope, element, 'line');
+        return [
+            {
+                line: {
+                    ...box,
+                    rotate: element.rotation,
+                    line: {
+                        color: colorValue(element.borderColor ?? element.color),
+                        width: element.borderWidth ?? 1
+                    },
+                    ...objectName ? {
+                        objectName
+                    } : {}
+                }
+            }
+        ];
+    }
+    if ('text' === element.type) {
+        const objectName = groups.objectName(groupScope, element, 'text');
+        return [
+            {
+                text: {
+                    text: element.text,
+                    options: textOptions(element, slideWidth, slideHeight, objectName)
+                }
+            }
+        ];
+    }
+    if ('shape' !== element.type) return [];
+    const shapeObjectName = groups.objectName(groupScope, element, 'shape');
+    const objects = [
+        {
+            rect: {
+                ...box,
+                rotate: element.rotation,
+                fill: 'transparent' === element.fill ? {
+                    color: 'FFFFFF',
+                    transparency: 100
+                } : {
+                    color: colorValue(element.fill),
+                    transparency: Math.round((1 - (element.opacity ?? 1)) * 100)
+                },
+                line: {
+                    color: colorValue(element.borderColor ?? element.fill),
+                    width: element.borderWidth ?? 0,
+                    transparency: element.borderWidth ? 0 : 100
+                },
+                ...shapeObjectName ? {
+                    objectName: shapeObjectName
+                } : {}
+            }
+        }
+    ];
+    if (element.text) {
+        const textObjectName = groups.objectName(groupScope, element, 'text');
+        objects.push({
+            text: {
+                text: element.text,
+                options: textOptions(element, slideWidth, slideHeight, textObjectName)
+            }
+        });
+    }
+    return objects;
+}
+function slideMasterPlaceholder(element, name, slideWidth, slideHeight) {
+    return {
+        placeholder: {
+            text: element.placeholder?.prompt ?? element.text,
+            options: {
+                name,
+                type: placeholderType(element.placeholder?.type),
+                ...textOptions(element, slideWidth, slideHeight)
+            }
+        }
+    };
+}
+function textOptions(element, slideWidth, slideHeight, objectName) {
+    return {
+        ...elementBox(element, slideWidth, slideHeight),
+        rotate: element.rotation,
+        fontFace: element.fontFamily ?? 'Aptos',
+        fontSize: Math.max(8, 0.75 * element.fontSize),
+        color: colorValue(element.color),
+        bold: element.bold,
+        italic: element.italic,
+        underline: element.underline ? {
+            style: 'sng'
+        } : void 0,
+        align: element.align,
+        valign: element.verticalAlign ?? 'middle',
+        margin: 0,
+        ...objectName ? {
+            objectName
+        } : {}
+    };
+}
+function elementBox(element, slideWidth, slideHeight) {
+    return {
+        x: element.x / 100 * slideWidth,
+        y: element.y / 100 * slideHeight,
+        w: element.width / 100 * slideWidth,
+        h: element.height / 100 * slideHeight
+    };
+}
+function placeholderName(element, index) {
+    const type = element.placeholder?.type || 'body';
+    const key = element.placeholder?.key.replace(/[^a-z0-9_-]/gi, '-') || `${index + 1}`;
+    return `A3S-${type}-${key}`;
+}
+function placeholderType(type) {
+    if ('title' === type || 'ctrTitle' === type) return 'title';
+    if ('pic' === type) return 'pic';
+    if ('chart' === type) return 'chart';
+    if ('tbl' === type) return 'tbl';
+    if ('media' === type) return 'media';
+    return 'body';
+}
+function uniqueMasterName(name, used) {
+    const base = name.trim() || 'Slide layout';
+    let candidate = base;
+    let index = 2;
+    while(used.has(candidate)){
+        candidate = `${base} ${index}`;
+        index += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function colorValue(color) {
+    return color.replace(/^#/, '').toUpperCase();
+}
+function createPptxExportState(artifact, PptxGenJS) {
+    if ('presentation' !== artifact.content.type) throw new Error('Only presentation artifacts can be exported as PPTX.');
+    const groups = new PptxGroupExportRegistry();
+    const presentation = new PptxGenJS();
+    const slideWidth = artifact.content.width ?? 13.333;
+    const slideHeight = artifact.content.height ?? 7.5;
+    presentation.defineLayout({
+        name: 'A3S_WORK',
+        width: slideWidth,
+        height: slideHeight
+    });
+    presentation.layout = 'A3S_WORK';
+    presentation.author = 'A3S Work';
+    presentation.subject = artifact.title;
+    presentation.title = artifact.title;
+    presentation.company = 'A3S Lab';
+    const design = definePptxSlideLayouts(presentation, artifact.content, slideWidth, slideHeight, groups);
+    for (const source of design.content.slides){
+        const binding = design.bindings.get(source.layoutId ?? '') ?? design.bindings.values().next().value;
+        const slide = binding ? presentation.addSlide({
+            masterName: binding.masterName
+        }) : presentation.addSlide();
+        if (!source.useLayoutBackground) slide.background = {
+            color: source.background.replace('#', '')
+        };
+        for (const element of source.elements)addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, `slide:${source.id}`, element.placeholder ? binding?.placeholderNames.get(element.placeholder.key) : void 0);
+        if (source.notes?.trim()) slide.addNotes(source.notes);
+    }
+    return {
+        groups,
+        presentation
+    };
+}
+async function createPptxBlob(artifact, PptxGenJS) {
+    const { groups, presentation } = createPptxExportState(artifact, PptxGenJS);
+    const output = await presentation.write({
+        outputType: 'arraybuffer',
+        compression: true
+    });
+    const buffer = await presentationArrayBuffer(output);
+    const slides = 'presentation' === artifact.content.type ? artifact.content.slides : [];
+    const withChartXySettings = await patchPptxChartXySettings(buffer, slides);
+    const withChartLayoutAndStyles = await patchPptxChartLayoutAndSeriesStyles(withChartXySettings, slides);
+    const withChartDataLabels = await patchPptxChartDataLabels(withChartLayoutAndStyles, slides);
+    const withChartAxes = await patchPptxChartAxes(withChartDataLabels, slides);
+    const withChartSeriesAnalysis = await patchPptxChartSeriesAnalysis(withChartAxes, slides);
+    const withTransitions = await patchPptxTransitions(withChartSeriesAnalysis, slides);
+    const withComments = await patchPptxComments(withTransitions, slides, 'presentation' === artifact.content.type ? artifact.content.width ?? 13.333 : 13.333, 'presentation' === artifact.content.type ? artifact.content.height ?? 7.5 : 7.5);
+    const patched = await patchPptxNativeGroups(withComments, groups);
+    return new Blob([
+        patched
+    ], {
+        type: 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
+    });
+}
+function addPresentationElement(slide, element, presentation, slideWidth, slideHeight, groups, groupScope, placeholder) {
+    const x = element.x / 100 * slideWidth;
+    const y = element.y / 100 * slideHeight;
+    const width = element.width / 100 * slideWidth;
+    const height = element.height / 100 * slideHeight;
+    const color = element.color.replace('#', '');
+    const fillColor = element.fill.replace('#', '');
+    const borderColor = (element.borderColor ?? element.fill).replace('#', '');
+    const rotation = element.rotation;
+    const resolvedPlaceholder = presentationGroupPath(element).length ? void 0 : placeholder;
+    if (element.placeholder && !element.text && !element.image && !element.table && !element.chart) return;
+    if ('image' === element.type && element.image) {
+        const objectName = groups.objectName(groupScope, element, 'image');
+        slide.addImage({
+            data: element.image.dataUrl,
+            x,
+            y,
+            w: width,
+            h: height,
+            rotate: rotation,
+            placeholder: resolvedPlaceholder,
+            ...objectName ? {
+                objectName
+            } : {}
+        });
+        return;
+    }
+    if ('table' === element.type && element.table) {
+        const objectName = groups.objectName(groupScope, element, 'table');
+        const options = {
+            x,
+            y,
+            w: width,
+            h: height,
+            border: {
+                color: borderColor,
+                pt: element.borderWidth ?? 1
+            },
+            color,
+            fill: {
+                color: fillColor
+            },
+            fontFace: element.fontFamily ?? 'Aptos',
+            fontSize: Math.max(7, 0.75 * element.fontSize),
+            margin: 0.06,
+            placeholder: resolvedPlaceholder,
+            ...objectName ? {
+                objectName
+            } : {}
+        };
+        slide.addTable(element.table.rows.map((row)=>row.map((text)=>({
+                    text
+                }))), options);
+        return;
+    }
+    if ('chart' === element.type && element.chart) {
+        const objectName = groups.objectName(groupScope, element, 'chart');
+        const axes = presentationChartAxes(element.chart);
+        const categoryAxis = 'bar' === element.chart.type ? axes?.left : axes?.bottom;
+        const valueAxis = 'bar' === element.chart.type ? axes?.bottom : axes?.left;
+        const chartType = 'scatter' === element.chart.type ? presentation.ChartType.scatter : 'bubble' === element.chart.type ? presentation.ChartType.bubble : 'line' === element.chart.type ? presentation.ChartType.line : 'pie' === element.chart.type ? presentation.ChartType.pie : 'doughnut' === element.chart.type ? presentation.ChartType.doughnut : 'radar' === element.chart.type ? presentation.ChartType.radar : 'area' === element.chart.type ? presentation.ChartType.area : presentation.ChartType.bar;
+        const options = {
+            x,
+            y,
+            w: width,
+            h: height,
+            catAxisLabelFontFace: element.fontFamily ?? 'Aptos',
+            chartColors: [
+                '4472C4',
+                'ED7D31',
+                'A5A5A5',
+                'FFC000',
+                '5B9BD5',
+                '70AD47'
+            ],
+            showLegend: presentationChartShowsLegend(element.chart),
+            legendPos: pptxLegendPosition(element.chart.legendPosition),
+            showTitle: Boolean(element.chart.title),
+            title: element.chart.title,
+            placeholder: resolvedPlaceholder,
+            ...objectName ? {
+                objectName
+            } : {},
+            ...presentationChartSupportsAxisTitles(element.chart) ? {
+                catAxisTitle: categoryAxis?.title,
+                showCatAxisTitle: Boolean(categoryAxis?.title),
+                valAxisTitle: valueAxis?.title,
+                showValAxisTitle: Boolean(valueAxis?.title)
+            } : {},
+            ...'column' === element.chart.type ? {
+                barDir: 'col'
+            } : {},
+            ...'doughnut' === element.chart.type ? {
+                holeSize: normalizeDoughnutHoleSize(element.chart.doughnutHoleSize)
+            } : {},
+            ...'radar' === element.chart.type ? {
+                radarStyle: normalizeRadarStyle(element.chart.radarStyle)
+            } : {},
+            ...'scatter' === element.chart.type ? pptxScatterOptions(element.chart) : {}
+        };
+        slide.addChart(chartType, pptxChartData(element.chart), options);
+        return;
+    }
+    if ('line' === element.type) {
+        const objectName = groups.objectName(groupScope, element, 'line');
+        slide.addShape(presentation.ShapeType.line, {
+            x,
+            y,
+            w: width,
+            h: height,
+            rotate: rotation,
+            line: {
+                color: borderColor,
+                width: element.borderWidth ?? 1
+            },
+            ...objectName ? {
+                objectName
+            } : {}
+        });
+        return;
+    }
+    if ('shape' === element.type) addShape(slide, element, presentation, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'shape'));
+    if (element.text) addText(slide, element, x, y, width, height, resolvedPlaceholder, groups.objectName(groupScope, element, 'text'));
+}
+function pptxChartData(chart) {
+    if (presentationChartUsesNumericXAxis(chart.type)) return [
+        {
+            name: 'X values',
+            values: presentationChartXValues(chart)
+        },
+        ...chart.series.map((series)=>({
+                name: series.name,
+                values: series.values,
+                ...'bubble' === chart.type ? {
+                    sizes: presentationChartBubbleSizes(series)
+                } : {}
+            }))
+    ];
+    return chart.series.map((series)=>({
+            name: series.name,
+            labels: chart.categories,
+            values: series.values
+        }));
+}
+function pptxScatterOptions(chart) {
+    const style = normalizePresentationScatterStyle(chart.scatterStyle);
+    return {
+        lineDataSymbol: 'line' === style || 'smooth' === style ? 'none' : 'circle',
+        lineSize: 'marker' === style ? 0 : 2,
+        lineSmooth: 'smooth' === style || 'smoothMarker' === style
+    };
+}
+function pptxLegendPosition(position) {
+    const normalized = normalizePresentationChartLegendPosition(position);
+    if ('left' === normalized) return 'l';
+    if ('top' === normalized) return 't';
+    if ('bottom' === normalized) return 'b';
+    if ('topRight' === normalized) return 'tr';
+    return 'r';
+}
+function addShape(slide, element, presentation, x, y, width, height, placeholder, objectName) {
+    const shapeType = 'ellipse' === element.shapeType ? presentation.ShapeType.ellipse : 'triangle' === element.shapeType ? presentation.ShapeType.triangle : 'diamond' === element.shapeType ? presentation.ShapeType.diamond : 'roundRect' === element.shapeType ? presentation.ShapeType.roundRect : presentation.ShapeType.rect;
+    const fillColor = element.fill.replace('#', '');
+    const borderColor = (element.borderColor ?? element.fill).replace('#', '');
+    const options = {
+        x,
+        y,
+        w: width,
+        h: height,
+        rotate: element.rotation,
+        placeholder,
+        ...objectName ? {
+            objectName
+        } : {},
+        fill: 'transparent' === element.fill ? {
+            color: 'FFFFFF',
+            transparency: 100
+        } : {
+            color: fillColor,
+            transparency: Math.round((1 - (element.opacity ?? 1)) * 100)
+        },
+        line: {
+            color: borderColor,
+            width: element.borderWidth ?? 0,
+            transparency: element.borderWidth ? 0 : 100
+        }
+    };
+    slide.addShape(shapeType, options);
+}
+function addText(slide, element, x, y, width, height, placeholder, objectName) {
+    const text = element.textRuns?.length ? element.textRuns.map((run)=>({
+            text: run.text,
+            options: {
+                fontFace: run.fontFamily ?? element.fontFamily ?? 'Aptos',
+                fontSize: Math.max(7, (run.fontSize ?? element.fontSize) * 0.75),
+                color: (run.color ?? element.color).replace('#', ''),
+                bold: run.bold,
+                italic: run.italic,
+                underline: run.underline ? {
+                    style: 'sng'
+                } : void 0,
+                hyperlink: run.href ? {
+                    url: run.href
+                } : void 0
+            }
+        })) : element.text;
+    slide.addText(text, {
+        x,
+        y,
+        w: width,
+        h: height,
+        rotate: element.rotation,
+        fontFace: element.fontFamily ?? 'Aptos',
+        fontSize: Math.max(8, 0.75 * element.fontSize),
+        color: element.color.replace('#', ''),
+        bold: element.bold,
+        italic: element.italic,
+        underline: element.underline ? {
+            style: 'sng'
+        } : void 0,
+        align: element.align,
+        valign: element.verticalAlign ?? 'middle',
+        margin: 'transparent' === element.fill ? 0 : 10,
+        breakLine: false,
+        fill: 'transparent' === element.fill ? void 0 : {
+            color: element.fill.replace('#', '')
+        },
+        hyperlink: element.href ? {
+            url: element.href
+        } : void 0,
+        placeholder,
+        ...objectName ? {
+            objectName
+        } : {}
+    });
+}
+async function presentationArrayBuffer(output) {
+    if (output instanceof ArrayBuffer) return output;
+    if (output instanceof Blob) return output.arrayBuffer();
+    if (output instanceof Uint8Array) return output.slice().buffer;
+    throw new Error('PowerPoint export returned an unsupported binary representation.');
+}
+export { createPptxBlob };