json2pptx 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1141 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ENABLE_DECK_JSON: () => ENABLE_DECK_JSON,
+  PPTX_JSON_PAYLOAD_PATH: () => PPTX_JSON_PAYLOAD_PATH,
+  PPTX_JSON_PAYLOAD_VERSION: () => PPTX_JSON_PAYLOAD_VERSION,
+  buildPptxBlob: () => buildPptxBlob,
+  getElementRange: () => getElementRange,
+  getLineElementPath: () => getLineElementPath,
+  resolveImageData: () => resolveImageData
+});
+module.exports = __toCommonJS(index_exports);
+var import_pptxgenjs = __toESM(require("pptxgenjs"));
+var import_jszip = __toESM(require("jszip"));
+var import_tinycolor2 = __toESM(require("tinycolor2"));
+
+// lib/resolveImageData.ts
+var dataUrlRegex = /^data:image\/[^;]+;base64,/;
+var mimeFromPath = (path) => {
+  const lower = path.toLowerCase();
+  if (lower.endsWith(".png")) return "image/png";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
+  if (lower.endsWith(".gif")) return "image/gif";
+  if (lower.endsWith(".svg")) return "image/svg+xml";
+  if (lower.endsWith(".webp")) return "image/webp";
+  if (lower.endsWith(".bmp")) return "image/bmp";
+  return "application/octet-stream";
+};
+var toBase64 = (buffer) => {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(buffer).toString("base64");
+  }
+  let binary = "";
+  const bytes = new Uint8Array(buffer);
+  const len = bytes.byteLength;
+  for (let i = 0; i < len; i += 1) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+};
+var readLocalFile = async (path) => {
+  const fs = await import("fs/promises");
+  const buffer = await fs.readFile(path);
+  return buffer.toString("base64");
+};
+var resolveImageData = async (src) => {
+  var _a;
+  if (dataUrlRegex.test(src)) return src;
+  const isFileUrl = src.startsWith("file://");
+  const isLocalPath = !src.startsWith("http") && !src.startsWith("data:");
+  const isNode = typeof process !== "undefined" && Boolean((_a = process.versions) == null ? void 0 : _a.node);
+  if ((isFileUrl || isLocalPath) && isNode) {
+    const filePath = isFileUrl ? src.replace("file://", "") : src;
+    const base642 = await readLocalFile(filePath);
+    const mime = mimeFromPath(filePath);
+    return `data:${mime};base64,${base642}`;
+  }
+  if (typeof fetch !== "function") {
+    throw new Error("fetch is not available to resolve image data");
+  }
+  const response = await fetch(src);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch image: ${response.status} ${response.statusText}`);
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const base64 = toBase64(arrayBuffer);
+  const contentType = response.headers.get("content-type") || mimeFromPath(src);
+  return `data:${contentType};base64,${base64}`;
+};
+
+// lib/htmlParser/tags.ts
+var childlessTags = ["style", "script", "template"];
+var closingTags = [
+  "html",
+  "head",
+  "body",
+  "p",
+  "dt",
+  "dd",
+  "li",
+  "option",
+  "thead",
+  "th",
+  "tbody",
+  "tr",
+  "td",
+  "tfoot",
+  "colgroup"
+];
+var closingTagAncestorBreakers = {
+  li: ["ul", "ol", "menu"],
+  dt: ["dl"],
+  dd: ["dl"],
+  tbody: ["table"],
+  thead: ["table"],
+  tfoot: ["table"],
+  tr: ["table"],
+  td: ["table"]
+};
+var voidTags = [
+  "!doctype",
+  "area",
+  "base",
+  "br",
+  "col",
+  "command",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+
+// lib/htmlParser/lexer.ts
+var jumpPosition = (state, end) => {
+  const len = end - state.position;
+  movePosition(state, len);
+};
+var movePosition = (state, len) => {
+  state.position = state.position + len;
+};
+var findTextEnd = (str, index) => {
+  const isEnd = false;
+  while (!isEnd) {
+    const textEnd = str.indexOf("<", index);
+    if (textEnd === -1) {
+      return textEnd;
+    }
+    const char = str.charAt(textEnd + 1);
+    if (char === "/" || char === "!" || /[A-Za-z0-9]/.test(char)) {
+      return textEnd;
+    }
+    index = textEnd + 1;
+  }
+  return -1;
+};
+var lexText = (state) => {
+  const { str } = state;
+  let textEnd = findTextEnd(str, state.position);
+  if (textEnd === state.position) return;
+  if (textEnd === -1) {
+    textEnd = str.length;
+  }
+  const content = str.slice(state.position, textEnd);
+  jumpPosition(state, textEnd);
+  state.tokens.push({
+    type: "text",
+    content
+  });
+};
+var lexComment = (state) => {
+  const { str } = state;
+  movePosition(state, 4);
+  let contentEnd = str.indexOf("-->", state.position);
+  let commentEnd = contentEnd + 3;
+  if (contentEnd === -1) {
+    contentEnd = commentEnd = str.length;
+  }
+  const content = str.slice(state.position, contentEnd);
+  jumpPosition(state, commentEnd);
+  state.tokens.push({
+    type: "comment",
+    content
+  });
+};
+var lexTagName = (state) => {
+  const { str } = state;
+  const len = str.length;
+  let start = state.position;
+  while (start < len) {
+    const char = str.charAt(start);
+    const isTagChar = !(/\s/.test(char) || char === "/" || char === ">");
+    if (isTagChar) break;
+    start++;
+  }
+  let end = start + 1;
+  while (end < len) {
+    const char = str.charAt(end);
+    const isTagChar = !(/\s/.test(char) || char === "/" || char === ">");
+    if (!isTagChar) break;
+    end++;
+  }
+  jumpPosition(state, end);
+  const tagName = str.slice(start, end);
+  state.tokens.push({
+    type: "tag",
+    content: tagName
+  });
+  return tagName;
+};
+var lexTagAttributes = (state) => {
+  const { str, tokens } = state;
+  let cursor = state.position;
+  let quote = null;
+  let wordBegin = cursor;
+  const words = [];
+  const len = str.length;
+  while (cursor < len) {
+    const char = str.charAt(cursor);
+    if (quote) {
+      const isQuoteEnd = char === quote;
+      if (isQuoteEnd) quote = null;
+      cursor++;
+      continue;
+    }
+    const isTagEnd = char === "/" || char === ">";
+    if (isTagEnd) {
+      if (cursor !== wordBegin) words.push(str.slice(wordBegin, cursor));
+      break;
+    }
+    const isWordEnd = /\s/.test(char);
+    if (isWordEnd) {
+      if (cursor !== wordBegin) words.push(str.slice(wordBegin, cursor));
+      wordBegin = cursor + 1;
+      cursor++;
+      continue;
+    }
+    const isQuoteStart = char === "'" || char === '"';
+    if (isQuoteStart) {
+      quote = char;
+      cursor++;
+      continue;
+    }
+    cursor++;
+  }
+  jumpPosition(state, cursor);
+  const type = "attribute";
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    const isNotPair = word.indexOf("=") === -1;
+    if (isNotPair) {
+      const secondWord = words[i + 1];
+      if (secondWord && secondWord.startsWith("=")) {
+        if (secondWord.length > 1) {
+          const newWord = word + secondWord;
+          tokens.push({ type, content: newWord });
+          i += 1;
+          continue;
+        }
+        const thirdWord = words[i + 2];
+        i += 1;
+        if (thirdWord) {
+          const newWord = word + "=" + thirdWord;
+          tokens.push({ type, content: newWord });
+          i += 1;
+          continue;
+        }
+      }
+    }
+    if (word.endsWith("=")) {
+      const secondWord = words[i + 1];
+      if (secondWord && secondWord.indexOf("=") === -1) {
+        const newWord2 = word + secondWord;
+        tokens.push({ type, content: newWord2 });
+        i += 1;
+        continue;
+      }
+      const newWord = word.slice(0, -1);
+      tokens.push({ type, content: newWord });
+      continue;
+    }
+    tokens.push({ type, content: word });
+  }
+};
+var lexSkipTag = (tagName, state) => {
+  const { str, tokens } = state;
+  const safeTagName = tagName.toLowerCase();
+  const len = str.length;
+  let index = state.position;
+  while (index < len) {
+    const nextTag = str.indexOf("</", index);
+    if (nextTag === -1) {
+      lexText(state);
+      break;
+    }
+    const tagState = {
+      str,
+      position: state.position,
+      tokens: []
+    };
+    jumpPosition(tagState, nextTag);
+    const name = lexTag(tagState);
+    if (safeTagName !== name.toLowerCase()) {
+      index = tagState.position;
+      continue;
+    }
+    if (nextTag !== state.position) {
+      const textStart = state.position;
+      jumpPosition(state, nextTag);
+      tokens.push({
+        type: "text",
+        content: str.slice(textStart, nextTag)
+      });
+    }
+    tokens.push(...tagState.tokens);
+    jumpPosition(state, tagState.position);
+    break;
+  }
+};
+var lexTag = (state) => {
+  const { str } = state;
+  const secondChar = str.charAt(state.position + 1);
+  const tagStartClose = secondChar === "/";
+  movePosition(state, tagStartClose ? 2 : 1);
+  state.tokens.push({
+    type: "tag-start",
+    close: tagStartClose
+  });
+  const tagName = lexTagName(state);
+  lexTagAttributes(state);
+  const firstChar = str.charAt(state.position);
+  const tagEndClose = firstChar === "/";
+  movePosition(state, tagEndClose ? 2 : 1);
+  state.tokens.push({
+    type: "tag-end",
+    close: tagEndClose
+  });
+  return tagName;
+};
+var lex = (state) => {
+  const str = state.str;
+  const len = str.length;
+  while (state.position < len) {
+    const start = state.position;
+    lexText(state);
+    if (state.position === start) {
+      const isComment = str.startsWith("!--", start + 1);
+      if (isComment) lexComment(state);
+      else {
+        const tagName = lexTag(state);
+        const safeTag = tagName.toLowerCase();
+        if (childlessTags.includes(safeTag)) lexSkipTag(tagName, state);
+      }
+    }
+  }
+};
+var lexer = (str) => {
+  const state = {
+    str,
+    position: 0,
+    tokens: []
+  };
+  lex(state);
+  return state.tokens;
+};
+
+// lib/htmlParser/parser.ts
+var parser = (tokens) => {
+  const root = { tagName: null, children: [] };
+  const state = { tokens, cursor: 0, stack: [root] };
+  parse(state);
+  return root.children;
+};
+var hasTerminalParent = (tagName, stack) => {
+  const tagParents = closingTagAncestorBreakers[tagName];
+  if (tagParents) {
+    let currentIndex = stack.length - 1;
+    while (currentIndex >= 0) {
+      const parentTagName = stack[currentIndex].tagName;
+      if (parentTagName === tagName) break;
+      if (parentTagName && tagParents.includes(parentTagName)) return true;
+      currentIndex--;
+    }
+  }
+  return false;
+};
+var rewindStack = (stack, newLength) => {
+  stack.splice(newLength);
+};
+var parse = (state) => {
+  const { stack, tokens } = state;
+  let { cursor } = state;
+  let nodes = stack[stack.length - 1].children;
+  const len = tokens.length;
+  while (cursor < len) {
+    const token = tokens[cursor];
+    if (token.type !== "tag-start") {
+      nodes.push(token);
+      cursor++;
+      continue;
+    }
+    const tagToken = tokens[++cursor];
+    cursor++;
+    const tagName = tagToken.content.toLowerCase();
+    if (token.close) {
+      let index = stack.length;
+      let shouldRewind = false;
+      while (--index > -1) {
+        if (stack[index].tagName === tagName) {
+          shouldRewind = true;
+          break;
+        }
+      }
+      while (cursor < len) {
+        if (tokens[cursor].type !== "tag-end") break;
+        cursor++;
+      }
+      if (shouldRewind) {
+        rewindStack(stack, index);
+        break;
+      } else continue;
+    }
+    const isClosingTag = closingTags.includes(tagName);
+    let shouldRewindToAutoClose = isClosingTag;
+    if (shouldRewindToAutoClose) {
+      shouldRewindToAutoClose = !hasTerminalParent(tagName, stack);
+    }
+    if (shouldRewindToAutoClose) {
+      let currentIndex = stack.length - 1;
+      while (currentIndex > 0) {
+        if (tagName === stack[currentIndex].tagName) {
+          rewindStack(stack, currentIndex);
+          const previousIndex = currentIndex - 1;
+          nodes = stack[previousIndex].children;
+          break;
+        }
+        currentIndex = currentIndex - 1;
+      }
+    }
+    const attributes = [];
+    let tagEndToken;
+    while (cursor < len) {
+      const _token = tokens[cursor];
+      if (_token.type === "tag-end") {
+        tagEndToken = _token;
+        break;
+      }
+      attributes.push(_token.content);
+      cursor++;
+    }
+    if (!tagEndToken) break;
+    cursor++;
+    const children = [];
+    const elementNode = {
+      type: "element",
+      tagName: tagToken.content,
+      attributes,
+      children
+    };
+    nodes.push(elementNode);
+    const hasChildren = !(tagEndToken.close || voidTags.includes(tagName));
+    if (hasChildren) {
+      stack.push({ tagName, children });
+      const innerState = { tokens, cursor, stack };
+      parse(innerState);
+      cursor = innerState.cursor;
+    }
+  }
+  state.cursor = cursor;
+};
+
+// lib/htmlParser/format.ts
+var splitHead = (str, sep) => {
+  const idx = str.indexOf(sep);
+  if (idx === -1) return [str];
+  return [str.slice(0, idx), str.slice(idx + sep.length)];
+};
+var unquote = (str) => {
+  const car = str.charAt(0);
+  const end = str.length - 1;
+  const isQuoteStart = car === '"' || car === "'";
+  if (isQuoteStart && car === str.charAt(end)) {
+    return str.slice(1, end);
+  }
+  return str;
+};
+var formatAttributes = (attributes) => {
+  return attributes.map((attribute) => {
+    const parts = splitHead(attribute.trim(), "=");
+    const key = parts[0];
+    const value = typeof parts[1] === "string" ? unquote(parts[1]) : null;
+    return { key, value };
+  });
+};
+var format = (nodes) => {
+  return nodes.map((node) => {
+    if (node.type === "element") {
+      const children = format(node.children);
+      const item2 = {
+        type: "element",
+        tagName: node.tagName.toLowerCase(),
+        attributes: formatAttributes(node.attributes),
+        children
+      };
+      return item2;
+    }
+    const item = {
+      type: node.type,
+      content: node.content
+    };
+    return item;
+  });
+};
+
+// lib/htmlParser/index.ts
+var toAST = (str) => {
+  const tokens = lexer(str);
+  const nodes = parser(tokens);
+  return format(nodes);
+};
+
+// lib/svgPathParser.ts
+var import_svg_pathdata = require("svg-pathdata");
+var import_svg_arc_to_cubic_bezier = __toESM(require("svg-arc-to-cubic-bezier"));
+var typeMap = {
+  1: "Z",
+  2: "M",
+  4: "H",
+  8: "V",
+  16: "L",
+  32: "C",
+  64: "S",
+  128: "Q",
+  256: "T",
+  512: "A"
+};
+var toPoints = (d) => {
+  const pathData = new import_svg_pathdata.SVGPathData(d);
+  const points = [];
+  for (const item of pathData.commands) {
+    const type = typeMap[item.type];
+    if (item.type === 2 || item.type === 16) {
+      points.push({
+        x: item.x,
+        y: item.y,
+        relative: item.relative,
+        type
+      });
+    }
+    if (item.type === 32) {
+      points.push({
+        x: item.x,
+        y: item.y,
+        curve: {
+          type: "cubic",
+          x1: item.x1,
+          y1: item.y1,
+          x2: item.x2,
+          y2: item.y2
+        },
+        relative: item.relative,
+        type
+      });
+    } else if (item.type === 128) {
+      points.push({
+        x: item.x,
+        y: item.y,
+        curve: {
+          type: "quadratic",
+          x1: item.x1,
+          y1: item.y1
+        },
+        relative: item.relative,
+        type
+      });
+    } else if (item.type === 512) {
+      const lastPoint = points[points.length - 1];
+      if (!lastPoint || !["M", "L", "Q", "C"].includes(lastPoint.type)) continue;
+      const cubicBezierPoints = (0, import_svg_arc_to_cubic_bezier.default)({
+        px: lastPoint.x,
+        py: lastPoint.y,
+        cx: item.x,
+        cy: item.y,
+        rx: item.rX,
+        ry: item.rY,
+        xAxisRotation: item.xRot,
+        largeArcFlag: item.lArcFlag,
+        sweepFlag: item.sweepFlag
+      });
+      for (const cbPoint of cubicBezierPoints) {
+        points.push({
+          x: cbPoint.x,
+          y: cbPoint.y,
+          curve: {
+            type: "cubic",
+            x1: cbPoint.x1,
+            y1: cbPoint.y1,
+            x2: cbPoint.x2,
+            y2: cbPoint.y2
+          },
+          relative: false,
+          type: "C"
+        });
+      }
+    } else if (item.type === 1) {
+      points.push({ close: true, type });
+    } else continue;
+  }
+  return points;
+};
+
+// lib/element.ts
+var getElementRange = (element) => {
+  var _a, _b, _c, _d, _e, _f;
+  let minX = 0;
+  let maxX = 0;
+  let minY = 0;
+  let maxY = 0;
+  if (element.type === "line" && element.start && element.end) {
+    minX = (_a = element.left) != null ? _a : 0;
+    maxX = ((_b = element.left) != null ? _b : 0) + Math.max(element.start[0], element.end[0]);
+    minY = (_c = element.top) != null ? _c : 0;
+    maxY = ((_d = element.top) != null ? _d : 0) + Math.max(element.start[1], element.end[1]);
+  } else if (element.left !== void 0 && element.top !== void 0) {
+    minX = element.left;
+    minY = element.top;
+    maxX = element.left + ((_e = element.width) != null ? _e : 0);
+    maxY = element.top + ((_f = element.height) != null ? _f : 0);
+  }
+  return { minX, maxX, minY, maxY };
+};
+var isLineElement = (element) => element.type === "line";
+var getLineElementPath = (element) => {
+  if (!isLineElement(element) || !element.start || !element.end) return "";
+  const start = element.start.join(",");
+  const end = element.end.join(",");
+  const broken = element.broken;
+  const broken2 = element.broken2;
+  const curve = element.curve;
+  const cubic = element.cubic;
+  if (broken) {
+    const mid = broken.join(",");
+    return `M${start} L${mid} L${end}`;
+  }
+  if (broken2) {
+    const { minX, maxX, minY, maxY } = getElementRange(element);
+    if (maxX - minX >= maxY - minY) {
+      return `M${start} L${broken2[0]},${element.start[1]} L${broken2[0]},${element.end[1]} ${end}`;
+    }
+    return `M${start} L${element.start[0]},${broken2[1]} L${element.end[0]},${broken2[1]} ${end}`;
+  }
+  if (curve) {
+    const mid = curve.join(",");
+    return `M${start} Q${mid} ${end}`;
+  }
+  if (cubic) {
+    const [c1, c2] = cubic;
+    const p1 = c1.join(",");
+    const p2 = c2.join(",");
+    return `M${start} C${p1} ${p2} ${end}`;
+  }
+  return `M${start} L${end}`;
+};
+
+// lib/index.ts
+var DEFAULT_WIDTH = 1e3;
+var DEFAULT_HEIGHT = 562.5;
+var DEFAULT_FONT_SIZE = 16;
+var DEFAULT_FONT_FACE = "\u5FAE\u8F6F\u96C5\u9ED1";
+var ENABLE_DECK_JSON = true;
+var PPTX_JSON_PAYLOAD_PATH = "json2ppt-editor.json";
+var PPTX_JSON_PAYLOAD_VERSION = 1;
+function sanitizeFileName(name) {
+  return name.replace(/[\\/:*?"<>|]/g, "").trim() || "presentation";
+}
+function formatColor(input) {
+  if (!input) {
+    return {
+      alpha: 0,
+      color: "#000000"
+    };
+  }
+  const color = (0, import_tinycolor2.default)(input);
+  const alpha = color.getAlpha();
+  const hex = alpha === 0 ? "#ffffff" : color.setAlpha(1).toHexString();
+  return { alpha, color: hex };
+}
+function formatHTML(html, ratioPx2Pt) {
+  const ast = toAST(html);
+  let bulletFlag = false;
+  let indent = 0;
+  const slices = [];
+  const parse2 = (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 match = styleItem.match(/([^:]+):\s*(.+)/);
+          if (match) {
+            const [key, value] = [match[1].trim(), match[2].trim()];
+            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((attr2) => attr2.key === "href");
+          styleObj.href = (attr == null ? void 0 : 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"], 10) / ratioPx2Pt;
+        }
+        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 || DEFAULT_FONT_SIZE) * 1.25
+          };
+          options.paraSpaceBefore = 0.1;
+          bulletFlag = false;
+        }
+        if (bulletFlag && styleObj["list-type"] === "ul") {
+          options.bullet = { indent: (options.fontSize || DEFAULT_FONT_SIZE) * 1.25 };
+          options.paraSpaceBefore = 0.1;
+          bulletFlag = false;
+        }
+        if (indent) {
+          options.indentLevel = indent;
+          indent = 0;
+        }
+        slices.push({ text, options });
+      } else if ("children" in item) parse2(item.children, styleObj);
+    }
+  };
+  parse2(ast);
+  return slices;
+}
+var formatPoints = (points, ratioPx2Inch, scale = { x: 1, y: 1 }) => {
+  return points.map((point) => {
+    if ("close" in point) {
+      return { close: true };
+    }
+    if (point.type === "M") {
+      return {
+        x: point.x / ratioPx2Inch * scale.x,
+        y: point.y / ratioPx2Inch * scale.y,
+        moveTo: true
+      };
+    }
+    if (point.curve) {
+      if (point.curve.type === "cubic") {
+        return {
+          x: point.x / ratioPx2Inch * scale.x,
+          y: point.y / ratioPx2Inch * scale.y,
+          curve: {
+            type: "cubic",
+            x1: point.curve.x1 / ratioPx2Inch * scale.x,
+            y1: point.curve.y1 / ratioPx2Inch * scale.y,
+            x2: point.curve.x2 / ratioPx2Inch * scale.x,
+            y2: point.curve.y2 / ratioPx2Inch * scale.y
+          }
+        };
+      }
+      if (point.curve.type === "quadratic") {
+        return {
+          x: point.x / ratioPx2Inch * scale.x,
+          y: point.y / ratioPx2Inch * scale.y,
+          curve: {
+            type: "quadratic",
+            x1: point.curve.x1 / ratioPx2Inch * scale.x,
+            y1: point.curve.y1 / ratioPx2Inch * scale.y
+          }
+        };
+      }
+    }
+    return {
+      x: point.x / ratioPx2Inch * scale.x,
+      y: point.y / ratioPx2Inch * scale.y
+    };
+  });
+};
+var dashTypeMap = {
+  solid: "solid",
+  dashed: "dash",
+  dotted: "sysDot"
+};
+var getShadowOption = (shadow, ratioPx2Pt) => {
+  var _a, _b;
+  const c = formatColor((_a = shadow.color) != null ? _a : "#000000");
+  const { h = 0, v = 0 } = 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: ((_b = shadow.blur) != null ? _b : 0) / ratioPx2Pt,
+    offset,
+    angle
+  };
+};
+var getOutlineOption = (outline, ratioPx2Pt) => {
+  const c = formatColor(outline.color || "#000000");
+  return {
+    color: c.color,
+    transparency: (1 - c.alpha) * 100,
+    width: (outline.width || 1) / ratioPx2Pt,
+    dashType: outline.style ? dashTypeMap[outline.style] : "solid"
+  };
+};
+var isBase64Image = (url) => {
+  const regex = /^data:image\/[^;]+;base64,/;
+  return regex.test(url);
+};
+async function buildPptxBlob(template) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K;
+  const pptx = new import_pptxgenjs.default();
+  const width = (_a = template.width) != null ? _a : DEFAULT_WIDTH;
+  const height = (_b = template.height) != null ? _b : DEFAULT_HEIGHT;
+  const viewportRatio = height / width;
+  const ratioPx2Inch = 96 * (width / 960);
+  const ratioPx2Pt = 96 / 72 * (width / 960);
+  if (Math.abs(viewportRatio - 0.625) < 1e-3) pptx.layout = "LAYOUT_16x10";
+  else if (Math.abs(viewportRatio - 0.75) < 1e-3) pptx.layout = "LAYOUT_4x3";
+  else if (Math.abs(viewportRatio - 0.70710678) < 1e-4) {
+    pptx.defineLayout({ name: "A3", width: 10, height: 7.0710678 });
+    pptx.layout = "A3";
+  } else if (Math.abs(viewportRatio - 1.41421356) < 1e-4) {
+    pptx.defineLayout({ name: "A3_V", width: 10, height: 14.1421356 });
+    pptx.layout = "A3_V";
+  } else pptx.layout = "LAYOUT_16x9";
+  for (const slideJson of (_c = template.slides) != null ? _c : []) {
+    const slide = pptx.addSlide();
+    const backgroundColor = (_d = slideJson.background) == null ? void 0 : _d.color;
+    if (backgroundColor) {
+      const c = formatColor(backgroundColor);
+      slide.background = { color: c.color, transparency: (1 - c.alpha) * 100 };
+    }
+    for (const element of (_e = slideJson.elements) != null ? _e : []) {
+      if (element.type === "text" && element.content) {
+        const textProps = formatHTML(element.content, ratioPx2Pt);
+        const options = {
+          x: ((_f = element.left) != null ? _f : 0) / ratioPx2Inch,
+          y: ((_g = element.top) != null ? _g : 0) / ratioPx2Inch,
+          w: ((_h = element.width) != null ? _h : 0) / ratioPx2Inch,
+          h: ((_i = element.height) != null ? _i : 0) / ratioPx2Inch,
+          fontSize: DEFAULT_FONT_SIZE / ratioPx2Pt,
+          fontFace: element.defaultFontName || ((_j = template.theme) == null ? void 0 : _j.fontName) || DEFAULT_FONT_FACE,
+          color: "#000000",
+          valign: "top",
+          margin: 10 / ratioPx2Pt,
+          paraSpaceBefore: 5 / ratioPx2Pt,
+          lineSpacingMultiple: 1.5 / 1.25,
+          autoFit: true
+        };
+        if (element.rotate) options.rotate = element.rotate;
+        if (element.wordSpace) options.charSpacing = element.wordSpace / ratioPx2Pt;
+        if (element.lineHeight) options.lineSpacingMultiple = element.lineHeight / 1.25;
+        if (element.fill) {
+          const c = formatColor(element.fill);
+          const opacity = element.opacity === void 0 ? 1 : element.opacity;
+          options.fill = {
+            color: c.color,
+            transparency: (1 - c.alpha * opacity) * 100
+          };
+        }
+        if (element.defaultColor) options.color = formatColor(element.defaultColor).color;
+        if (element.shadow) options.shadow = getShadowOption(element.shadow, ratioPx2Pt);
+        if ((_k = element.outline) == null ? void 0 : _k.width) options.line = getOutlineOption(element.outline, ratioPx2Pt);
+        if (element.opacity !== void 0) options.transparency = (1 - element.opacity) * 100;
+        if (element.paragraphSpace !== void 0) {
+          options.paraSpaceBefore = element.paragraphSpace / ratioPx2Pt;
+        }
+        if (element.vertical) options.vert = "eaVert";
+        slide.addText(textProps, options);
+        continue;
+      }
+      if (element.type === "image" && element.src) {
+        const options = {
+          x: ((_l = element.left) != null ? _l : 0) / ratioPx2Inch,
+          y: ((_m = element.top) != null ? _m : 0) / ratioPx2Inch,
+          w: ((_n = element.width) != null ? _n : 0) / ratioPx2Inch,
+          h: ((_o = element.height) != null ? _o : 0) / ratioPx2Inch
+        };
+        if (isBase64Image(element.src)) options.data = element.src;
+        else options.data = await resolveImageData(element.src);
+        if (element.flipH) options.flipH = element.flipH;
+        if (element.flipV) options.flipV = element.flipV;
+        if (element.rotate) options.rotate = element.rotate;
+        if ((_p = element.filters) == null ? void 0 : _p.opacity) {
+          options.transparency = 100 - parseInt(element.filters.opacity, 10);
+        }
+        if ((_q = element.clip) == null ? void 0 : _q.range) {
+          if (element.clip.shape === "ellipse") options.rounding = true;
+          const [start, end] = element.clip.range;
+          const [startX, startY] = start;
+          const [endX, endY] = end;
+          const originW = ((_r = element.width) != null ? _r : 0) / ((endX - startX) / ratioPx2Inch);
+          const originH = ((_s = element.height) != null ? _s : 0) / ((endY - startY) / ratioPx2Inch);
+          options.w = originW / ratioPx2Inch;
+          options.h = originH / ratioPx2Inch;
+          options.sizing = {
+            type: "crop",
+            x: startX / ratioPx2Inch * (originW / ratioPx2Inch),
+            y: startY / ratioPx2Inch * (originH / ratioPx2Inch),
+            w: (endX - startX) / ratioPx2Inch * (originW / ratioPx2Inch),
+            h: (endY - startY) / ratioPx2Inch * (originH / ratioPx2Inch)
+          };
+        }
+        slide.addImage(options);
+        continue;
+      }
+      if (element.type === "shape" && element.path && element.viewBox) {
+        const scale = {
+          x: ((_t = element.width) != null ? _t : 0) / element.viewBox[0],
+          y: ((_u = element.height) != null ? _u : 0) / element.viewBox[1]
+        };
+        const points = formatPoints(toPoints(element.path), ratioPx2Inch, scale);
+        let fillColor = formatColor(element.fill || "#000000");
+        const opacity = element.opacity === void 0 ? 1 : element.opacity;
+        const options = {
+          x: ((_v = element.left) != null ? _v : 0) / ratioPx2Inch,
+          y: ((_w = element.top) != null ? _w : 0) / ratioPx2Inch,
+          w: ((_x = element.width) != null ? _x : 0) / ratioPx2Inch,
+          h: ((_y = element.height) != null ? _y : 0) / ratioPx2Inch,
+          fill: {
+            color: fillColor.color,
+            transparency: (1 - fillColor.alpha * opacity) * 100
+          },
+          points
+        };
+        if (element.flipH) options.flipH = element.flipH;
+        if (element.flipV) options.flipV = element.flipV;
+        if (element.shadow) options.shadow = getShadowOption(element.shadow, ratioPx2Pt);
+        if ((_z = element.outline) == null ? void 0 : _z.width) options.line = getOutlineOption(element.outline, ratioPx2Pt);
+        if (element.rotate) options.rotate = element.rotate;
+        slide.addShape("custGeom", options);
+        if ((_A = element.text) == null ? void 0 : _A.content) {
+          const textProps = formatHTML(element.text.content, ratioPx2Pt);
+          const textOptions = {
+            x: ((_B = element.left) != null ? _B : 0) / ratioPx2Inch,
+            y: ((_C = element.top) != null ? _C : 0) / ratioPx2Inch,
+            w: ((_D = element.width) != null ? _D : 0) / ratioPx2Inch,
+            h: ((_E = element.height) != null ? _E : 0) / ratioPx2Inch,
+            fontSize: DEFAULT_FONT_SIZE / ratioPx2Pt,
+            fontFace: element.text.defaultFontName || DEFAULT_FONT_FACE,
+            color: "#000000",
+            paraSpaceBefore: 5 / ratioPx2Pt,
+            valign: element.text.align
+          };
+          if (element.rotate) textOptions.rotate = element.rotate;
+          if (element.text.defaultColor) {
+            textOptions.color = formatColor(element.text.defaultColor).color;
+          }
+          slide.addText(textProps, textOptions);
+        }
+        continue;
+      }
+      if (element.type === "line" && element.start && element.end) {
+        const path = getLineElementPath(element);
+        const points = formatPoints(toPoints(path), ratioPx2Inch);
+        const { minX, maxX, minY, maxY } = getElementRange(element);
+        const c = formatColor(element.color || "#000000");
+        const options = {
+          x: ((_F = element.left) != null ? _F : 0) / ratioPx2Inch,
+          y: ((_G = element.top) != null ? _G : 0) / ratioPx2Inch,
+          w: (maxX - minX) / ratioPx2Inch,
+          h: (maxY - minY) / ratioPx2Inch,
+          line: {
+            color: c.color,
+            transparency: (1 - c.alpha) * 100,
+            width: ((_H = element.width) != null ? _H : 1) / ratioPx2Pt,
+            dashType: element.style ? dashTypeMap[element.style] : "solid",
+            beginArrowType: ((_I = element.points) == null ? void 0 : _I[0]) ? "arrow" : "none",
+            endArrowType: ((_J = element.points) == null ? void 0 : _J[1]) ? "arrow" : "none"
+          },
+          points
+        };
+        if (element.shadow) options.shadow = getShadowOption(element.shadow, ratioPx2Pt);
+        slide.addShape("custGeom", options);
+      }
+    }
+  }
+  const fileName = `${sanitizeFileName((_K = template.title) != null ? _K : "presentation")}.pptx`;
+  const pptxBuffer = await pptx.write({
+    outputType: "arraybuffer",
+    compression: true
+  });
+  if (!ENABLE_DECK_JSON) {
+    return { blob: new Blob([pptxBuffer]), fileName };
+  }
+  const zip = await import_jszip.default.loadAsync(pptxBuffer);
+  zip.file(
+    PPTX_JSON_PAYLOAD_PATH,
+    JSON.stringify(
+      {
+        version: PPTX_JSON_PAYLOAD_VERSION,
+        deck: template
+      },
+      null,
+      2
+    )
+  );
+  const blob = await zip.generateAsync({ type: "blob" });
+  return { blob, fileName };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENABLE_DECK_JSON,
+  PPTX_JSON_PAYLOAD_PATH,
+  PPTX_JSON_PAYLOAD_VERSION,
+  buildPptxBlob,
+  getElementRange,
+  getLineElementPath,
+  resolveImageData
+});
+//# sourceMappingURL=index.js.map