@8btc/ppt-generator-mcp 0.0.1

package/dist/export-pptx.js

@@ -0,0 +1,876 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportPPTX = void 0;
+const lodash_1 = require("lodash");
+const pptxgenjs_1 = __importDefault(require("pptxgenjs"));
+const tinycolor2_1 = __importDefault(require("tinycolor2"));
+const element_1 = require("./utils/element");
+const htmlParser_1 = require("./utils/htmlParser");
+const svgPathParser_1 = require("./utils/svgPathParser");
+const svg2Base64_1 = require("./utils/svg2Base64");
+const defaultFontSize = 16;
+// 导出PPTX文件
+const exportPPTX = (_slides, ignoreMedia, options) => {
+    const { viewportRatio, viewportSize } = options;
+    const pptx = new pptxgenjs_1.default();
+    if (viewportRatio === 0.625)
+        pptx.layout = "LAYOUT_16x10";
+    else if (viewportRatio === 0.75)
+        pptx.layout = "LAYOUT_4x3";
+    else if (viewportRatio === 0.70710678) {
+        pptx.defineLayout({ name: "A3", width: 10, height: 7.0710678 });
+        pptx.layout = "A3";
+    }
+    else if (viewportRatio === 1.41421356) {
+        pptx.defineLayout({ name: "A3_V", width: 10, height: 14.1421356 });
+        pptx.layout = "A3_V";
+    }
+    else
+        pptx.layout = "LAYOUT_16x9";
+    for (const slide of _slides) {
+        const pptxSlide = pptx.addSlide();
+        if (slide.background) {
+            const background = slide.background;
+            if (background.type === "image" && background.image) {
+                if (isSVGImage(background.image.src)) {
+                    pptxSlide.addImage({
+                        data: background.image.src,
+                        x: 0,
+                        y: 0,
+                        w: viewportSize / ratioPx2Inch(viewportSize),
+                        h: (viewportSize * viewportRatio) / ratioPx2Inch(viewportSize),
+                    });
+                }
+                else if (isBase64Image(background.image.src)) {
+                    pptxSlide.background = { data: background.image.src };
+                }
+                else {
+                    pptxSlide.background = { path: background.image.src };
+                }
+            }
+            else if (background.type === "solid" && background.color) {
+                const c = formatColor(background.color);
+                pptxSlide.background = {
+                    color: c.color,
+                    transparency: (1 - c.alpha) * 100,
+                };
+            }
+            else if (background.type === "gradient" && background.gradient) {
+                const colors = background.gradient.colors;
+                const color1 = colors[0].color;
+                const color2 = colors[colors.length - 1].color;
+                const color = tinycolor2_1.default.mix(color1, color2).toHexString();
+                const c = formatColor(color);
+                pptxSlide.background = {
+                    color: c.color,
+                    transparency: (1 - c.alpha) * 100,
+                };
+            }
+        }
+        if (slide.remark) {
+            const doc = new DOMParser().parseFromString(slide.remark, "text/html");
+            const pList = doc.body.querySelectorAll("p");
+            const text = [];
+            for (const p of pList) {
+                const textContent = p.textContent;
+                text.push(textContent || "");
+            }
+            pptxSlide.addNotes(text.join("\n"));
+        }
+        if (!slide.elements)
+            continue;
+        for (const el of slide.elements) {
+            if (el.type === "text") {
+                const textProps = formatHTML(el.content, viewportSize);
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                    fontSize: defaultFontSize / ratioPx2Pt(viewportSize),
+                    fontFace: "PingFang SC",
+                    color: "#000000",
+                    valign: "top",
+                    margin: 10 / ratioPx2Pt(viewportSize),
+                    paraSpaceBefore: 5 / ratioPx2Pt(viewportSize),
+                    lineSpacingMultiple: 1.5 / 1.25,
+                    autoFit: true,
+                };
+                if (el.rotate)
+                    options.rotate = el.rotate;
+                if (el.wordSpace)
+                    options.charSpacing = el.wordSpace / ratioPx2Pt(viewportSize);
+                if (el.lineHeight)
+                    options.lineSpacingMultiple = el.lineHeight / 1.25;
+                if (el.fill) {
+                    const c = formatColor(el.fill);
+                    const opacity = el.opacity === undefined ? 1 : el.opacity;
+                    options.fill = {
+                        color: c.color,
+                        transparency: (1 - c.alpha * opacity) * 100,
+                    };
+                }
+                if (el.defaultColor)
+                    options.color = formatColor(el.defaultColor).color;
+                if (el.defaultFontName)
+                    options.fontFace = el.defaultFontName;
+                if (el.shadow)
+                    options.shadow = getShadowOption(el.shadow, viewportSize);
+                if (el.outline?.width)
+                    options.line = getOutlineOption(el.outline, viewportSize);
+                if (el.opacity !== undefined)
+                    options.transparency = (1 - el.opacity) * 100;
+                if (el.paragraphSpace !== undefined)
+                    options.paraSpaceBefore =
+                        el.paragraphSpace / ratioPx2Pt(viewportSize);
+                if (el.vertical)
+                    options.vert = "eaVert";
+                pptxSlide.addText(textProps, options);
+            }
+            else if (el.type === "image") {
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                };
+                if (isBase64Image(el.src))
+                    options.data = el.src;
+                else
+                    options.path = el.src;
+                if (el.flipH)
+                    options.flipH = el.flipH;
+                if (el.flipV)
+                    options.flipV = el.flipV;
+                if (el.rotate)
+                    options.rotate = el.rotate;
+                if (el.link) {
+                    const linkOption = getLinkOption(el.link, _slides);
+                    if (linkOption)
+                        options.hyperlink = linkOption;
+                }
+                if (el.filters?.opacity)
+                    options.transparency = 100 - parseInt(el.filters?.opacity);
+                if (el.clip) {
+                    if (el.clip.shape === "ellipse")
+                        options.rounding = true;
+                    const [start, end] = el.clip.range;
+                    const [startX, startY] = start;
+                    const [endX, endY] = end;
+                    const originW = el.width / ((endX - startX) / ratioPx2Inch(viewportSize));
+                    const originH = el.height / ((endY - startY) / ratioPx2Inch(viewportSize));
+                    options.w = originW / ratioPx2Inch(viewportSize);
+                    options.h = originH / ratioPx2Inch(viewportSize);
+                    options.sizing = {
+                        type: "crop",
+                        x: ((startX / ratioPx2Inch(viewportSize)) * originW) /
+                            ratioPx2Inch(viewportSize),
+                        y: ((startY / ratioPx2Inch(viewportSize)) * originH) /
+                            ratioPx2Inch(viewportSize),
+                        w: (((endX - startX) / ratioPx2Inch(viewportSize)) * originW) /
+                            ratioPx2Inch(viewportSize),
+                        h: (((endY - startY) / ratioPx2Inch(viewportSize)) * originH) /
+                            ratioPx2Inch(viewportSize),
+                    };
+                }
+                pptxSlide.addImage(options);
+            }
+            else if (el.type === "shape") {
+                // if (el.special) {
+                //   const svgRef = document.querySelector(
+                //     `.thumbnail-list .base-element-${el.id} svg`
+                //   ) as HTMLElement;
+                //   if (svgRef.clientWidth < 1 || svgRef.clientHeight < 1) continue; // 临时处理（导入PPTX文件带来的异常数据）
+                //   const base64SVG = svg2Base64(svgRef);
+                //   const options: pptxgen.ImageProps = {
+                //     data: base64SVG,
+                //     x: el.left / ratioPx2Inch(viewportSize),
+                //     y: el.top / ratioPx2Inch(viewportSize),
+                //     w: el.width / ratioPx2Inch(viewportSize),
+                //     h: el.height / ratioPx2Inch(viewportSize),
+                //   };
+                //   if (el.rotate) options.rotate = el.rotate;
+                //   if (el.flipH) options.flipH = el.flipH;
+                //   if (el.flipV) options.flipV = el.flipV;
+                //   if (el.link) {
+                //     const linkOption = getLinkOption(el.link, _slides);
+                //     if (linkOption) options.hyperlink = linkOption;
+                //   }
+                //   pptxSlide.addImage(options);
+                // } else
+                {
+                    const scale = {
+                        x: el.width / el.viewBox[0],
+                        y: el.height / el.viewBox[1],
+                    };
+                    const points = formatPoints((0, svgPathParser_1.toPoints)(el.path), scale, viewportSize);
+                    let fillColor = formatColor(el.fill);
+                    if (el.gradient) {
+                        const colors = el.gradient.colors;
+                        const color1 = colors[0].color;
+                        const color2 = colors[colors.length - 1].color;
+                        const color = tinycolor2_1.default.mix(color1, color2).toHexString();
+                        fillColor = formatColor(color);
+                    }
+                    if (el.pattern)
+                        fillColor = formatColor("#00000000");
+                    const opacity = el.opacity === undefined ? 1 : el.opacity;
+                    const options = {
+                        x: el.left / ratioPx2Inch(viewportSize),
+                        y: el.top / ratioPx2Inch(viewportSize),
+                        w: el.width / ratioPx2Inch(viewportSize),
+                        h: el.height / ratioPx2Inch(viewportSize),
+                        fill: {
+                            color: fillColor.color,
+                            transparency: (1 - fillColor.alpha * opacity) * 100,
+                        },
+                        points,
+                    };
+                    if (el.flipH)
+                        options.flipH = el.flipH;
+                    if (el.flipV)
+                        options.flipV = el.flipV;
+                    if (el.shadow)
+                        options.shadow = getShadowOption(el.shadow, viewportSize);
+                    if (el.outline?.width)
+                        options.line = getOutlineOption(el.outline, viewportSize);
+                    if (el.rotate)
+                        options.rotate = el.rotate;
+                    if (el.link) {
+                        const linkOption = getLinkOption(el.link, _slides);
+                        if (linkOption)
+                            options.hyperlink = linkOption;
+                    }
+                    pptxSlide.addShape("custGeom", options);
+                }
+                if (el.text) {
+                    const textProps = formatHTML(el.text.content, viewportSize);
+                    const options = {
+                        x: el.left / ratioPx2Inch(viewportSize),
+                        y: el.top / ratioPx2Inch(viewportSize),
+                        w: el.width / ratioPx2Inch(viewportSize),
+                        h: el.height / ratioPx2Inch(viewportSize),
+                        fontSize: defaultFontSize / ratioPx2Pt(viewportSize),
+                        fontFace: "PingFang SC",
+                        color: "#000000",
+                        paraSpaceBefore: 5 / ratioPx2Pt(viewportSize),
+                        valign: el.text.align,
+                    };
+                    if (el.rotate)
+                        options.rotate = el.rotate;
+                    if (el.text.defaultColor)
+                        options.color = formatColor(el.text.defaultColor).color;
+                    if (el.text.defaultFontName)
+                        options.fontFace = el.text.defaultFontName;
+                    pptxSlide.addText(textProps, options);
+                }
+                if (el.pattern) {
+                    const options = {
+                        x: el.left / ratioPx2Inch(viewportSize),
+                        y: el.top / ratioPx2Inch(viewportSize),
+                        w: el.width / ratioPx2Inch(viewportSize),
+                        h: el.height / ratioPx2Inch(viewportSize),
+                    };
+                    if (isBase64Image(el.pattern))
+                        options.data = el.pattern;
+                    else
+                        options.path = el.pattern;
+                    if (el.flipH)
+                        options.flipH = el.flipH;
+                    if (el.flipV)
+                        options.flipV = el.flipV;
+                    if (el.rotate)
+                        options.rotate = el.rotate;
+                    if (el.link) {
+                        const linkOption = getLinkOption(el.link, _slides);
+                        if (linkOption)
+                            options.hyperlink = linkOption;
+                    }
+                    pptxSlide.addImage(options);
+                }
+            }
+            else if (el.type === "line") {
+                const path = (0, element_1.getLineElementPath)(el);
+                const points = formatPoints((0, svgPathParser_1.toPoints)(path), { x: 1, y: 1 }, viewportSize);
+                const { minX, maxX, minY, maxY } = (0, element_1.getElementRange)(el);
+                const c = formatColor(el.color);
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: (maxX - minX) / ratioPx2Inch(viewportSize),
+                    h: (maxY - minY) / ratioPx2Inch(viewportSize),
+                    line: {
+                        color: c.color,
+                        transparency: (1 - c.alpha) * 100,
+                        width: el.width / ratioPx2Pt(viewportSize),
+                        dashType: dashTypeMap[el.style],
+                        beginArrowType: el.points[0] ? "arrow" : "none",
+                        endArrowType: el.points[1] ? "arrow" : "none",
+                    },
+                    points,
+                };
+                if (el.shadow)
+                    options.shadow = getShadowOption(el.shadow, viewportSize);
+                pptxSlide.addShape("custGeom", options);
+            }
+            else if (el.type === "chart") {
+                const chartData = [];
+                for (let i = 0; i < el.data.series.length; i++) {
+                    const item = el.data.series[i];
+                    chartData.push({
+                        name: `系列${i + 1}`,
+                        labels: el.data.labels,
+                        values: item,
+                    });
+                }
+                let chartColors = [];
+                if (el.themeColors.length === 10)
+                    chartColors = el.themeColors.map((color) => formatColor(color).color);
+                else if (el.themeColors.length === 1)
+                    chartColors = (0, tinycolor2_1.default)(el.themeColors[0])
+                        .analogous(10)
+                        .map((color) => formatColor(color.toHexString()).color);
+                else {
+                    const len = el.themeColors.length;
+                    const supplement = (0, tinycolor2_1.default)(el.themeColors[len - 1])
+                        .analogous(10 + 1 - len)
+                        .map((color) => color.toHexString());
+                    chartColors = [
+                        ...el.themeColors.slice(0, len - 1),
+                        ...supplement,
+                    ].map((color) => formatColor(color).color);
+                }
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                    chartColors: el.chartType === "pie" || el.chartType === "ring"
+                        ? chartColors
+                        : chartColors.slice(0, el.data.series.length),
+                };
+                const textColor = formatColor(el.textColor || "#000000").color;
+                options.catAxisLabelColor = textColor;
+                options.valAxisLabelColor = textColor;
+                const fontSize = 14 / ratioPx2Pt(viewportSize);
+                options.catAxisLabelFontSize = fontSize;
+                options.valAxisLabelFontSize = fontSize;
+                if (el.fill || el.outline) {
+                    const plotArea = {};
+                    if (el.fill) {
+                        plotArea.fill = { color: formatColor(el.fill).color };
+                    }
+                    if (el.outline) {
+                        plotArea.border = {
+                            pt: el.outline.width / ratioPx2Pt(viewportSize),
+                            color: formatColor(el.outline.color).color,
+                        };
+                    }
+                    options.plotArea = plotArea;
+                }
+                if ((el.data.series.length > 1 && el.chartType !== "scatter") ||
+                    el.chartType === "pie" ||
+                    el.chartType === "ring") {
+                    options.showLegend = true;
+                    options.legendPos = "b";
+                    options.legendColor = textColor;
+                    options.legendFontSize = fontSize;
+                }
+                let type = pptx.ChartType.bar;
+                if (el.chartType === "bar") {
+                    type = pptx.ChartType.bar;
+                    options.barDir = "col";
+                    if (el.options?.stack)
+                        options.barGrouping = "stacked";
+                }
+                else if (el.chartType === "column") {
+                    type = pptx.ChartType.bar;
+                    options.barDir = "bar";
+                    if (el.options?.stack)
+                        options.barGrouping = "stacked";
+                }
+                else if (el.chartType === "line") {
+                    type = pptx.ChartType.line;
+                    if (el.options?.lineSmooth)
+                        options.lineSmooth = true;
+                }
+                else if (el.chartType === "area") {
+                    type = pptx.ChartType.area;
+                }
+                else if (el.chartType === "radar") {
+                    type = pptx.ChartType.radar;
+                }
+                else if (el.chartType === "scatter") {
+                    type = pptx.ChartType.scatter;
+                    options.lineSize = 0;
+                }
+                else if (el.chartType === "pie") {
+                    type = pptx.ChartType.pie;
+                }
+                else if (el.chartType === "ring") {
+                    type = pptx.ChartType.doughnut;
+                    options.holeSize = 60;
+                }
+                pptxSlide.addChart(type, chartData, options);
+            }
+            else if (el.type === "table") {
+                const hiddenCells = [];
+                for (let i = 0; i < el.data.length; i++) {
+                    const rowData = el.data[i];
+                    for (let j = 0; j < rowData.length; j++) {
+                        const cell = rowData[j];
+                        if (cell.colspan > 1 || cell.rowspan > 1) {
+                            for (let row = i; row < i + cell.rowspan; row++) {
+                                for (let col = row === i ? j + 1 : j; col < j + cell.colspan; col++)
+                                    hiddenCells.push(`${row}_${col}`);
+                            }
+                        }
+                    }
+                }
+                const tableData = [];
+                const theme = el.theme;
+                let themeColor = null;
+                let subThemeColors = [];
+                if (theme) {
+                    themeColor = formatColor(theme.color);
+                    subThemeColors = (0, element_1.getTableSubThemeColor)(theme.color).map((item) => formatColor(item));
+                }
+                for (let i = 0; i < el.data.length; i++) {
+                    const row = el.data[i];
+                    const _row = [];
+                    for (let j = 0; j < row.length; j++) {
+                        const cell = row[j];
+                        const cellOptions = {
+                            colspan: cell.colspan,
+                            rowspan: cell.rowspan,
+                            bold: cell.style?.bold || false,
+                            italic: cell.style?.em || false,
+                            underline: { style: cell.style?.underline ? "sng" : "none" },
+                            align: cell.style?.align || "left",
+                            valign: "middle",
+                            fontFace: cell.style?.fontname || "PingFang SC",
+                            fontSize: (cell.style?.fontsize ? parseInt(cell.style?.fontsize) : 14) /
+                                ratioPx2Pt(viewportSize),
+                        };
+                        if (theme && themeColor) {
+                            let c;
+                            if (i % 2 === 0)
+                                c = subThemeColors[1];
+                            else
+                                c = subThemeColors[0];
+                            if (theme.rowHeader && i === 0)
+                                c = themeColor;
+                            else if (theme.rowFooter && i === el.data.length - 1)
+                                c = themeColor;
+                            else if (theme.colHeader && j === 0)
+                                c = themeColor;
+                            else if (theme.colFooter && j === row.length - 1)
+                                c = themeColor;
+                            cellOptions.fill = {
+                                color: c.color,
+                                transparency: (1 - c.alpha) * 100,
+                            };
+                        }
+                        if (cell.style?.backcolor) {
+                            const c = formatColor(cell.style.backcolor);
+                            cellOptions.fill = {
+                                color: c.color,
+                                transparency: (1 - c.alpha) * 100,
+                            };
+                        }
+                        if (cell.style?.color)
+                            cellOptions.color = formatColor(cell.style.color).color;
+                        if (!hiddenCells.includes(`${i}_${j}`)) {
+                            _row.push({
+                                text: cell.text,
+                                options: cellOptions,
+                            });
+                        }
+                    }
+                    if (_row.length)
+                        tableData.push(_row);
+                }
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                    colW: el.colWidths.map((item) => (el.width * item) / ratioPx2Inch(viewportSize)),
+                };
+                if (el.theme)
+                    options.fill = { color: "#ffffff" };
+                if (el.outline.width && el.outline.color) {
+                    options.border = {
+                        type: el.outline.style === "solid" ? "solid" : "dash",
+                        pt: el.outline.width / ratioPx2Pt(viewportSize),
+                        color: formatColor(el.outline.color).color,
+                    };
+                }
+                pptxSlide.addTable(tableData, options);
+            }
+            else if (el.type === "latex") {
+                const svgRef = document.querySelector(`.thumbnail-list .base-element-${el.id} svg`);
+                const base64SVG = (0, svg2Base64_1.svg2Base64)(svgRef);
+                const options = {
+                    data: base64SVG,
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                };
+                if (el.link) {
+                    const linkOption = getLinkOption(el.link, _slides);
+                    if (linkOption)
+                        options.hyperlink = linkOption;
+                }
+                pptxSlide.addImage(options);
+            }
+            else if (!ignoreMedia && (el.type === "video" || el.type === "audio")) {
+                const options = {
+                    x: el.left / ratioPx2Inch(viewportSize),
+                    y: el.top / ratioPx2Inch(viewportSize),
+                    w: el.width / ratioPx2Inch(viewportSize),
+                    h: el.height / ratioPx2Inch(viewportSize),
+                    path: el.src,
+                    type: el.type,
+                };
+                if (el.type === "video" && el.poster)
+                    options.cover = el.poster;
+                const extMatch = el.src.match(/\.([a-zA-Z0-9]+)(?:[\?#]|$)/);
+                if (extMatch && extMatch[1])
+                    options.extn = extMatch[1];
+                else if (el.ext)
+                    options.extn = el.ext;
+                const videoExts = ["avi", "mp4", "m4v", "mov", "wmv"];
+                const audioExts = ["mp3", "m4a", "mp4", "wav", "wma"];
+                if (options.extn &&
+                    [...videoExts, ...audioExts].includes(options.extn)) {
+                    pptxSlide.addMedia(options);
+                }
+            }
+        }
+    }
+    return pptx;
+};
+exports.exportPPTX = exportPPTX;
+const ratioPx2Inch = (viewportSize) => {
+    return 96 * (viewportSize / 960);
+};
+const ratioPx2Pt = (viewportSize) => {
+    return (96 / 72) * (viewportSize / 960);
+};
+// 格式化颜色值为 透明度 + HexString，供pptxgenjs使用
+const formatColor = (_color) => {
+    if (!_color) {
+        return {
+            alpha: 0,
+            color: "#000000",
+        };
+    }
+    const c = (0, tinycolor2_1.default)(_color);
+    const alpha = c.getAlpha();
+    const color = alpha === 0 ? "#ffffff" : c.setAlpha(1).toHexString();
+    return {
+        alpha,
+        color,
+    };
+};
+// 将HTML字符串格式化为pptxgenjs所需的格式
+// 核心思路：将HTML字符串按样式分片平铺，每个片段需要继承祖先元素的样式信息，遇到块级元素需要换行
+const formatHTML = (html, viewportSize) => {
+    const ast = (0, htmlParser_1.toAST)(html);
+    let bulletFlag = false;
+    let indent = 0;
+    const slices = [];
+    const parse = (obj, baseStyleObj = {}) => {
+        for (const item of obj) {
+            const isBlockTag = "tagName" in item && ["div", "li", "p"].includes(item.tagName);
+            if (isBlockTag && slices.length) {
+                const lastSlice = slices[slices.length - 1];
+                if (!lastSlice.options)
+                    lastSlice.options = {};
+                lastSlice.options.breakLine = true;
+            }
+            const styleObj = { ...baseStyleObj };
+            const styleAttr = "attributes" in item
+                ? item.attributes.find((attr) => attr.key === "style")
+                : null;
+            if (styleAttr && styleAttr.value) {
+                const styleArr = styleAttr.value.split(";");
+                for (const styleItem of styleArr) {
+                    const [_key, _value] = styleItem.split(": ");
+                    const [key, value] = [(0, lodash_1.trim)(_key), (0, lodash_1.trim)(_value)];
+                    if (key && value)
+                        styleObj[key] = value;
+                }
+            }
+            if ("tagName" in item) {
+                if (item.tagName === "em") {
+                    styleObj["font-style"] = "italic";
+                }
+                if (item.tagName === "strong") {
+                    styleObj["font-weight"] = "bold";
+                }
+                if (item.tagName === "sup") {
+                    styleObj["vertical-align"] = "super";
+                }
+                if (item.tagName === "sub") {
+                    styleObj["vertical-align"] = "sub";
+                }
+                if (item.tagName === "a") {
+                    const attr = item.attributes.find((attr) => attr.key === "href");
+                    styleObj["href"] = attr?.value || "";
+                }
+                if (item.tagName === "ul") {
+                    styleObj["list-type"] = "ul";
+                }
+                if (item.tagName === "ol") {
+                    styleObj["list-type"] = "ol";
+                }
+                if (item.tagName === "li") {
+                    bulletFlag = true;
+                }
+                if (item.tagName === "p") {
+                    if ("attributes" in item) {
+                        const dataIndentAttr = item.attributes.find((attr) => attr.key === "data-indent");
+                        if (dataIndentAttr && dataIndentAttr.value)
+                            indent = +dataIndentAttr.value;
+                    }
+                }
+            }
+            if ("tagName" in item && item.tagName === "br") {
+                slices.push({ text: "", options: { breakLine: true } });
+            }
+            else if ("content" in item) {
+                const text = item.content
+                    .replace(/&nbsp;/g, " ")
+                    .replace(/&gt;/g, ">")
+                    .replace(/&lt;/g, "<")
+                    .replace(/&amp;/g, "&")
+                    .replace(/\n/g, "");
+                const options = {};
+                if (styleObj["font-size"]) {
+                    options.fontSize =
+                        parseInt(styleObj["font-size"]) / ratioPx2Pt(viewportSize);
+                }
+                if (styleObj["color"]) {
+                    options.color = formatColor(styleObj["color"]).color;
+                }
+                if (styleObj["background-color"]) {
+                    options.highlight = formatColor(styleObj["background-color"]).color;
+                }
+                if (styleObj["text-decoration-line"]) {
+                    if (styleObj["text-decoration-line"].indexOf("underline") !== -1) {
+                        options.underline = {
+                            color: options.color || "#000000",
+                            style: "sng",
+                        };
+                    }
+                    if (styleObj["text-decoration-line"].indexOf("line-through") !== -1) {
+                        options.strike = "sngStrike";
+                    }
+                }
+                if (styleObj["text-decoration"]) {
+                    if (styleObj["text-decoration"].indexOf("underline") !== -1) {
+                        options.underline = {
+                            color: options.color || "#000000",
+                            style: "sng",
+                        };
+                    }
+                    if (styleObj["text-decoration"].indexOf("line-through") !== -1) {
+                        options.strike = "sngStrike";
+                    }
+                }
+                if (styleObj["vertical-align"]) {
+                    if (styleObj["vertical-align"] === "super")
+                        options.superscript = true;
+                    if (styleObj["vertical-align"] === "sub")
+                        options.subscript = true;
+                }
+                if (styleObj["text-align"])
+                    options.align = styleObj["text-align"];
+                if (styleObj["font-weight"])
+                    options.bold = styleObj["font-weight"] === "bold";
+                if (styleObj["font-style"])
+                    options.italic = styleObj["font-style"] === "italic";
+                if (styleObj["font-family"])
+                    options.fontFace = styleObj["font-family"];
+                if (styleObj["href"])
+                    options.hyperlink = { url: styleObj["href"] };
+                if (bulletFlag && styleObj["list-type"] === "ol") {
+                    options.bullet = {
+                        type: "number",
+                        indent: (options.fontSize || defaultFontSize) * 1.25,
+                    };
+                    options.paraSpaceBefore = 0.1;
+                    bulletFlag = false;
+                }
+                if (bulletFlag && styleObj["list-type"] === "ul") {
+                    options.bullet = {
+                        indent: (options.fontSize || defaultFontSize) * 1.25,
+                    };
+                    options.paraSpaceBefore = 0.1;
+                    bulletFlag = false;
+                }
+                if (indent) {
+                    options.indentLevel = indent;
+                    indent = 0;
+                }
+                slices.push({ text, options });
+            }
+            else if ("children" in item)
+                parse(item.children, styleObj);
+        }
+    };
+    parse(ast);
+    return slices;
+};
+// 将SVG路径信息格式化为pptxgenjs所需要的格式
+const formatPoints = (points, scale = { x: 1, y: 1 }, viewportSize) => {
+    return points.map((point) => {
+        if (point.close !== undefined) {
+            return { close: true };
+        }
+        else if (point.type === "M") {
+            return {
+                x: (point.x / ratioPx2Inch(viewportSize)) * scale.x,
+                y: (point.y / ratioPx2Inch(viewportSize)) * scale.y,
+                moveTo: true,
+            };
+        }
+        else if (point.curve) {
+            if (point.curve.type === "cubic") {
+                return {
+                    x: (point.x / ratioPx2Inch(viewportSize)) * scale.x,
+                    y: (point.y / ratioPx2Inch(viewportSize)) * scale.y,
+                    curve: {
+                        type: "cubic",
+                        x1: (point.curve.x1 / ratioPx2Inch(viewportSize)) *
+                            scale.x,
+                        y1: (point.curve.y1 / ratioPx2Inch(viewportSize)) *
+                            scale.y,
+                        x2: (point.curve.x2 / ratioPx2Inch(viewportSize)) *
+                            scale.x,
+                        y2: (point.curve.y2 / ratioPx2Inch(viewportSize)) *
+                            scale.y,
+                    },
+                };
+            }
+            else if (point.curve.type === "quadratic") {
+                return {
+                    x: (point.x / ratioPx2Inch(viewportSize)) * scale.x,
+                    y: (point.y / ratioPx2Inch(viewportSize)) * scale.y,
+                    curve: {
+                        type: "quadratic",
+                        x1: (point.curve.x1 / ratioPx2Inch(viewportSize)) *
+                            scale.x,
+                        y1: (point.curve.y1 / ratioPx2Inch(viewportSize)) *
+                            scale.y,
+                    },
+                };
+            }
+        }
+        return {
+            x: (point.x / ratioPx2Inch(viewportSize)) * scale.x,
+            y: (point.y / ratioPx2Inch(viewportSize)) * scale.y,
+        };
+    });
+};
+// 获取阴影配置
+const getShadowOption = (shadow, viewportSize) => {
+    const c = formatColor(shadow.color);
+    const { h, v } = shadow;
+    let offset = 4;
+    let angle = 45;
+    if (h === 0 && v === 0) {
+        offset = 4;
+        angle = 45;
+    }
+    else if (h === 0) {
+        if (v > 0) {
+            offset = v;
+            angle = 90;
+        }
+        else {
+            offset = -v;
+            angle = 270;
+        }
+    }
+    else if (v === 0) {
+        if (h > 0) {
+            offset = h;
+            angle = 1;
+        }
+        else {
+            offset = -h;
+            angle = 180;
+        }
+    }
+    else if (h > 0 && v > 0) {
+        offset = Math.max(h, v);
+        angle = 45;
+    }
+    else if (h > 0 && v < 0) {
+        offset = Math.max(h, -v);
+        angle = 315;
+    }
+    else if (h < 0 && v > 0) {
+        offset = Math.max(-h, v);
+        angle = 135;
+    }
+    else if (h < 0 && v < 0) {
+        offset = Math.max(-h, -v);
+        angle = 225;
+    }
+    return {
+        type: "outer",
+        color: c.color.replace("#", ""),
+        opacity: c.alpha,
+        blur: shadow.blur / ratioPx2Pt(viewportSize),
+        offset,
+        angle,
+    };
+};
+const dashTypeMap = {
+    solid: "solid",
+    dashed: "dash",
+    dotted: "sysDot",
+};
+// 获取边框配置
+const getOutlineOption = (outline, viewportSize) => {
+    const c = formatColor(outline?.color || "#000000");
+    return {
+        color: c.color,
+        transparency: (1 - c.alpha) * 100,
+        width: (outline.width || 1) / ratioPx2Pt(viewportSize),
+        dashType: outline.style
+            ? dashTypeMap[outline.style]
+            : "solid",
+    };
+};
+// 获取超链接配置
+const getLinkOption = (link, slides) => {
+    const { type, target } = link;
+    if (type === "web")
+        return { url: target };
+    if (type === "slide") {
+        const index = slides.findIndex((slide) => slide.id === target);
+        if (index !== -1)
+            return { slide: index + 1 };
+    }
+    return null;
+};
+// 判断是否为Base64图片地址
+const isBase64Image = (url) => {
+    const regex = /^data:image\/[^;]+;base64,/;
+    return url.match(regex) !== null;
+};
+// 判断是否为SVG图片地址
+const isSVGImage = (url) => {
+    const isSVGBase64 = /^data:image\/svg\+xml;base64,/.test(url);
+    const isSVGUrl = /\.svg$/.test(url);
+    return isSVGBase64 || isSVGUrl;
+};