pptxtojson 0.1.2 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pptxtojson",
-	"version": "0.1.2",
+	"version": "0.1.3",
 	"description": "A javascript tool for parsing .pptx file",
 	"type": "module",
 	"main": "./dist/index.umd.js",
@@ -12,7 +12,7 @@
 		"lint": "eslint src --ext .js,.jsx,.ts,.tsx"
 	},
 	"author": "",
-	"license": "AGPL-3.0",
+	"license": "MIT",
 	"publishConfig": {
 		"registry": "https://registry.npmjs.com/"
 	},

package/src/align.js

@@ -1,26 +1,55 @@
 import { getTextByPathList } from './utils'
 
-export function getHorizontalAlign(node, slideLayoutSpNode, slideMasterSpNode, type, slideMasterTextStyles) {
+export function getHorizontalAlign(node, pNode, type, warpObj) {
   let algn = getTextByPathList(node, ['a:pPr', 'attrs', 'algn'])
+  if (!algn) algn = getTextByPathList(pNode, ['a:pPr', 'attrs', 'algn'])
 
-  if (!algn) algn = getTextByPathList(slideLayoutSpNode, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
-  if (!algn) algn = getTextByPathList(slideMasterSpNode, ['p:txBody', 'a:p', 'a:pPr', 'attrs', 'algn'])
   if (!algn) {
-    switch (type) {
-      case 'title':
-      case 'subTitle':
-      case 'ctrTitle':
-        algn = getTextByPathList(slideMasterTextStyles, ['p:titleStyle', 'a:lvl1pPr', 'attrs', 'algn'])
+    if (type === 'title' || type === 'ctrTitle' || type === 'subTitle') {
+      let lvlIdx = 1
+      const lvlNode = getTextByPathList(pNode, ['a:pPr', 'attrs', 'lvl'])
+      if (lvlNode) {
+        lvlIdx = parseInt(lvlNode) + 1
+      }
+      const lvlStr = 'a:lvl' + lvlIdx + 'pPr'
+      algn = getTextByPathList(warpObj, ['slideLayoutTables', 'typeTable', type, 'p:txBody', 'a:lstStyle', lvlStr, 'attrs', 'algn'])
+      if (!algn) algn = getTextByPathList(warpObj, ['slideMasterTables', 'typeTable', type, 'p:txBody', 'a:lstStyle', lvlStr, 'attrs', 'algn'])
+      if (!algn) algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:titleStyle', lvlStr, 'attrs', 'algn'])
+      if (!algn && type === 'subTitle') {
+        algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:bodyStyle', lvlStr, 'attrs', 'algn'])
+      }
+    } 
+    else if (type === 'body') {
+      algn = getTextByPathList(warpObj, ['slideMasterTextStyles', 'p:bodyStyle', 'a:lvl1pPr', 'attrs', 'algn'])
+    } 
+    else {
+      algn = getTextByPathList(warpObj, ['slideMasterTables', 'typeTable', type, 'p:txBody', 'a:lstStyle', 'a:lvl1pPr', '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:
-        algn = getTextByPathList(slideMasterTextStyles, ['p:otherStyle', 'a:lvl1pPr', 'attrs', 'algn'])
+        align = 'inherit'
     }
   }
-  if (!algn) {
-    if (type === 'title' || type === 'subTitle' || type === 'ctrTitle') return 'center'
-    else if (type === 'sldNum') return 'right'
-  }
-  return algn === 'ctr' ? 'center' : algn === 'r' ? 'right' : 'left'
+  return align
 }
 
 export function getVerticalAlign(node, slideLayoutSpNode, slideMasterSpNode) {

package/src/fill.js

@@ -244,7 +244,7 @@ export function getShapeFill(node, isSvgMode, warpObj) {
     if (isNaN(lumOff)) lumOff = 0
 
     const color = tinycolor(fillColor).toHsl()
-    const lum = color.l * (1 + lumOff)
+    const lum = color.l * lumMod + lumOff
     return tinycolor({ h: color.h, s: color.s, l: lum, a: color.a }).toHexString()
   } 
 
@@ -264,6 +264,15 @@ export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
   else if (solidFill['a:schemeClr']) {
     const schemeClr = 'a:' + getTextByPathList(solidFill['a:schemeClr'], ['attrs', 'val'])
     color = getSchemeColorFromTheme(schemeClr, warpObj)
+    
+    let lumMod = parseInt(getTextByPathList(solidFill, ['a:schemeClr', 'a:lumMod', 'attrs', 'val'])) / 100000
+    let lumOff = parseInt(getTextByPathList(solidFill, ['a:schemeClr', 'a:lumOff', 'attrs', 'val'])) / 100000
+    if (isNaN(lumMod)) lumMod = 1.0
+    if (isNaN(lumOff)) lumOff = 0
+
+    color = tinycolor(color).toHsl()
+    const lum = color.l * lumMod + lumOff
+    return tinycolor({ h: color.h, s: color.s, l: lum, a: color.a }).toHex()
   }
   else if (solidFill['a:scrgbClr']) {
     clrNode = solidFill['a:scrgbClr']

package/src/fontStyle.js

@@ -58,7 +58,7 @@ export function getFontSize(node, slideLayoutSpNode, type, slideMasterTextStyles
 
   fontSize = (isNaN(fontSize) || !fontSize) ? 18 : fontSize
 
-  return fontSize * fontsizeFactor + 'px'
+  return parseFloat((fontSize * fontsizeFactor).toFixed(2)) + (fontsizeFactor === 1 ? 'pt' : 'px')
 }
 
 export function getFontBold(node) {
@@ -88,10 +88,10 @@ export function getFontSubscript(node) {
   return parseInt(baseline) > 0 ? 'super' : 'sub'
 }
 
-export function getFontShadow(node, warpObj, slideFactor) {
+export function getFontShadow(node, warpObj) {
   const txtShadow = getTextByPathList(node, ['a:rPr', 'a:effectLst', 'a:outerShdw'])
   if (txtShadow) {
-    const shadow = getShadow(txtShadow, warpObj, slideFactor)
+    const shadow = getShadow(txtShadow, warpObj)
     if (shadow) {
       const { h, v, blur, color } = shadow
       if (!isNaN(v) && !isNaN(h)) {

package/src/position.js

@@ -8,8 +8,8 @@ export function getPosition(slideSpNode, slideLayoutSpNode, slideMasterSpNode, f
   if (!off) return { top: 0, left: 0 }
 
   return {
-    top: parseInt(off['y']) * factor,
-    left: parseInt(off['x']) * factor,
+    top: parseFloat((parseInt(off['y']) * factor).toFixed(2)),
+    left: parseFloat((parseInt(off['x']) * factor).toFixed(2)),
   }
 }
 
@@ -23,7 +23,7 @@ export function getSize(slideSpNode, slideLayoutSpNode, slideMasterSpNode, facto
   if (!ext) return { width: 0, height: 0 }
 
   return {
-    width: parseInt(ext['cx']) * factor,
-    height: parseInt(ext['cy']) * factor,
+    width: parseFloat((parseInt(ext['cx']) * factor).toFixed(2)),
+    height: parseFloat((parseInt(ext['cy']) * factor).toFixed(2)),
   }
 }

package/src/pptxtojson.js

@@ -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']
@@ -258,34 +252,36 @@ async function processSingleSlide(zip, sldFileName, themeContent, defaultTextSty
   const nodes = slideContent['p:sld']['p:cSld']['p:spTree']
   const warpObj = {
     zip,
-    slideLayoutContent: slideLayoutContent,
-    slideLayoutTables: slideLayoutTables,
-    slideMasterContent: slideMasterContent,
-    slideMasterTables: slideMasterTables,
-    slideContent: slideContent,
-    tableStyles: tableStyles,
-    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)
     }
   }
@@ -296,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']
@@ -335,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:
   }
@@ -363,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'])
@@ -435,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)
@@ -456,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'
@@ -473,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'
@@ -500,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,
     }
   }
@@ -559,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)
@@ -643,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
@@ -663,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:
   }
@@ -673,8 +715,8 @@ 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'])
 
@@ -719,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'])
@@ -729,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)
@@ -741,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)
@@ -765,8 +807,8 @@ function genTable(node, warpObj) {
 
 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']
@@ -797,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/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,
   }