pptxtojson 2.0.1 → 2.0.3

package/package.json

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

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,7 +3,8 @@ 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 { getTextInsets } from './textInsets'
 import { getPosition, getSize } from './position'
 import { genTextBody, getTextNodeValue } from './text'
 import { getCustomShapePath, identifyShape } from './shape'
@@ -33,6 +34,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 +43,7 @@ export async function parse(file, options = {}) {
 
   return {
     slides,
+    usedFonts,
     themeColors,
     size: {
       width,
@@ -81,6 +84,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']
@@ -624,6 +643,8 @@ async function processGroupSpNode(node, warpObj, source, parentGroupHierarchy =
     return elements.map(element => {
       const processed = {
         ...element,
+        left: numberToFixed(element.left * ws),
+        top: numberToFixed(element.top * hs),
         width: numberToFixed(element.width * ws),
         height: numberToFixed(element.height * hs),
       }
@@ -680,6 +701,7 @@ async function processSpNode(node, warpObj, source, groupHierarchy = []) {
   }
   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'
@@ -754,6 +776,7 @@ async function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type,
   const vAlign = getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode, type)
   const isVertical = getTextByPathList(node, ['p:txBody', 'a:bodyPr', 'attrs', 'vert']) === 'eaVert'
   const autoFit = getTextAutoFit(node, slideLayoutSpNode, slideMasterSpNode)
+  const textInset = getTextInsets(node, slideLayoutSpNode, slideMasterSpNode)
 
   const data = {
     left,
@@ -777,6 +800,7 @@ async function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type,
   if (shadow) data.shadow = shadow
   if (autoFit) data.autoFit = autoFit
   if (link) data.link = link
+  if (textInset) data.textInset = textInset
 
   const isHasValidText = data.content && hasValidText(data.content)
 
@@ -1168,6 +1192,7 @@ async function genTable(node, warpObj) {
         if (cell.colSpan) td.colSpan = cell.colSpan
         if (cell.vMerge) td.vMerge = cell.vMerge
         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
@@ -1200,6 +1225,7 @@ async function genTable(node, warpObj) {
       if (cell.colSpan) td.colSpan = cell.colSpan
       if (cell.vMerge) td.vMerge = cell.vMerge
       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
@@ -1298,4 +1324,4 @@ async function genDiagram(node, warpObj) {
     textList,
     order,
   }
-}
+}

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 {
@@ -25,8 +25,9 @@ export function genTextBody(textBodyNode, spNode, slideLayoutSpNode, slideMaster
 
   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]
@@ -58,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) {
@@ -96,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) {
@@ -160,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) {
@@ -170,7 +171,7 @@ 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'])
@@ -182,7 +183,7 @@ export function getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLay
 
   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)
@@ -220,4 +221,4 @@ export function getSpanStyleInfo(node, pNode, textBodyNode, pFontStyle, slideLay
     hasLink,
     linkURL: hasLink ? warpObj['slideResObj'][linkID]['target'] : null
   }
-}
+}

package/src/textInsets.js

@@ -0,0 +1,64 @@
+import { getTextByPathList, numberToFixed } from './utils'
+import { RATIO_EMUs_Points } from './constants'
+
+const DEFAULT_INSET_EMU = {
+  lIns: 91440, // 0.1 in
+  rIns: 91440, // 0.1 in
+  tIns: 45720, // 0.05 in
+  bIns: 45720, // 0.05 in
+}
+
+function getInsetAttr(slideNode, layoutNode, masterNode, attrName) {
+  let v = getTextByPathList(slideNode, ['p:txBody', 'a:bodyPr', 'attrs', attrName])
+  if (v !== undefined && v !== null && v !== '') return v
+
+  v = getTextByPathList(layoutNode, ['p:txBody', 'a:bodyPr', 'attrs', attrName])
+  if (v !== undefined && v !== null && v !== '') return v
+
+  return getTextByPathList(masterNode, ['p:txBody', 'a:bodyPr', 'attrs', attrName])
+}
+
+function emuToPt(emuStr) {
+  if (emuStr === undefined || emuStr === null || emuStr === '') return null
+  const v = parseInt(emuStr, 10)
+  if (!Number.isFinite(v)) return null
+  return numberToFixed(v * RATIO_EMUs_Points)
+}
+
+export function getTextInsets(node, slideLayoutSpNode, slideMasterSpNode) {
+  const nodeBodyPr = getTextByPathList(node, ['p:txBody', 'a:bodyPr'])
+  const layoutBodyPr = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:bodyPr'])
+  const masterBodyPr = getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:bodyPr'])
+
+  if (!nodeBodyPr) {
+    if (!layoutBodyPr) {
+      if (!masterBodyPr) return null
+    }
+  }
+
+  let li = getInsetAttr(node, slideLayoutSpNode, slideMasterSpNode, 'lIns')
+  if (li === undefined || li === null || li === '') li = DEFAULT_INSET_EMU.lIns
+
+  let ti = getInsetAttr(node, slideLayoutSpNode, slideMasterSpNode, 'tIns')
+  if (ti === undefined || ti === null || ti === '') ti = DEFAULT_INSET_EMU.tIns
+
+  let ri = getInsetAttr(node, slideLayoutSpNode, slideMasterSpNode, 'rIns')
+  if (ri === undefined || ri === null || ri === '') ri = DEFAULT_INSET_EMU.rIns
+
+  let bi = getInsetAttr(node, slideLayoutSpNode, slideMasterSpNode, 'bIns')
+  if (bi === undefined || bi === null || bi === '') bi = DEFAULT_INSET_EMU.bIns
+
+  let l = emuToPt(li)
+  if (l === null) l = 0
+
+  let t = emuToPt(ti)
+  if (t === null) t = 0
+
+  let r = emuToPt(ri)
+  if (r === null) r = 0
+
+  let b = emuToPt(bi)
+  if (b === null) b = 0
+
+  return { l, t, r, b }
+}