pptxtojson 2.0.0 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptxtojson",
-	"version": "2.0.0",
+	"version": "2.0.2",
 	"description": "A javascript tool for parsing .pptx file",
 	"type": "module",
 	"main": "./dist/index.umd.js",

package/src/diagram.js

@@ -1,4 +1,5 @@
 import { readXmlFile } from './readXmlFile'
+import { getTextNodeValue } from './text'
 import { getTextByPathList } from './utils'
 
 export async function loadDiagramFile(warpObj, filename, transformDrawing = false) {
@@ -112,7 +113,7 @@ export function getSmartArtTextData(dataContent) {
             if (!Array.isArray(runs)) runs = [runs]
 
             runs.forEach(r => {
-              const t = getTextByPathList(r, ['a:t'])
+              const t = getTextNodeValue(getTextByPathList(r, ['a:t']))
               if (t && typeof t === 'string') nodeText += t
             })
           }

package/src/fontStyle.js

@@ -44,6 +44,14 @@ function appendMasterTextStyleNodes(styleNodes, type, lvl, slideMasterTextStyles
   }
 }
 
+function appendDefaultTextStyleNodes(styleNodes, lvl, defaultTextStyle) {
+  if (!defaultTextStyle) return
+
+  const lvlPath = getLevelPath(lvl)
+  pushStyleNode(styleNodes, getTextByPathList(defaultTextStyle, [lvlPath, 'a:defRPr']))
+  pushStyleNode(styleNodes, getTextByPathList(defaultTextStyle, ['a:defPPr', 'a:defRPr']))
+}
+
 function getBaseFontStyleNodes(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, lvl) {
   const styleNodes = []
   const runStyleNode = getTextByPathList(node, ['a:rPr'])
@@ -180,8 +188,9 @@ export function getFontColor(node, pNode, textBodyNode, slideLayoutSpNode, slide
   return color || ''
 }
 
-export function getFontSize(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl) {
+export function getFontSize(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl, defaultTextStyle) {
   const styleNodes = getFontStyleNodes(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl)
+  appendDefaultTextStyleNodes(styleNodes, lvl, defaultTextStyle)
   const sz = getFontAttr(styleNodes, 'sz')
   let fontSize = sz ? parseInt(sz) / 100 : undefined
 
@@ -235,4 +244,4 @@ export function getFontShadow(node, pNode, textBodyNode, slideLayoutSpNode, slid
     }
   }
   return ''
-}
+}

package/src/paragraph.js

@@ -0,0 +1,223 @@
+import { getTextByPathList } from './utils'
+
+function getParagraphLevel(node) {
+  let lvlIdx = 1
+  const lvlNode = getTextByPathList(node, ['a:pPr', 'attrs', 'lvl'])
+  if (lvlNode !== undefined) lvlIdx = parseInt(lvlNode) + 1
+  return lvlIdx
+}
+
+function getAlignFromTextNode(node, lvlStr) {
+  if (!node) return ''
+
+  let algn = getTextByPathList(node, ['p:txBody', 'a:lstStyle', lvlStr, 'attrs', 'algn'])
+  if (!algn) algn = getTextByPathList(node, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
+
+  return algn || ''
+}
+
+export function getHorizontalAlign(node, pNode, type, slideLayoutSpNode, slideMasterSpNode, warpObj) {
+  let algn = getTextByPathList(node, ['a:pPr', 'attrs', 'algn'])
+
+  if (!algn) algn = getTextByPathList(pNode, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
+
+  if (!algn) {
+    const lvlIdx = getParagraphLevel(node)
+    const lvlStr = 'a:lvl' + lvlIdx + 'pPr'
+
+    algn = getAlignFromTextNode(slideLayoutSpNode, lvlStr)
+    if (!algn) algn = getAlignFromTextNode(slideMasterSpNode, lvlStr)
+
+    if (!algn && (type === 'title' || type === 'ctrTitle' || type === 'subTitle')) {
+      algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:titleStyle', lvlStr, 'attrs', 'algn'])
+      if (!algn && type === 'subTitle') {
+        algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:bodyStyle', lvlStr, 'attrs', 'algn'])
+      }
+    } 
+    else if (!algn && type === 'body') {
+      algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:bodyStyle', lvlStr, 'attrs', 'algn'])
+    } 
+    else if (!algn) {
+      algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:otherStyle', lvlStr, 'attrs', 'algn'])
+    }
+  }
+
+  let align = 'left'
+  if (algn) {
+    switch (algn) {
+      case 'l':
+        align = 'left'
+        break
+      case 'r':
+        align = 'right'
+        break
+      case 'ctr':
+        align = 'center'
+        break
+      case 'just':
+        align = 'justify'
+        break
+      case 'dist':
+        align = 'justify'
+        break
+      default:
+        align = 'inherit'
+    }
+  }
+  return align
+}
+
+export function getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode) {
+  let anchor = getTextByPathList(node, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+  if (!anchor) {
+    anchor = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+    if (!anchor) {
+      anchor = getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:bodyPr', 'attrs', 'anchor'])
+      if (!anchor) anchor = 't'
+    }
+  }
+  return (anchor === 'ctr') ? 'mid' : ((anchor === 'b') ? 'down' : 'up')
+}
+
+export function getTextAutoFit(node, slideLayoutSpNode, slideMasterSpNode) {
+  function checkBodyPr(bodyPr) {
+    if (!bodyPr) return null
+
+    if (bodyPr['a:noAutofit']) return { result: null }
+    else if (bodyPr['a:spAutoFit']) return { result: { type: 'shape' } }
+    else if (bodyPr['a:normAutofit']) {
+      const fontScale = getTextByPathList(bodyPr['a:normAutofit'], ['attrs', 'fontScale'])
+      if (fontScale) {
+        const scalePercent = parseInt(fontScale) / 1000
+        return {
+          result: {
+            type: 'text',
+            fontScale: scalePercent,
+          }
+        }
+      }
+      return { result: { type: 'text' } }
+    }
+    return null
+  }
+
+  const nodeCheck = checkBodyPr(getTextByPathList(node, ['p:txBody', 'a:bodyPr']))
+  if (nodeCheck) return nodeCheck.result
+
+  const layoutCheck = checkBodyPr(getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:bodyPr']))
+  if (layoutCheck) return layoutCheck.result
+
+  const masterCheck = checkBodyPr(getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:bodyPr']))
+  if (masterCheck) return masterCheck.result
+
+  return null
+}
+
+function pushParagraphStyleNode(styleNodes, styleNode) {
+  if (styleNode) styleNodes.push(styleNode)
+}
+
+function appendTextBodyParagraphStyleNodes(styleNodes, textBodyNode, lvl) {
+  if (!textBodyNode) return
+
+  const lvlPath = `a:lvl${lvl}pPr`
+  pushParagraphStyleNode(styleNodes, getTextByPathList(textBodyNode, ['a:lstStyle', lvlPath]))
+}
+
+function appendShapeParagraphStyleNodes(styleNodes, shapeNode, lvl) {
+  if (!shapeNode) return
+
+  const lvlPath = `a:lvl${lvl}pPr`
+  pushParagraphStyleNode(styleNodes, getTextByPathList(shapeNode, ['p:txBody', 'a:lstStyle', lvlPath]))
+  pushParagraphStyleNode(styleNodes, getTextByPathList(shapeNode, ['p:txBody', 'a:p', 'a:pPr']))
+}
+
+function appendMasterTextParagraphStyleNodes(styleNodes, type, lvl, slideMasterTextStyles) {
+  if (!slideMasterTextStyles) return
+
+  const lvlPath = `a:lvl${lvl}pPr`
+
+  if (type === 'title' || type === 'ctrTitle' || type === 'subTitle') {
+    pushParagraphStyleNode(styleNodes, getTextByPathList(slideMasterTextStyles, ['p:titleStyle', lvlPath]))
+    if (type === 'subTitle') {
+      pushParagraphStyleNode(styleNodes, getTextByPathList(slideMasterTextStyles, ['p:bodyStyle', lvlPath]))
+    }
+  }
+  else if (type === 'body') {
+    pushParagraphStyleNode(styleNodes, getTextByPathList(slideMasterTextStyles, ['p:bodyStyle', lvlPath]))
+  }
+  else {
+    pushParagraphStyleNode(styleNodes, getTextByPathList(slideMasterTextStyles, ['p:otherStyle', lvlPath]))
+  }
+}
+
+function appendDefaultTextParagraphStyleNodes(styleNodes, defaultTextStyle, lvl) {
+  if (!defaultTextStyle) return
+
+  const lvlPath = `a:lvl${lvl}pPr`
+  pushParagraphStyleNode(styleNodes, getTextByPathList(defaultTextStyle, [lvlPath]))
+  pushParagraphStyleNode(styleNodes, getTextByPathList(defaultTextStyle, ['a:defPPr']))
+}
+
+function getParagraphStyleNodes(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj) {
+  if (!pNode) return null
+
+  const pPrNode = pNode['a:pPr']
+  const lvl = getParagraphLevel(pNode)
+  const styleNodes = []
+
+  pushParagraphStyleNode(styleNodes, pPrNode)
+  appendTextBodyParagraphStyleNodes(styleNodes, textBodyNode, lvl)
+  appendShapeParagraphStyleNodes(styleNodes, slideLayoutSpNode, lvl)
+  appendShapeParagraphStyleNodes(styleNodes, slideMasterSpNode, lvl)
+  appendMasterTextParagraphStyleNodes(styleNodes, type, lvl, slideMasterTextStyles)
+  appendDefaultTextParagraphStyleNodes(styleNodes, getTextByPathList(warpObj, ['defaultTextStyle']), lvl)
+
+  return styleNodes
+}
+
+function getLineSpacingValue(spacingNode) {
+  const spcPct = getTextByPathList(spacingNode, ['a:spcPct', 'attrs', 'val'])
+  const spcPts = getTextByPathList(spacingNode, ['a:spcPts', 'attrs', 'val'])
+
+  if (spcPct) return parseInt(spcPct) / 1000 / 100
+  if (spcPts) return parseInt(spcPts) / 100 + 'pt'
+
+  return undefined
+}
+
+function getParagraphSpacingValue(spacingNode) {
+  const spcPct = getTextByPathList(spacingNode, ['a:spcPct', 'attrs', 'val'])
+  const spcPts = getTextByPathList(spacingNode, ['a:spcPts', 'attrs', 'val'])
+
+  if (spcPct) return parseInt(spcPct) / 1000 + 'em'
+  if (spcPts) return parseInt(spcPts) / 100 + 'pt'
+
+  return undefined
+}
+
+export function getParagraphSpacing(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj) {
+  const styleNodes = getParagraphStyleNodes(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
+  if (!styleNodes) return null
+
+  const spacing = {}
+
+  for (const styleNode of styleNodes) {
+    if (spacing.lineSpacing === undefined) {
+      const lineSpacing = getLineSpacingValue(styleNode['a:lnSpc'])
+      if (lineSpacing !== undefined) spacing.lineSpacing = lineSpacing
+    }
+
+    if (spacing.spaceBefore === undefined) {
+      const spaceBefore = getParagraphSpacingValue(styleNode['a:spcBef'])
+      if (spaceBefore !== undefined) spacing.spaceBefore = spaceBefore
+    }
+
+    if (spacing.spaceAfter === undefined) {
+      const spaceAfter = getParagraphSpacingValue(styleNode['a:spcAft'])
+      if (spaceAfter !== undefined) spacing.spaceAfter = spaceAfter
+    }
+  }
+
+  return Object.keys(spacing).length > 0 ? spacing : null
+}

package/src/pptxtojson.js

@@ -3,9 +3,9 @@ import { readXmlFile } from './readXmlFile'
 import { getBorder } from './border'
 import { getSlideBackgroundFill, getShapeFill, getSolidFill, getPicFill, getPicFilters, getImageData, getVideoData, getAudioData } from './fill'
 import { getChartInfo } from './chart'
-import { getVerticalAlign, getTextAutoFit } from './align'
+import { getVerticalAlign, getTextAutoFit } from './paragraph'
 import { getPosition, getSize } from './position'
-import { genTextBody } from './text'
+import { genTextBody, getTextNodeValue } from './text'
 import { getCustomShapePath, identifyShape } from './shape'
 import { extractFileExtension, getTextByPathList, angleToDegrees, isVideoLink, escapeHtml, hasValidText, numberToFixed } from './utils'
 import { getShadow } from './shadow'
@@ -33,6 +33,7 @@ export async function parse(file, options = {}) {
   const filesInfo = await getContentTypes(zip)
   const { width, height, defaultTextStyle } = await getSlideInfo(zip)
   const { themeContent, themeColors } = await getTheme(zip)
+  const usedFonts = await getUsedFonts(zip)
 
   for (const filename of filesInfo.slides) {
     const singleSlide = await processSingleSlide(zip, filename, themeContent, defaultTextStyle, loadedImages, loadedVideos, loadedAudios, parseOptions)
@@ -41,6 +42,7 @@ export async function parse(file, options = {}) {
 
   return {
     slides,
+    usedFonts,
     themeColors,
     size: {
       width,
@@ -81,6 +83,22 @@ async function getContentTypes(zip) {
   }
 }
 
+async function getUsedFonts(zip) {
+  const content = await readXmlFile(zip, 'ppt/presentation.xml')
+  const embeddedFontList = getTextByPathList(content, ['p:presentation', 'p:embeddedFontLst', 'p:embeddedFont'])
+  const usedFonts = []
+
+  if (!embeddedFontList) return usedFonts
+
+  const embeddedFonts = embeddedFontList.constructor === Array ? embeddedFontList : [embeddedFontList]
+  for (const embeddedFont of embeddedFonts) {
+    const typeface = getTextByPathList(embeddedFont, ['p:font', 'attrs', 'typeface'])
+    if (typeface && !usedFonts.includes(typeface)) usedFonts.push(typeface)
+  }
+
+  return usedFonts
+}
+
 async function getSlideInfo(zip) {
   const content = await readXmlFile(zip, 'ppt/presentation.xml')
   const sldSzAttrs = content['p:presentation']['p:sldSz']['attrs']
@@ -392,7 +410,7 @@ function getNote(noteContent) {
       if (rNodes) {
         if (rNodes.constructor !== Array) rNodes = [rNodes]
         for (const r of rNodes) {
-          const t = getTextByPathList(r, ['a:t'])
+          const t = getTextNodeValue(getTextByPathList(r, ['a:t']))
           if (t && typeof t === 'string') text += t
         }
       }
@@ -622,11 +640,13 @@ async function processGroupSpNode(node, warpObj, source, parentGroupHierarchy =
     if (depth > 10) return elements
 
     return elements.map(element => {
-      const processed = {
-        ...element,
-        width: numberToFixed(element.width * ws),
-        height: numberToFixed(element.height * hs),
-      }
+      const processed = {
+        ...element,
+        left: numberToFixed(element.left * ws),
+        top: numberToFixed(element.top * hs),
+        width: numberToFixed(element.width * ws),
+        height: numberToFixed(element.height * hs),
+      }
       if (element.type === 'group' && element.elements) {
         processed.elements = processNestedGroupElements(element.elements, ws, hs, depth + 1)
       }
@@ -678,10 +698,11 @@ async function processSpNode(node, warpObj, source, groupHierarchy = []) {
     const txBoxVal = getTextByPathList(node, ['p:nvSpPr', 'p:cNvSpPr', 'attrs', 'txBox'])
     if (txBoxVal === '1') type = 'text'
   }
-  if (!type) type = getTextByPathList(slideLayoutSpNode, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
-  if (!type) type = getTextByPathList(slideMasterSpNode, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
-
-  if (!type) {
+  if (!type) type = getTextByPathList(slideLayoutSpNode, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
+  if (!type) type = getTextByPathList(slideMasterSpNode, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
+  if (!slideMasterSpNode && type === 'ctrTitle') slideMasterSpNode = warpObj['slideMasterTables']['typeTable']['title']
+
+  if (!type) {
     if (source === 'diagramBg') type = 'diagram'
     else type = 'obj'
   }
@@ -1167,10 +1188,11 @@ async function genTable(node, warpObj) {
         if (cell.rowSpan) td.rowSpan = cell.rowSpan
         if (cell.colSpan) td.colSpan = cell.colSpan
         if (cell.vMerge) td.vMerge = cell.vMerge
-        if (cell.hMerge) td.hMerge = cell.hMerge
-        if (cell.fontBold || fontBold) td.fontBold = cell.fontBold || fontBold
-        if (cell.fontColor || fontColor) td.fontColor = cell.fontColor || fontColor
-        if (cell.fillColor || fillColor || tbl_bgcolor) td.fillColor = cell.fillColor || fillColor || tbl_bgcolor
+        if (cell.hMerge) td.hMerge = cell.hMerge
+        if (cell.vAlign) td.vAlign = cell.vAlign
+        if (cell.fontBold || fontBold) td.fontBold = cell.fontBold || fontBold
+        if (cell.fontColor || fontColor) td.fontColor = cell.fontColor || fontColor
+        if (cell.fillColor || fillColor || tbl_bgcolor) td.fillColor = cell.fillColor || fillColor || tbl_bgcolor
         if (cell.borders) td.borders = cell.borders
 
         tr.push(td)
@@ -1199,10 +1221,11 @@ async function genTable(node, warpObj) {
       if (cell.rowSpan) td.rowSpan = cell.rowSpan
       if (cell.colSpan) td.colSpan = cell.colSpan
       if (cell.vMerge) td.vMerge = cell.vMerge
-      if (cell.hMerge) td.hMerge = cell.hMerge
-      if (cell.fontBold || fontBold) td.fontBold = cell.fontBold || fontBold
-      if (cell.fontColor || fontColor) td.fontColor = cell.fontColor || fontColor
-      if (cell.fillColor || fillColor || tbl_bgcolor) td.fillColor = cell.fillColor || fillColor || tbl_bgcolor
+      if (cell.hMerge) td.hMerge = cell.hMerge
+      if (cell.vAlign) td.vAlign = cell.vAlign
+      if (cell.fontBold || fontBold) td.fontBold = cell.fontBold || fontBold
+      if (cell.fontColor || fontColor) td.fontColor = cell.fontColor || fontColor
+      if (cell.fillColor || fillColor || tbl_bgcolor) td.fillColor = cell.fillColor || fillColor || tbl_bgcolor
       if (cell.borders) td.borders = cell.borders
 
       tr.push(td)
@@ -1298,4 +1321,4 @@ async function genDiagram(node, warpObj) {
     textList,
     order,
   }
-}
+}

package/src/readXmlFile.js

@@ -2,6 +2,10 @@ import * as txml from 'txml/dist/txml.mjs'
 
 let cust_attr_order = 0
 
+function isWhitespaceTextNode(node) {
+  return typeof node === 'string' && node.trim() === ''
+}
+
 export function simplifyLostLess(children, parentAttributes = {}) {
   const out = {}
   if (!children.length) return out
@@ -13,6 +17,7 @@ export function simplifyLostLess(children, parentAttributes = {}) {
     } : children[0]
   }
   for (const child of children) {
+    if (isWhitespaceTextNode(child)) continue
     if (typeof child !== 'object') return
     if (child.tagName === '?xml') continue
 
@@ -39,7 +44,7 @@ export function simplifyLostLess(children, parentAttributes = {}) {
 export async function readXmlFile(zip, filename) {
   try {
     const data = await zip.file(filename).async('string')
-    return simplifyLostLess(txml.parse(data))
+    return simplifyLostLess(txml.parse(data, { keepWhitespace: true }))
   }
   catch {
     return null

package/src/shapePath.js

@@ -4,28 +4,33 @@ import { RATIO_EMUs_Points } from './constants'
 import { getTextByPathList } from './utils'
 
 function shapePie(H, w, adj1, adj2, isClose) {
-  const pieVal = parseInt(adj2)
-  const piAngle = parseInt(adj1)
+  const pieVal = parseFloat(adj2)
+  const piAngle = parseFloat(adj1)
   const size = parseInt(H)
-  const radius = size / 2
+  const radiusY = size / 2
+  const radiusX = w / 2
+  const centerX = radiusX
+  const centerY = radiusY
 
   let value = pieVal - piAngle
   if (value < 0) value = 360 + value
   value = Math.min(Math.max(value, 0), 360)
 
-  const x = Math.cos((2 * Math.PI) / (360 / value))
-  const y = Math.sin((2 * Math.PI) / (360 / value))
+  const startRadians = piAngle * Math.PI / 180
+  const endRadians = (piAngle + value) * Math.PI / 180
+  const startX = centerX + Math.cos(startRadians) * radiusX
+  const startY = centerY + Math.sin(startRadians) * radiusY
+  const endX = centerX + Math.cos(endRadians) * radiusX
+  const endY = centerY + Math.sin(endRadians) * radiusY
 
   let longArc, d
   if (isClose) {
     longArc = (value <= 180) ? 0 : 1
-    d = `M${radius},${radius} L${radius},0 A${radius},${radius} 0 ${longArc},1 ${radius + y * radius},${radius - x * radius} z`
+    d = `M${centerX},${centerY} L${startX},${startY} A${radiusX},${radiusY} 0 ${longArc},1 ${endX},${endY} z`
   } 
   else {
     longArc = (value <= 180) ? 0 : 1
-    const radius1 = radius
-    const radius2 = w / 2
-    d = `M${radius1},0 A${radius2},${radius1} 0 ${longArc},1 ${radius2 + y * radius2},${radius1 - x * radius1}`
+    d = `M${startX},${startY} A${radiusX},${radiusY} 0 ${longArc},1 ${endX},${endY}`
   }
 
   return d
@@ -1434,17 +1439,18 @@ export function getShapePath(shapType, w, h, node) {
         }
 
         if (shapAdjst) {
-          let shapAdjst1 = getTextByPathList(shapAdjst, ['attrs', 'fmla'])
-          let shapAdjst2 = shapAdjst1
-          if (shapAdjst1 === undefined) {
-            shapAdjst1 = shapAdjst[0]['attrs']['fmla']
-            shapAdjst2 = shapAdjst[1]['attrs']['fmla']
-          }
-          if (shapAdjst1) {
-            adj1 = parseInt(shapAdjst1.substring(4)) / 60000
-          }
-          if (shapAdjst2) {
-            adj2 = parseInt(shapAdjst2.substring(4)) / 60000
+          const shapAdjstAry = Array.isArray(shapAdjst) ? shapAdjst : [shapAdjst]
+          for (const adj of shapAdjstAry) {
+            const name = getTextByPathList(adj, ['attrs', 'name'])
+            const fmla = getTextByPathList(adj, ['attrs', 'fmla'])
+            if (!name || !fmla) continue
+
+            if (name === 'adj1') {
+              adj1 = parseInt(fmla.substring(4)) / 60000
+            }
+            else if (name === 'adj2') {
+              adj2 = parseInt(fmla.substring(4)) / 60000
+            }
           }
         }
 
@@ -4628,4 +4634,4 @@ export function getShapePath(shapType, w, h, node) {
   }
 
   return pathData
-}
+}

package/src/table.js

@@ -49,14 +49,15 @@ export function getTableBorders(node, warpObj) {
   return borders
 }
 
-export async function getTableCellParams(tcNode, thisTblStyle, cellSource, warpObj) {
-  const rowSpan = getTextByPathList(tcNode, ['attrs', 'rowSpan'])
-  const colSpan = getTextByPathList(tcNode, ['attrs', 'gridSpan'])
-  const vMerge = getTextByPathList(tcNode, ['attrs', 'vMerge'])
-  const hMerge = getTextByPathList(tcNode, ['attrs', 'hMerge'])
-  let fillColor
-  let fontColor
-  let fontBold
+export async function getTableCellParams(tcNode, thisTblStyle, cellSource, warpObj) {
+  const rowSpan = getTextByPathList(tcNode, ['attrs', 'rowSpan'])
+  const colSpan = getTextByPathList(tcNode, ['attrs', 'gridSpan'])
+  const vMerge = getTextByPathList(tcNode, ['attrs', 'vMerge'])
+  const hMerge = getTextByPathList(tcNode, ['attrs', 'hMerge'])
+  const anchor = getTextByPathList(tcNode, ['a:tcPr', 'attrs', 'anchor'])
+  let fillColor
+  let fontColor
+  let fontBold
 
   const getCelFill = getTextByPathList(tcNode, ['a:tcPr'])
   if (getCelFill) {
@@ -113,10 +114,11 @@ export async function getTableCellParams(tcNode, thisTblStyle, cellSource, warpO
     fillColor,
     fontColor,
     fontBold,
-    borders,
-    rowSpan: rowSpan ? +rowSpan : undefined,
-    colSpan: colSpan ? +colSpan : undefined,
-    vMerge: vMerge ? +vMerge : undefined,
+    borders,
+    vAlign: (anchor === 'ctr') ? 'mid' : ((anchor === 'b') ? 'down' : 'up'),
+    rowSpan: rowSpan ? +rowSpan : undefined,
+    colSpan: colSpan ? +colSpan : undefined,
+    vMerge: vMerge ? +vMerge : undefined,
     hMerge: hMerge ? +hMerge : undefined,
   }
 }
@@ -202,4 +204,4 @@ export function getTableRowParams(trNodes, i, tblStylAttrObj, thisTblStyle, warp
     fontColor,
     fontBold,
   }
-}
+}

package/src/text.js

@@ -1,4 +1,4 @@
-import { getHorizontalAlign, getParagraphSpacing } from './align'
+import { getHorizontalAlign, getParagraphSpacing } from './paragraph'
 import { getTextByPathList } from './utils'
 
 import {
@@ -14,13 +14,20 @@ import {
   getFontShadow,
 } from './fontStyle'
 
+export function getTextNodeValue(node) {
+  if (typeof node === 'string') return node
+  if (node && typeof node.value === 'string') return node.value
+  return undefined
+}
+
 export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, slideMasterSpNode, type, warpObj) {
   if (!textBodyNode) return ''
 
   let text = ''
 
-  const pFontStyle = getTextByPathList(spNode, ['p:style', 'a:fontRef'])
-  const slideMasterTextStyles = spNode && spNode['a:tcPr'] ? undefined : warpObj['slideMasterTextStyles']
+  const pFontStyle = getTextByPathList(spNode, ['p:style', 'a:fontRef'])
+  const slideMasterTextStyles = spNode && spNode['a:tcPr'] ? undefined : warpObj['slideMasterTextStyles']
+  const defaultTextStyle = spNode && spNode['a:tcPr'] ? warpObj['defaultTextStyle'] : undefined
 
   const pNode = textBodyNode['a:p']
   const pNodes = pNode.constructor === Array ? pNode : [pNode]
@@ -52,7 +59,7 @@ export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, slideMaster
     }
 
     const align = getHorizontalAlign(pNode, spNode, type, slideLayoutSpNode, slideMasterSpNode, warpObj)
-    const spacing = getParagraphSpacing(pNode)
+    const spacing = getParagraphSpacing(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
 
     let styleText = `text-align: ${align};`
     if (spacing) {
@@ -90,14 +97,14 @@ export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, slideMaster
     }
     
     if (!rNode) {
-      text += genSpanElement(pNode, spNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
+      text += genSpanElement(pNode, spNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, defaultTextStyle, warpObj)
     } 
     else {
       let prevStyleInfo = null
       let accumulatedText = ''
 
       for (const rNodeItem of rNode) {
-        const styleInfo = getSpanStyleInfo(rNodeItem, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
+        const styleInfo = getSpanStyleInfo(rNodeItem, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, defaultTextStyle, warpObj)
 
         if (!prevStyleInfo || prevStyleInfo.styleText !== styleInfo.styleText || prevStyleInfo.hasLink !== styleInfo.hasLink || styleInfo.hasLink) {
           if (accumulatedText) {
@@ -154,8 +161,8 @@ export function getListLevel(node) {
   return 0
 }
 
-export function genSpanElement(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj) {
-  const { styleText, text, hasLink, linkURL } = getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
+export function genSpanElement(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, defaultTextStyle, warpObj) {
+  const { styleText, text, hasLink, linkURL } = getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, defaultTextStyle, warpObj)
   const processedText = text.replace(/\t/g, '    ').replace(/\s/g, ' ')
 
   if (hasLink) {
@@ -164,19 +171,19 @@ export function genSpanElement(node, pNode, textBodyNode, pFontStyle, slideLayou
   return `<span style="${styleText}">${processedText}</span>`
 }
 
-export function getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj) {
+export function getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, defaultTextStyle, warpObj) {
   let lvl = 1
   const pPrNode = pNode['a:pPr']
   const lvlNode = getTextByPathList(pPrNode, ['attrs', 'lvl'])
   if (lvlNode !== undefined) lvl = parseInt(lvlNode) + 1
 
-  let text = node['a:t']
-  if (typeof text !== 'string') text = getTextByPathList(node, ['a:fld', 'a:t'])
+  let text = getTextNodeValue(node['a:t'])
+  if (typeof text !== 'string') text = getTextNodeValue(getTextByPathList(node, ['a:fld', 'a:t']))
   if (typeof text !== 'string') text = '&nbsp;'
 
   let styleText = ''
   const fontColor = getFontColor(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl, pFontStyle, warpObj)
-  const fontSize = getFontSize(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl)
+  const fontSize = getFontSize(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl, defaultTextStyle)
   const fontType = getFontType(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl, warpObj)
   const fontBold = getFontBold(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl)
   const fontItalic = getFontItalic(node, pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, lvl)
@@ -214,4 +221,4 @@ export function getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLay
     hasLink,
     linkURL: hasLink ? warpObj['slideResObj'][linkID]['target'] : null
   }
-}
+}