pptxtojson 2.0.3 → 2.0.5

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.3",
+	"version": "2.0.5",
 	"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/fill.js

@@ -702,25 +702,47 @@ export async function getSlideBackgroundFill(warpObj) {
   }
 }
 
-export async function getShapeFill(node, warpObj, source, groupHierarchy = []) {
-  const fillType = getFillType(getTextByPathList(node, ['p:spPr']))
+function getShapeFillCandidates(node, source, slideLayoutSpNode, slideMasterSpNode) {
+  const candidates = [{ node, source }]
+
+  if (slideLayoutSpNode) {
+    candidates.push({
+      node: slideLayoutSpNode,
+      source: 'slideLayoutBg',
+    })
+  }
+  if (slideMasterSpNode) {
+    candidates.push({
+      node: slideMasterSpNode,
+      source: 'slideMasterBg',
+    })
+  }
+
+  return candidates
+}
+
+async function resolveShapeFillFromNode(node, warpObj, source, groupHierarchy) {
+  if (!node) return { state: 'missing' }
+
+  const spPr = getTextByPathList(node, ['p:spPr'])
+  const fillType = spPr ? getFillType(spPr) : ''
   let type = 'color'
   let fillValue = ''
   if (fillType === 'NO_FILL') {
-    return null
+    return { state: 'none' }
   }
   else if (fillType === 'SOLID_FILL') {
-    const shpFill = node['p:spPr']['a:solidFill']
+    const shpFill = spPr['a:solidFill']
     fillValue = getSolidFill(shpFill, undefined, undefined, warpObj)
     type = 'color'
   }
   else if (fillType === 'GRADIENT_FILL') {
-    const shpFill = node['p:spPr']['a:gradFill']
+    const shpFill = spPr['a:gradFill']
     fillValue = getGradientFill(shpFill, warpObj)
     type = 'gradient'
   }
   else if (fillType === 'PIC_FILL') {
-    const shpFill = node['p:spPr']['a:blipFill']
+    const shpFill = spPr['a:blipFill']
     const picFill = await getPicFill(source, shpFill, warpObj)
     const opacity = getPicFillOpacity(shpFill)
     fillValue = {
@@ -732,12 +754,13 @@ export async function getShapeFill(node, warpObj, source, groupHierarchy = []) {
     type = 'image'
   }
   else if (fillType === 'PATTERN_FILL') {
-    const shpFill = node['p:spPr']['a:pattFill']
+    const shpFill = spPr['a:pattFill']
     fillValue = getPatternFill({ 'a:pattFill': shpFill }, warpObj)
     type = 'pattern'
   }
   else if (fillType === 'GROUP_FILL') {
-    return findFillInGroupHierarchy(groupHierarchy, warpObj, source)
+    const groupFill = await findFillInGroupHierarchy(groupHierarchy, warpObj, source)
+    return groupFill ? { state: 'found', fill: groupFill } : { state: 'none' }
   }
   if (!fillValue) {
     const clrName = getTextByPathList(node, ['p:style', 'a:fillRef'])
@@ -745,15 +768,36 @@ export async function getShapeFill(node, warpObj, source, groupHierarchy = []) {
     type = 'color'
   }
   if (!fillValue) {
-    return null
+    return { state: 'missing' }
   }
 
   return {
-    type,
-    value: fillValue,
+    state: 'found',
+    fill: {
+      type,
+      value: fillValue,
+    }
   }
 }
 
+export async function getShapeFill(node, warpObj, source, options = {}) {
+  const {
+    groupHierarchy = [],
+    slideLayoutSpNode,
+    slideMasterSpNode,
+  } = options
+
+  const candidates = getShapeFillCandidates(node, source, slideLayoutSpNode, slideMasterSpNode)
+  for (const candidate of candidates) {
+    const result = await resolveShapeFillFromNode(candidate.node, warpObj, candidate.source, groupHierarchy)
+
+    if (result.state === 'none') return null
+    if (result.state === 'found') return result.fill
+  }
+
+  return null
+}
+
 async function findFillInGroupHierarchy(groupHierarchy, warpObj, source) {
   for (const groupNode of groupHierarchy) {
     if (!groupNode || !groupNode['p:grpSpPr']) continue
@@ -892,4 +936,4 @@ export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
   if (color && color.indexOf('#') === -1) color = '#' + color
 
   return color
-}
+}

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
+}