pptxtojson 2.0.2 → 2.0.4

package/index.html

@@ -432,11 +432,13 @@
             loadingOverlay.classList.add('show')
 
             try {
+              const parseStart = performance.now()
               const json = await pptxtojson.parse(e.target.result, {
                 imageMode: 'both',
                 videoMode: 'blob',
                 audioMode: 'blob',
               })
+              console.log('parse time:', ((performance.now() - parseStart) / 1000).toFixed(3) + 's')
               editor.set(json)
               console.log(json)
               jsonString = JSON.stringify(json, null, 2)
@@ -459,7 +461,13 @@
         loadingOverlay.classList.add('show')
 
         try {
-          const json = await pptxtojson.parse(file)
+          const parseStart = performance.now()
+          const json = await pptxtojson.parse(file, {
+            imageMode: 'both',
+            videoMode: 'blob',
+            audioMode: 'blob',
+          })
+          console.log('parse time:', ((performance.now() - parseStart) / 1000).toFixed(3) + 's')
           editor.set(json)
           console.log(json)
           jsonString = JSON.stringify(json, null, 2)
@@ -542,4 +550,4 @@
     })
 	</script>
 </body>
-</html>
+</html>

package/package.json

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

package/src/chart.js

@@ -31,56 +31,66 @@ function extractChartData(serNode) {
   const dataMat = []
   if (!serNode) return dataMat
 
-  if (serNode['c:xVal']) {
-    let dataRow = []
-    eachElement(serNode['c:xVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
-      dataRow.push(parseFloat(innerNode['c:v']))
-      return ''
-    })
-    dataMat.push(dataRow)
-    dataRow = []
-    eachElement(serNode['c:yVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
-      dataRow.push(parseFloat(innerNode['c:v']))
-      return ''
-    })
-    dataMat.push(dataRow)
-  } 
-  else {
-    eachElement(serNode, (innerNode, index) => {
-      const dataRow = []
-      const colName = getTextByPathList(innerNode, ['c:tx', 'c:strRef', 'c:strCache', 'c:pt', 'c:v']) || index
-
-      const rowNames = {}
-      if (getTextByPathList(innerNode, ['c:cat', 'c:strRef', 'c:strCache', 'c:pt'])) {
-        eachElement(innerNode['c:cat']['c:strRef']['c:strCache']['c:pt'], innerNode => {
-          rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
-          return ''
-        })
-      } 
-      else if (getTextByPathList(innerNode, ['c:cat', 'c:numRef', 'c:numCache', 'c:pt'])) {
-        eachElement(innerNode['c:cat']['c:numRef']['c:numCache']['c:pt'], innerNode => {
-          rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
-          return ''
-        })
-      }
+  eachElement(serNode, (innerNode, index) => {
+    const dataRow = []
+    const colName = getTextByPathList(innerNode, ['c:tx', 'c:strRef', 'c:strCache', 'c:pt', 'c:v']) || index
 
-      if (getTextByPathList(innerNode, ['c:val', 'c:numRef', 'c:numCache', 'c:pt'])) {
-        eachElement(innerNode['c:val']['c:numRef']['c:numCache']['c:pt'], innerNode => {
-          dataRow.push({
-            x: innerNode['attrs']['idx'],
-            y: parseFloat(innerNode['c:v']),
-          })
-          return ''
-        })
-      }
+    const rowNames = {}
+    if (getTextByPathList(innerNode, ['c:cat', 'c:strRef', 'c:strCache', 'c:pt'])) {
+      eachElement(innerNode['c:cat']['c:strRef']['c:strCache']['c:pt'], innerNode => {
+        rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
+        return ''
+      })
+    } 
+    else if (getTextByPathList(innerNode, ['c:cat', 'c:numRef', 'c:numCache', 'c:pt'])) {
+      eachElement(innerNode['c:cat']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+        rowNames[innerNode['attrs']['idx']] = innerNode['c:v']
+        return ''
+      })
+    }
 
-      dataMat.push({
-        key: colName,
-        values: dataRow,
-        xlabels: rowNames,
+    if (getTextByPathList(innerNode, ['c:val', 'c:numRef', 'c:numCache', 'c:pt'])) {
+      eachElement(innerNode['c:val']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+        dataRow.push({
+          x: innerNode['attrs']['idx'],
+          y: parseFloat(innerNode['c:v']),
+        })
+        return ''
       })
+    }
+
+    dataMat.push({
+      key: colName,
+      values: dataRow,
+      xlabels: rowNames,
+    })
+    return ''
+  })
+
+  return dataMat
+}
+
+function extractScatterChartData(serNode) {
+  const dataMat = []
+  if (!serNode) return dataMat
+
+  const serNodes = serNode.constructor === Array ? serNode : [serNode]
+  const firstSerNode = serNodes[0]
+  const xData = []
+
+  eachElement(firstSerNode['c:xVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+    xData.push(parseFloat(innerNode['c:v']))
+    return ''
+  })
+  dataMat.push(xData)
+
+  for (const node of serNodes) {
+    const yData = []
+    eachElement(node['c:yVal']['c:numRef']['c:numCache']['c:pt'], innerNode => {
+      yData.push(parseFloat(innerNode['c:v']))
       return ''
     })
+    dataMat.push(yData)
   }
 
   return dataMat
@@ -168,7 +178,7 @@ export function getChartInfo(plotArea, warpObj) {
       case 'c:scatterChart':
         chart = {
           type: 'scatterChart',
-          data: extractChartData(plotArea[key]['c:ser']),
+          data: extractScatterChartData(plotArea[key]['c:ser']),
           colors: extractChartColors(plotArea[key]['c:ser'], warpObj),
           style: getTextByPathList(plotArea[key], ['c:scatterStyle', 'attrs', 'val']),
         }
@@ -176,7 +186,7 @@ export function getChartInfo(plotArea, warpObj) {
       case 'c:bubbleChart':
         chart = {
           type: 'bubbleChart',
-          data: extractChartData(plotArea[key]['c:ser']),
+          data: extractScatterChartData(plotArea[key]['c:ser']),
           colors: extractChartColors(plotArea[key]['c:ser'], warpObj),
         }
         break
@@ -214,4 +224,4 @@ export function getChartInfo(plotArea, warpObj) {
   }
 
   return chart
-}
+}

package/src/paragraph.js

@@ -1,17 +1,18 @@
-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'])
+import { RATIO_EMUs_Points } from './constants'
+import { getTextByPathList, numberToFixed } 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 || ''
 }
@@ -109,115 +110,144 @@ export function getTextAutoFit(node, slideLayoutSpNode, slideMasterSpNode) {
 
   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
-}
+
+  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
+}
+
+function getParagraphIndentValue(styleNode, attrName) {
+  const val = getTextByPathList(styleNode, ['attrs', attrName])
+
+  if (val !== undefined && val !== '') return numberToFixed(parseInt(val) * RATIO_EMUs_Points) + '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
+}
+
+export function getParagraphIndent(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj) {
+  const styleNodes = getParagraphStyleNodes(pNode, textBodyNode, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles, warpObj)
+  if (!styleNodes) return null
+
+  const indent = {}
+
+  for (const styleNode of styleNodes) {
+    if (indent.marginLeft === undefined) {
+      const marginLeft = getParagraphIndentValue(styleNode, 'marL')
+      if (marginLeft !== undefined) indent.marginLeft = marginLeft
+    }
+
+    if (indent.textIndent === undefined) {
+      const textIndent = getParagraphIndentValue(styleNode, 'indent')
+      if (textIndent !== undefined) indent.textIndent = textIndent
+    }
+  }
+
+  return Object.keys(indent).length > 0 ? indent : null
+}

package/src/pptxtojson.js

@@ -4,6 +4,7 @@ import { getBorder } from './border'
 import { getSlideBackgroundFill, getShapeFill, getSolidFill, getPicFill, getPicFilters, getImageData, getVideoData, getAudioData } from './fill'
 import { getChartInfo } from './chart'
 import { getVerticalAlign, getTextAutoFit } from './paragraph'
+import { getTextInsets } from './textInsets'
 import { getPosition, getSize } from './position'
 import { genTextBody, getTextNodeValue } from './text'
 import { getCustomShapePath, identifyShape } from './shape'
@@ -21,6 +22,7 @@ export async function parse(file, options = {}) {
   const loadedImages = {}
   const loadedVideos = {}
   const loadedAudios = {}
+  const xmlCache = {}
   const parseOptions = {
     ...options,
     imageMode: options.imageMode || 'base64',
@@ -36,7 +38,7 @@ export async function parse(file, options = {}) {
   const usedFonts = await getUsedFonts(zip)
 
   for (const filename of filesInfo.slides) {
-    const singleSlide = await processSingleSlide(zip, filename, themeContent, defaultTextStyle, loadedImages, loadedVideos, loadedAudios, parseOptions)
+    const singleSlide = await processSingleSlide(zip, filename, themeContent, defaultTextStyle, loadedImages, loadedVideos, loadedAudios, parseOptions, xmlCache)
     slides.push(singleSlide)
   }
 
@@ -142,7 +144,16 @@ async function getTheme(zip) {
   return { themeContent, themeColors }
 }
 
-async function processSingleSlide(zip, sldFileName, themeContent, defaultTextStyle, loadedImages, loadedVideos, loadedAudios, options) {
+async function readXmlFileCached(zip, filename, xmlCache) {
+  if (!filename) return null
+  if (Object.prototype.hasOwnProperty.call(xmlCache, filename)) return xmlCache[filename]
+
+  const content = await readXmlFile(zip, filename)
+  xmlCache[filename] = content
+  return content
+}
+
+async function processSingleSlide(zip, sldFileName, themeContent, defaultTextStyle, loadedImages, loadedVideos, loadedAudios, options, xmlCache) {
   const resName = sldFileName.replace('slides/slide', 'slides/_rels/slide') + '.rels'
   const resContent = await readXmlFile(zip, resName)
   let relationshipArray = resContent['Relationships']['Relationship']
@@ -205,10 +216,10 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
   const slideNotesContent = await readXmlFile(zip, noteFilename)
   const note = getNote(slideNotesContent)
 
-  const slideLayoutContent = await readXmlFile(zip, layoutFilename)
-  const slideLayoutTables = await indexNodes(slideLayoutContent)
+  const slideLayoutContent = await readXmlFileCached(zip, layoutFilename, xmlCache)
+  const slideLayoutTables = indexNodes(slideLayoutContent)
   const slideLayoutResFilename = layoutFilename.replace('slideLayouts/slideLayout', 'slideLayouts/_rels/slideLayout') + '.rels'
-  const slideLayoutResContent = await readXmlFile(zip, slideLayoutResFilename)
+  const slideLayoutResContent = await readXmlFileCached(zip, slideLayoutResFilename, xmlCache)
   relationshipArray = slideLayoutResContent['Relationships']['Relationship']
   if (relationshipArray.constructor !== Array) relationshipArray = [relationshipArray]
 
@@ -230,11 +241,11 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
     }
   }
 
-  const slideMasterContent = await readXmlFile(zip, masterFilename)
+  const slideMasterContent = await readXmlFileCached(zip, masterFilename, xmlCache)
   const slideMasterTextStyles = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:txStyles'])
   const slideMasterTables = indexNodes(slideMasterContent)
   const slideMasterResFilename = masterFilename.replace('slideMasters/slideMaster', 'slideMasters/_rels/slideMaster') + '.rels'
-  const slideMasterResContent = await readXmlFile(zip, slideMasterResFilename)
+  const slideMasterResContent = await readXmlFileCached(zip, slideMasterResFilename, xmlCache)
   relationshipArray = slideMasterResContent['Relationships']['Relationship']
   if (relationshipArray.constructor !== Array) relationshipArray = [relationshipArray]
 
@@ -274,7 +285,7 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
     }
   }
 
-  const tableStyles = await readXmlFile(zip, 'ppt/tableStyles.xml')
+  const tableStyles = await readXmlFileCached(zip, 'ppt/tableStyles.xml', xmlCache)
 
   const slideContent = await readXmlFile(zip, sldFileName)
   const nodes = slideContent['p:sld']['p:cSld']['p:spTree']
@@ -397,7 +408,7 @@ function getNote(noteContent) {
           text += `<${listType}>`
           listTypes[listLevel] = listType
         }
-        text += `<li style="text-align:${align};">`
+        text += `<li><p style="text-align:${align};">`
       }
       else {
         while (listTypes.length > 0) {
@@ -415,7 +426,7 @@ function getNote(noteContent) {
         }
       }
 
-      if (listType) text += '</li>'
+      if (listType) text += '</p></li>'
       else text += '</p>'
     }
     while (listTypes.length > 0) {
@@ -558,6 +569,8 @@ async function processMathNode(node, warpObj, source) {
   const { width, height } = getSize(xfrmNode, undefined, undefined)
 
   const oMath = findOMath(choice)[0]
+  if (!oMath) return null
+
   const latex = latexFormart(parseOMath(oMath))
 
   const blipFill = getTextByPathList(fallback, ['p:sp', 'p:spPr', 'a:blipFill'])
@@ -640,13 +653,13 @@ async function processGroupSpNode(node, warpObj, source, parentGroupHierarchy =
     if (depth > 10) return elements
 
     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),
-      }
+      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)
       }
@@ -698,11 +711,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 (!slideMasterSpNode && type === 'ctrTitle') slideMasterSpNode = warpObj['slideMasterTables']['typeTable']['title']
-
-  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'
   }
@@ -775,6 +788,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,
@@ -798,6 +812,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)
 
@@ -1188,11 +1203,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.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.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)
@@ -1221,11 +1236,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.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.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)