pptxtojson 0.1.1 → 0.1.3

package/src/pptxtojson.js

@@ -1,7 +1,7 @@
 import JSZip from 'jszip'
 import { readXmlFile } from './readXmlFile'
 import { getBorder } from './border'
-import { getSlideBackgroundFill, getShapeFill } from './fill'
+import { getSlideBackgroundFill, getShapeFill, getSolidFill } from './fill'
 import { getChartInfo } from './chart'
 import { getVerticalAlign } from './align'
 import { getPosition, getSize } from './position'
@@ -10,30 +10,24 @@ import { getCustomShapePath } from './shape'
 import { extractFileExtension, base64ArrayBuffer, getTextByPathList, angleToDegrees, getMimeType, isVideoLink, escapeHtml } from './utils'
 import { getShadow } from './shadow'
 
-let SLIDE_FACTOR = 96 / 914400
-let FONTSIZE_FACTOR = 100 / 75
-
-const defaultOptions = {
-  slideFactor: SLIDE_FACTOR,
-  fontsizeFactor: FONTSIZE_FACTOR,
-}
-
 export async function parse(file, options = {}) {
-  options = { ...defaultOptions, ...options }
+  const defaultOptions = {
+    slideFactor: 96 / 914400,
+    fontsizeFactor: 100 / 75,
+  }
 
-  if (options.slideFactor) SLIDE_FACTOR = options.slideFactor
-  if (options.fontsizeFactor) FONTSIZE_FACTOR = options.fontsizeFactor
+  options = { ...defaultOptions, ...options }
 
   const slides = []
   
   const zip = await JSZip.loadAsync(file)
 
   const filesInfo = await getContentTypes(zip)
-  const { width, height, defaultTextStyle } = await getSlideInfo(zip)
+  const { width, height, defaultTextStyle } = await getSlideInfo(zip, options)
   const themeContent = await loadTheme(zip)
 
   for (const filename of filesInfo.slides) {
-    const singleSlide = await processSingleSlide(zip, filename, themeContent, defaultTextStyle)
+    const singleSlide = await processSingleSlide(zip, filename, themeContent, defaultTextStyle, options)
     slides.push(singleSlide)
   }
 
@@ -78,13 +72,13 @@ async function getContentTypes(zip) {
   }
 }
 
-async function getSlideInfo(zip) {
+async function getSlideInfo(zip, options) {
   const content = await readXmlFile(zip, 'ppt/presentation.xml')
   const sldSzAttrs = content['p:presentation']['p:sldSz']['attrs']
   const defaultTextStyle = content['p:presentation']['p:defaultTextStyle']
   return {
-    width: parseInt(sldSzAttrs['cx']) * SLIDE_FACTOR,
-    height: parseInt(sldSzAttrs['cy']) * SLIDE_FACTOR,
+    width: parseInt(sldSzAttrs['cx']) * options.slideFactor,
+    height: parseInt(sldSzAttrs['cy']) * options.slideFactor,
     defaultTextStyle,
   }
 }
@@ -110,7 +104,7 @@ async function loadTheme(zip) {
   return await readXmlFile(zip, 'ppt/' + themeURI)
 }
 
-async function processSingleSlide(zip, sldFileName, themeContent, defaultTextStyle) {
+async function processSingleSlide(zip, sldFileName, themeContent, defaultTextStyle, options) {
   const resName = sldFileName.replace('slides/slide', 'slides/_rels/slide') + '.rels'
   const resContent = await readXmlFile(zip, resName)
   let relationshipArray = resContent['Relationships']['Relationship']
@@ -252,37 +246,42 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
     }
   }
 
+  const tableStyles = await readXmlFile(zip, 'ppt/tableStyles.xml')
+
   const slideContent = await readXmlFile(zip, sldFileName)
   const nodes = slideContent['p:sld']['p:cSld']['p:spTree']
   const warpObj = {
     zip,
-    slideLayoutContent: slideLayoutContent,
-    slideLayoutTables: slideLayoutTables,
-    slideMasterContent: slideMasterContent,
-    slideMasterTables: slideMasterTables,
-    slideContent: slideContent,
-    slideResObj: slideResObj,
-    slideMasterTextStyles: slideMasterTextStyles,
-    layoutResObj: layoutResObj,
-    masterResObj: masterResObj,
-    themeContent: themeContent,
-    themeResObj: themeResObj,
-    digramFileContent: digramFileContent,
-    diagramResObj: diagramResObj,
-    defaultTextStyle: defaultTextStyle,
+    slideLayoutContent,
+    slideLayoutTables,
+    slideMasterContent,
+    slideMasterTables,
+    slideContent,
+    tableStyles,
+    slideResObj,
+    slideMasterTextStyles,
+    layoutResObj,
+    masterResObj,
+    themeContent,
+    themeResObj,
+    digramFileContent,
+    diagramResObj,
+    defaultTextStyle,
+    options,
   }
+  // const bgElements = await getBackground(warpObj)
   const bgColor = await getSlideBackgroundFill(warpObj)
 
   const elements = []
   for (const nodeKey in nodes) {
     if (nodes[nodeKey].constructor === Array) {
       for (const node of nodes[nodeKey]) {
-        const ret = await processNodesInSlide(nodeKey, node, warpObj)
+        const ret = await processNodesInSlide(nodeKey, node, warpObj, 'slide')
         if (ret) elements.push(ret)
       }
     } 
     else {
-      const ret = await processNodesInSlide(nodeKey, nodes[nodeKey], warpObj)
+      const ret = await processNodesInSlide(nodeKey, nodes[nodeKey], warpObj, 'slide')
       if (ret) elements.push(ret)
     }
   }
@@ -293,6 +292,51 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
   }
 }
 
+// async function getBackground(warpObj) {
+//   const elements = []
+//   const slideLayoutContent = warpObj['slideLayoutContent']
+//   const slideMasterContent = warpObj['slideMasterContent']
+//   const nodesSldLayout = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:cSld', 'p:spTree'])
+//   const nodesSldMaster = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:cSld', 'p:spTree'])
+
+//   const showMasterSp = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'attrs', 'showMasterSp'])
+//   if (nodesSldLayout) {
+//     for (const nodeKey in nodesSldLayout) {
+//       if (nodesSldLayout[nodeKey].constructor === Array) {
+//         for (let i = 0; i < nodesSldLayout[nodeKey].length; i++) {
+//           const ph_type = getTextByPathList(nodesSldLayout[nodeKey][i], ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
+//           if (ph_type !== 'pic') {
+//             const ret = await processNodesInSlide(nodeKey, nodesSldLayout[nodeKey][i], warpObj, 'slideLayoutBg')
+//             if (ret) elements.push(ret)
+//           }
+//         }
+//       } 
+//       else {
+//         const ph_type = getTextByPathList(nodesSldLayout[nodeKey], ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
+//         if (ph_type !== 'pic') {
+//           const ret = await processNodesInSlide(nodeKey, nodesSldLayout[nodeKey], warpObj, 'slideLayoutBg')
+//           if (ret) elements.push(ret)
+//         }
+//       }
+//     }
+//   }
+//   if (nodesSldMaster && (showMasterSp === '1' || showMasterSp)) {
+//     for (const nodeKey in nodesSldMaster) {
+//       if (nodesSldMaster[nodeKey].constructor === Array) {
+//         for (let i = 0; i < nodesSldMaster[nodeKey].length; i++) {
+//           const ret = await processNodesInSlide(nodeKey, nodesSldMaster[nodeKey][i], warpObj, 'slideMasterBg')
+//           if (ret) elements.push(ret)
+//         }
+//       } 
+//       else {
+//         const ret = await processNodesInSlide(nodeKey, nodesSldMaster[nodeKey], warpObj, 'slideMasterBg')
+//         if (ret) elements.push(ret)
+//       }
+//     }
+//   }
+//   return elements
+// }
+
 function indexNodes(content) {
   const keys = Object.keys(content)
   const spTreeNode = content[keys[0]]['p:cSld']['p:spTree']
@@ -332,27 +376,27 @@ function indexNodes(content) {
   return { idTable, idxTable, typeTable }
 }
 
-async function processNodesInSlide(nodeKey, nodeValue, warpObj) {
+async function processNodesInSlide(nodeKey, nodeValue, warpObj, source) {
   let json
 
   switch (nodeKey) {
     case 'p:sp': // Shape, Text
-      json = processSpNode(nodeValue, warpObj)
+      json = processSpNode(nodeValue, warpObj, source)
       break
     case 'p:cxnSp': // Shape, Text
-      json = processCxnSpNode(nodeValue, warpObj)
+      json = processCxnSpNode(nodeValue, warpObj, source)
       break
     case 'p:pic': // Image, Video, Audio
-      json = processPicNode(nodeValue, warpObj)
+      json = processPicNode(nodeValue, warpObj, source)
       break
     case 'p:graphicFrame': // Chart, Diagram, Table
-      json = await processGraphicFrameNode(nodeValue, warpObj)
+      json = await processGraphicFrameNode(nodeValue, warpObj, source)
       break
     case 'p:grpSp':
-      json = await processGroupSpNode(nodeValue, warpObj)
+      json = await processGroupSpNode(nodeValue, warpObj, source)
       break
     case 'mc:AlternateContent':
-      json = await processGroupSpNode(getTextByPathList(nodeValue, ['mc:Fallback']), warpObj)
+      json = await processGroupSpNode(getTextByPathList(nodeValue, ['mc:Fallback']), warpObj, source)
       break
     default:
   }
@@ -360,45 +404,55 @@ async function processNodesInSlide(nodeKey, nodeValue, warpObj) {
   return json
 }
 
-async function processGroupSpNode(node, warpObj) {
+async function processGroupSpNode(node, warpObj, source) {
   const xfrmNode = getTextByPathList(node, ['p:grpSpPr', 'a:xfrm'])
   if (!xfrmNode) return null
 
-  const x = parseInt(xfrmNode['a:off']['attrs']['x']) * SLIDE_FACTOR
-  const y = parseInt(xfrmNode['a:off']['attrs']['y']) * SLIDE_FACTOR
-  const chx = parseInt(xfrmNode['a:chOff']['attrs']['x']) * SLIDE_FACTOR
-  const chy = parseInt(xfrmNode['a:chOff']['attrs']['y']) * SLIDE_FACTOR
-  const cx = parseInt(xfrmNode['a:ext']['attrs']['cx']) * SLIDE_FACTOR
-  const cy = parseInt(xfrmNode['a:ext']['attrs']['cy']) * SLIDE_FACTOR
-  const chcx = parseInt(xfrmNode['a:chExt']['attrs']['cx']) * SLIDE_FACTOR
-  const chcy = parseInt(xfrmNode['a:chExt']['attrs']['cy']) * SLIDE_FACTOR
+  const x = parseInt(xfrmNode['a:off']['attrs']['x']) * warpObj.options.slideFactor
+  const y = parseInt(xfrmNode['a:off']['attrs']['y']) * warpObj.options.slideFactor
+  // https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.childoffset?view=openxml-2.8.1
+  const chx = parseInt(xfrmNode['a:chOff']['attrs']['x']) * warpObj.options.slideFactor
+  const chy = parseInt(xfrmNode['a:chOff']['attrs']['y']) * warpObj.options.slideFactor
+  const cx = parseInt(xfrmNode['a:ext']['attrs']['cx']) * warpObj.options.slideFactor
+  const cy = parseInt(xfrmNode['a:ext']['attrs']['cy']) * warpObj.options.slideFactor
+  // https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.drawing.childextents?view=openxml-2.8.1
+  const chcx = parseInt(xfrmNode['a:chExt']['attrs']['cx']) * warpObj.options.slideFactor
+  const chcy = parseInt(xfrmNode['a:chExt']['attrs']['cy']) * warpObj.options.slideFactor
+  // children coordinate
+  const ws = cx / chcx
+  const hs = cy / chcy
 
   const elements = []
   for (const nodeKey in node) {
     if (node[nodeKey].constructor === Array) {
       for (const item of node[nodeKey]) {
-        const ret = await processNodesInSlide(nodeKey, item, warpObj)
+        const ret = await processNodesInSlide(nodeKey, item, warpObj, source)
         if (ret) elements.push(ret)
       }
     }
     else {
-      const ret = await processNodesInSlide(nodeKey, node[nodeKey], warpObj)
+      const ret = await processNodesInSlide(nodeKey, node[nodeKey], warpObj, source)
       if (ret) elements.push(ret)
     }
   }
 
   return {
     type: 'group',
-    top: y - chy,
-    left: x - chx,
-    width: cx - chcx,
-    height: cy - chcy,
-    elements,
+    top: parseFloat(y.toFixed(2)),
+    left: parseFloat(x.toFixed(2)),
+    width: parseFloat(cx.toFixed(2)),
+    height: parseFloat(cy.toFixed(2)),
+    elements: elements.map(element => ({
+      ...element,
+      left: parseFloat(((element.left - chx) * ws).toFixed(2)),
+      top: parseFloat(((element.top - chy) * hs).toFixed(2)),
+      width: parseFloat((element.width * ws).toFixed(2)),
+      height: parseFloat((element.height * hs).toFixed(2)),
+    }))
   }
 }
 
 function processSpNode(node, warpObj, source) {
-  const id = getTextByPathList(node, ['p:nvSpPr', 'p:cNvPr', 'attrs', 'id'])
   const name = getTextByPathList(node, ['p:nvSpPr', 'p:cNvPr', 'attrs', 'name'])
   const idx = getTextByPathList(node, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'idx'])
   let type = getTextByPathList(node, ['p:nvSpPr', 'p:nvPr', 'p:ph', 'attrs', 'type'])
@@ -432,19 +486,17 @@ function processSpNode(node, warpObj, source) {
     else type = 'obj'
   }
 
-  return genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, type, warpObj)
+  return genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpObj)
 }
 
 function processCxnSpNode(node, warpObj) {
-  const id = node['p:nvCxnSpPr']['p:cNvPr']['attrs']['id']
   const name = node['p:nvCxnSpPr']['p:cNvPr']['attrs']['name']
-  const idx = (node['p:nvCxnSpPr']['p:nvPr']['p:ph'] === undefined) ? undefined : node['p:nvSpPr']['p:nvPr']['p:ph']['attrs']['idx']
   const type = (node['p:nvCxnSpPr']['p:nvPr']['p:ph'] === undefined) ? undefined : node['p:nvSpPr']['p:nvPr']['p:ph']['attrs']['type']
 
-  return genShape(node, undefined, undefined, id, name, idx, type, warpObj)
+  return genShape(node, undefined, undefined, name, type, warpObj)
 }
 
-function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, type, warpObj) {
+function genShape(node, slideLayoutSpNode, slideMasterSpNode, name, type, warpObj) {
   const xfrmList = ['p:spPr', 'a:xfrm']
   const slideXfrmNode = getTextByPathList(node, xfrmList)
   const slideLayoutXfrmNode = getTextByPathList(slideLayoutSpNode, xfrmList)
@@ -453,8 +505,8 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
   const shapType = getTextByPathList(node, ['p:spPr', 'a:prstGeom', 'attrs', 'prst'])
   const custShapType = getTextByPathList(node, ['p:spPr', 'a:custGeom'])
 
-  const { top, left } = getPosition(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode, SLIDE_FACTOR)
-  const { width, height } = getSize(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode, SLIDE_FACTOR)
+  const { top, left } = getPosition(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode, warpObj.options.slideFactor)
+  const { width, height } = getSize(slideXfrmNode, slideLayoutXfrmNode, slideMasterXfrmNode, warpObj.options.slideFactor)
 
   const isFlipV = getTextByPathList(slideXfrmNode, ['attrs', 'flipV']) === '1'
   const isFlipH = getTextByPathList(slideXfrmNode, ['attrs', 'flipH']) === '1'
@@ -470,14 +522,14 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
   else txtRotate = rotate
 
   let content = ''
-  if (node['p:txBody']) content = genTextBody(node['p:txBody'], slideLayoutSpNode, slideMasterSpNode, type, warpObj, FONTSIZE_FACTOR, SLIDE_FACTOR)
+  if (node['p:txBody']) content = genTextBody(node['p:txBody'], node, slideLayoutSpNode, type, warpObj)
 
   const { borderColor, borderWidth, borderType, strokeDasharray } = getBorder(node, type, warpObj)
   const fillColor = getShapeFill(node, undefined, warpObj) || ''
 
   let shadow
   const outerShdwNode = getTextByPathList(node, ['p:spPr', 'a:effectLst', 'a:outerShdw'])
-  if (outerShdwNode) shadow = getShadow(outerShdwNode, warpObj, SLIDE_FACTOR)
+  if (outerShdwNode) shadow = getShadow(outerShdwNode, warpObj)
 
   const vAlign = getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode, type)
   const isVertical = getTextByPathList(node, ['p:txBody', 'a:bodyPr', 'attrs', 'vert']) === 'eaVert'
@@ -497,40 +549,28 @@ function genShape(node, slideLayoutSpNode, slideMasterSpNode, id, name, idx, typ
     isFlipH,
     rotate,
     vAlign,
-    id,
     name,
-    idx,
   }
 
   if (shadow) data.shadow = shadow
 
   if (custShapType && type !== 'diagram') {
     const ext = getTextByPathList(slideXfrmNode, ['a:ext', 'attrs'])
-    const cx = parseInt(ext['cx']) * SLIDE_FACTOR
-    const cy = parseInt(ext['cy']) * SLIDE_FACTOR
-    const w = parseInt(ext['cx']) * SLIDE_FACTOR
-    const h = parseInt(ext['cy']) * SLIDE_FACTOR
+    const w = parseInt(ext['cx']) * warpObj.options.slideFactor
+    const h = parseInt(ext['cy']) * warpObj.options.slideFactor
     const d = getCustomShapePath(custShapType, w, h)
 
     return {
       ...data,
       type: 'shape',
-      cx,
-      cy,
       shapType: 'custom',
       path: d,
     }
   }
   if (shapType && type !== 'text') {
-    const ext = getTextByPathList(slideXfrmNode, ['a:ext', 'attrs'])
-    const cx = parseInt(ext['cx']) * SLIDE_FACTOR
-    const cy = parseInt(ext['cy']) * SLIDE_FACTOR
-
     return {
       ...data,
       type: 'shape',
-      cx,
-      cy,
       shapType,
     }
   }
@@ -556,10 +596,13 @@ async function processPicNode(node, warpObj, source) {
   const xfrmNode = node['p:spPr']['a:xfrm']
 
   const mimeType = getMimeType(imgFileExt)
-  const { top, left } = getPosition(xfrmNode, undefined, undefined, SLIDE_FACTOR)
-  const { width, height } = getSize(xfrmNode, undefined, undefined, SLIDE_FACTOR)
+  const { top, left } = getPosition(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
+  const { width, height } = getSize(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
   const src = `data:${mimeType};base64,${base64ArrayBuffer(imgArrayBuffer)}`
 
+  const isFlipV = getTextByPathList(xfrmNode, ['attrs', 'flipV']) === '1'
+  const isFlipH = getTextByPathList(xfrmNode, ['attrs', 'flipH']) === '1'
+
   let rotate = 0
   const rotateNode = getTextByPathList(node, ['p:spPr', 'a:xfrm', 'attrs', 'rot'])
   if (rotateNode) rotate = angleToDegrees(rotateNode)
@@ -640,10 +683,12 @@ async function processPicNode(node, warpObj, source) {
     height,
     rotate,
     src,
+    isFlipV,
+    isFlipH
   }
 }
 
-async function processGraphicFrameNode(node, warpObj) {
+async function processGraphicFrameNode(node, warpObj, source) {
   const graphicTypeUri = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'attrs', 'uri'])
   
   let result
@@ -660,7 +705,7 @@ async function processGraphicFrameNode(node, warpObj) {
     case 'http://schemas.openxmlformats.org/presentationml/2006/ole':
       let oleObjNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'mc:AlternateContent', 'mc:Fallback', 'p:oleObj'])
       if (!oleObjNode) oleObjNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'p:oleObj'])
-      else processGroupSpNode(oleObjNode, warpObj)
+      else processGroupSpNode(oleObjNode, warpObj, source)
       break
     default:
   }
@@ -670,8 +715,41 @@ async function processGraphicFrameNode(node, warpObj) {
 function genTable(node, warpObj) {
   const tableNode = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'a:tbl'])
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
-  const { top, left } = getPosition(xfrmNode, undefined, undefined, SLIDE_FACTOR)
-  const { width, height } = getSize(xfrmNode, undefined, undefined, SLIDE_FACTOR)
+  const { top, left } = getPosition(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
+  const { width, height } = getSize(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
+
+  const getTblPr = getTextByPathList(node, ['a:graphic', 'a:graphicData', 'a:tbl', 'a:tblPr'])
+
+  let thisTblStyle
+  const tbleStyleId = getTblPr['a:tableStyleId']
+  if (tbleStyleId) {
+    const tbleStylList = warpObj['tableStyles']['a:tblStyleLst']['a:tblStyle']
+    if (tbleStylList) {
+      if (tbleStylList.constructor === Array) {
+        for (let k = 0; k < tbleStylList.length; k++) {
+          if (tbleStylList[k]['attrs']['styleId'] === tbleStyleId) {
+            thisTblStyle = tbleStylList[k]
+          }
+        }
+      } 
+      else {
+        if (tbleStylList['attrs']['styleId'] === tbleStyleId) {
+          thisTblStyle = tbleStylList
+        }
+      }
+    }
+  }
+
+  let themeColor = ''
+  let tbl_bgFillschemeClr = getTextByPathList(thisTblStyle, ['a:tblBg', 'a:fillRef'])
+  if (tbl_bgFillschemeClr) {
+    themeColor = getSolidFill(tbl_bgFillschemeClr, undefined, undefined, warpObj)
+  }
+  if (tbl_bgFillschemeClr === undefined) {
+    tbl_bgFillschemeClr = getTextByPathList(thisTblStyle, ['a:wholeTbl', 'a:tcStyle', 'a:fill', 'a:solidFill'])
+    themeColor = getSolidFill(tbl_bgFillschemeClr, undefined, undefined, warpObj)
+  }
+  if (themeColor !== '') themeColor = '#' + themeColor
 
   const trNodes = tableNode['a:tr']
   
@@ -683,7 +761,7 @@ function genTable(node, warpObj) {
 
       if (tcNodes.constructor === Array) {
         for (const tcNode of tcNodes) {
-          const text = genTextBody(tcNode['a:txBody'], undefined, undefined, undefined, warpObj, FONTSIZE_FACTOR, SLIDE_FACTOR)
+          const text = genTextBody(tcNode['a:txBody'], tcNode, undefined, undefined, warpObj)
           const rowSpan = getTextByPathList(tcNode, ['attrs', 'rowSpan'])
           const colSpan = getTextByPathList(tcNode, ['attrs', 'gridSpan'])
           const vMerge = getTextByPathList(tcNode, ['attrs', 'vMerge'])
@@ -693,7 +771,7 @@ function genTable(node, warpObj) {
         }
       } 
       else {
-        const text = genTextBody(tcNodes['a:txBody'], undefined, undefined, undefined, warpObj, FONTSIZE_FACTOR, SLIDE_FACTOR)
+        const text = genTextBody(tcNodes['a:txBody'], tcNodes, undefined, undefined, warpObj)
         tr.push({ text })
       }
       data.push(tr)
@@ -705,12 +783,12 @@ function genTable(node, warpObj) {
 
     if (tcNodes.constructor === Array) {
       for (const tcNode of tcNodes) {
-        const text = genTextBody(tcNode['a:txBody'], undefined, undefined, undefined, warpObj, FONTSIZE_FACTOR, SLIDE_FACTOR)
+        const text = genTextBody(tcNode['a:txBody'], tcNode, undefined, undefined, warpObj)
         tr.push({ text })
       }
     } 
     else {
-      const text = genTextBody(tcNodes['a:txBody'], undefined, undefined, undefined, warpObj, FONTSIZE_FACTOR, SLIDE_FACTOR)
+      const text = genTextBody(tcNodes['a:txBody'], tcNodes, undefined, undefined, warpObj)
       tr.push({ text })
     }
     data.push(tr)
@@ -723,13 +801,14 @@ function genTable(node, warpObj) {
     width,
     height,
     data,
+    themeColor,
   }
 }
 
 async function genChart(node, warpObj) {
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
-  const { top, left } = getPosition(xfrmNode, undefined, undefined, SLIDE_FACTOR)
-  const { width, height } = getSize(xfrmNode, undefined, undefined, SLIDE_FACTOR)
+  const { top, left } = getPosition(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
+  const { width, height } = getSize(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
 
   const rid = node['a:graphic']['a:graphicData']['c:chart']['attrs']['r:id']
   const refName = warpObj['slideResObj'][rid]['target']
@@ -760,8 +839,8 @@ async function genChart(node, warpObj) {
 
 function genDiagram(node, warpObj) {
   const xfrmNode = getTextByPathList(node, ['p:xfrm'])
-  const { left, top } = getPosition(xfrmNode, undefined, undefined, SLIDE_FACTOR)
-  const { width, height } = getSize(xfrmNode, undefined, undefined, SLIDE_FACTOR)
+  const { left, top } = getPosition(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
+  const { width, height } = getSize(xfrmNode, undefined, undefined, warpObj.options.slideFactor)
   
   const dgmDrwSpArray = getTextByPathList(warpObj['digramFileContent'], ['p:drawing', 'p:spTree', 'p:sp'])
   const elements = []

package/src/readXmlFile.js

@@ -1,12 +1,14 @@
 import * as txml from 'txml/dist/txml.mjs'
 
+let cust_attr_order = 0
+
 export function simplifyLostLess(children, parentAttributes = {}) {
   const out = {}
   if (!children.length) return out
 
   if (children.length === 1 && typeof children[0] === 'string') {
     return Object.keys(parentAttributes).length ? {
-      attrs: parentAttributes,
+      attrs: { order: cust_attr_order++, ...parentAttributes },
       value: children[0],
     } : children[0]
   }
@@ -20,7 +22,7 @@ export function simplifyLostLess(children, parentAttributes = {}) {
     out[child.tagName].push(kids)
 
     if (Object.keys(child.attributes).length) {
-      kids.attrs = child.attributes
+      kids.attrs = { order: cust_attr_order++, ...child.attributes }
     }
   }
   for (const child in out) {

package/src/shadow.js

@@ -1,17 +1,18 @@
 import { getSolidFill } from './fill'
 
-export function getShadow(node, warpObj, slideFactor) {
+export function getShadow(node, warpObj) {
+  const slideFactor = warpObj.options.slideFactor
   const chdwClrNode = getSolidFill(node, undefined, undefined, warpObj)
   const outerShdwAttrs = node['attrs']
   const dir = (outerShdwAttrs['dir']) ? (parseInt(outerShdwAttrs['dir']) / 60000) : 0
   const dist = parseInt(outerShdwAttrs['dist']) * slideFactor
-  const blurRad = outerShdwAttrs['blurRad'] ? (parseInt(outerShdwAttrs['blurRad']) * slideFactor) : ''
+  const blurRad = outerShdwAttrs['blurRad'] ? parseFloat((parseInt(outerShdwAttrs['blurRad']) * slideFactor).toFixed(2)) : ''
   const vx = dist * Math.sin(dir * Math.PI / 180)
   const hx = dist * Math.cos(dir * Math.PI / 180)
 
   return {
-    h: hx,
-    v: vx,
+    h: parseFloat(hx.toFixed(2)),
+    v: parseFloat(vx.toFixed(2)),
     blur: blurRad,
     color: '#' + chdwClrNode,
   }

package/src/shape.js

@@ -57,11 +57,12 @@ export function getCustomShapePath(custShapType, w, h) {
           const moveToNoPt = moveToPtNode[key]
           const spX = moveToNoPt['attrs', 'x']
           const spY = moveToNoPt['attrs', 'y']
-          
+          const order = moveToNoPt['attrs', 'order']
           multiSapeAry.push({
             type: 'movto',
             x: spX,
             y: spY,
+            order,
           })
         })
       }
@@ -74,10 +75,12 @@ export function getCustomShapePath(custShapType, w, h) {
             const lnToNoPt = lnToPtNode[key]
             const ptX = lnToNoPt['attrs', 'x']
             const ptY = lnToNoPt['attrs', 'y']
+            const order = lnToNoPt['attrs', 'order']
             multiSapeAry.push({
               type: 'lnto',
               x: ptX,
               y: ptY,
+              order,
             })
           })
         }
@@ -101,14 +104,17 @@ export function getCustomShapePath(custShapType, w, h) {
           }
           pts_ary.push(pt_obj)
         })
+        const order = key[0]['attrs']['order']
         multiSapeAry.push({
           type: 'cubicBezTo',
-          cubBzPt: pts_ary
+          cubBzPt: pts_ary,
+          order,
         })
       })
     }
     if (arcToNodes) {
       const arcToNodesAttrs = arcToNodes['attrs']
+      const order = arcToNodesAttrs['order']
       const hR = arcToNodesAttrs['hR']
       const wR = arcToNodesAttrs['wR']
       const stAng = arcToNodesAttrs['stAng']
@@ -128,6 +134,7 @@ export function getCustomShapePath(custShapType, w, h) {
         swAng: swAng,
         shftX: shftX,
         shftY: shftY,
+        order,
       })
     }
     if (closeNode) {
@@ -135,13 +142,15 @@ export function getCustomShapePath(custShapType, w, h) {
       Object.keys(closeNode).forEach(() => {
         multiSapeAry.push({
           type: 'close',
+          order: Infinity,
         })
       })
     }
 
+    multiSapeAry.sort((a, b) => a.order - b.order)
+
     let k = 0
     while (k < multiSapeAry.length) {
-
       if (multiSapeAry[k].type === 'movto') {
         const spX = parseInt(multiSapeAry[k].x) * cX
         const spY = parseInt(multiSapeAry[k].y) * cY