node-pptx-templater 1.0.17 → 1.0.18

package/src/managers/SlideManager.js

@@ -71,6 +71,12 @@ class SlideManager {
    */
   #slideXmlCache = new Map()
 
+  /**
+   * Slide states: maps 1-based index → state object.
+   * @private @type {Map<number, Object>}
+   */
+  #slideStates = new Map()
+
   /**
    * Custom tags: maps tag → array of 1-based indices.
    * @private @type {Map<string, number[]>}
@@ -177,6 +183,16 @@ class SlideManager {
       }
 
       this.#slides.set(slideIndex, slideInfo)
+      this.#slideStates.set(slideIndex, {
+        xmlStr: null,
+        xmlObj: null,
+        dirty: false,
+        indexBuilt: false,
+        shapeMap: new Map(),
+        picMap: new Map(),
+        tableMap: new Map(),
+        chartMap: new Map(),
+      })
       slideIndex++
     }
 
@@ -237,9 +253,27 @@ class SlideManager {
   getSlideXml(slideIndex) {
     this.#assertSlideExists(slideIndex)
     const info = this.#slides.get(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+
+    if (state.dirty && state.xmlObj) {
+      const decl = this.#xmlParser.extractDeclaration(
+        state.xmlStr || '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
+      )
+      state.xmlStr = this.#xmlParser.build(state.xmlObj, decl)
+      this.#zipManager.writeFile(info.zipPath, state.xmlStr)
+      this.#slideXmlCache.set(info.zipPath, state.xmlStr)
+      state.dirty = false
+    }
+
+    if (state.xmlStr) {
+      return state.xmlStr
+    }
 
-    if (this.#slideXmlCache.has(info.zipPath)) {
-      return this.#slideXmlCache.get(info.zipPath)
+    const cached = this.#zipManager.readCachedFile(info.zipPath)
+    if (cached) {
+      state.xmlStr = cached
+      this.#slideXmlCache.set(info.zipPath, cached)
+      return cached
     }
 
     // This is sync because we pre-load; async callers should use getSlideXmlAsync
@@ -255,14 +289,16 @@ class SlideManager {
   async getSlideXmlAsync(slideIndex) {
     this.#assertSlideExists(slideIndex)
     const info = this.#slides.get(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
 
-    if (!this.#slideXmlCache.has(info.zipPath)) {
+    if (!state.xmlStr) {
       const xml = await this.#zipManager.readFile(info.zipPath)
       if (!xml) throw new SlideNotFoundError(`Slide ${slideIndex} XML not found at ${info.zipPath}`)
+      state.xmlStr = xml
       this.#slideXmlCache.set(info.zipPath, xml)
     }
 
-    return this.#slideXmlCache.get(info.zipPath)
+    return state.xmlStr
   }
 
   /**
@@ -274,6 +310,13 @@ class SlideManager {
   setSlideXml(slideIndex, xml) {
     this.#assertSlideExists(slideIndex)
     const info = this.#slides.get(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+
+    state.xmlStr = xml
+    state.xmlObj = null
+    state.dirty = false
+    state.indexBuilt = false
+
     this.#slideXmlCache.set(info.zipPath, xml)
     this.#zipManager.writeFile(info.zipPath, xml)
   }
@@ -360,6 +403,16 @@ class SlideManager {
     }
 
     this.#slides.set(newIndex, slideInfo)
+    this.#slideStates.set(newIndex, {
+      xmlStr: slideXml,
+      xmlObj: null,
+      dirty: false,
+      indexBuilt: false,
+      shapeMap: new Map(),
+      picMap: new Map(),
+      tableMap: new Map(),
+      chartMap: new Map(),
+    })
 
     // Update presentation.xml sldIdLst
     this.#addSlideToPresentation(rId, newSlideId)
@@ -424,6 +477,16 @@ class SlideManager {
     }
 
     this.#slides.set(newIndex, slideInfo)
+    this.#slideStates.set(newIndex, {
+      xmlStr: sourceXml,
+      xmlObj: null,
+      dirty: false,
+      indexBuilt: false,
+      shapeMap: new Map(),
+      picMap: new Map(),
+      tableMap: new Map(),
+      chartMap: new Map(),
+    })
     this.#addSlideToPresentation(rId, newSlideId)
     this.#registerSlideContentType(slideFileName)
 
@@ -448,6 +511,7 @@ class SlideManager {
 
     // Remove from cache
     this.#slideXmlCache.delete(info.zipPath)
+    this.#slideStates.delete(slideIndex)
 
     // Remove relationship from presentation.xml
     this.#relationshipManager.removeRelationship('ppt/presentation.xml', info.relationshipId)
@@ -479,13 +543,18 @@ class SlideManager {
     }
 
     const slidesCopy = new Map(this.#slides)
+    const statesCopy = new Map(this.#slideStates)
     this.#slides.clear()
+    this.#slideStates.clear()
 
     order.forEach((oldIndex, newPos) => {
       const info = slidesCopy.get(oldIndex)
       if (!info) throw new SlideNotFoundError(`Slide ${oldIndex} not found`)
       info.index = newPos + 1
       this.#slides.set(newPos + 1, info)
+
+      const state = statesCopy.get(oldIndex)
+      this.#slideStates.set(newPos + 1, state)
     })
 
     // Rebuild presentation sldIdLst
@@ -741,6 +810,16 @@ class SlideManager {
     }
 
     this.#slides.set(newIndex, slideInfo)
+    this.#slideStates.set(newIndex, {
+      xmlStr: slideXml,
+      xmlObj: null,
+      dirty: false,
+      indexBuilt: false,
+      shapeMap: new Map(),
+      picMap: new Map(),
+      tableMap: new Map(),
+      chartMap: new Map(),
+    })
 
     // Add entry in presentation.xml sldIdLst
     this.#addSlideToPresentation(rId, newSlideId)
@@ -917,10 +996,18 @@ class SlideManager {
   #reindexSlides() {
     const sorted = Array.from(this.#slides.entries()).sort(([a], [b]) => a - b)
     this.#slides.clear()
+
+    const sortedStates = Array.from(this.#slideStates.entries()).sort(([a], [b]) => a - b)
+    this.#slideStates.clear()
+
     sorted.forEach(([, info], i) => {
       info.index = i + 1
       this.#slides.set(i + 1, info)
     })
+
+    sortedStates.forEach(([, state], i) => {
+      this.#slideStates.set(i + 1, state)
+    })
   }
 
   /**
@@ -1044,6 +1131,162 @@ class SlideManager {
       )
     }
   }
+
+  getSlideObj(slideIndex) {
+    this.#assertSlideExists(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+
+    if (!state.xmlObj) {
+      const xml = this.getSlideXml(slideIndex)
+      const info = this.#slides.get(slideIndex)
+      state.xmlObj = this.#xmlParser.parse(xml, info.zipPath.split('/').pop())
+      state.indexBuilt = false
+    }
+
+    if (!state.indexBuilt) {
+      state.shapeMap.clear()
+      state.picMap.clear()
+      state.tableMap.clear()
+      state.chartMap.clear()
+
+      const spTree =
+        state.xmlObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+        state.xmlObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+        state.xmlObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
+
+      this.#buildSlideIndexRecursive(
+        spTree,
+        state.shapeMap,
+        state.picMap,
+        state.tableMap,
+        state.chartMap
+      )
+      state.indexBuilt = true
+    }
+
+    return state.xmlObj
+  }
+
+  #buildSlideIndexRecursive(container, shapeMap, picMap, tableMap, chartMap) {
+    if (!container) return
+
+    // Shapes
+    let shapes = container['p:sp'] || []
+    if (!Array.isArray(shapes)) shapes = [shapes]
+    for (const shape of shapes) {
+      const cNvPr = shape?.['p:nvSpPr']?.['p:cNvPr']
+      if (cNvPr) {
+        const name = cNvPr['@_name']
+        const id = String(cNvPr['@_id'])
+        const entry = { shape, parent: container, type: 'sp' }
+        if (name) shapeMap.set(name, entry)
+        if (id) shapeMap.set(id, entry)
+      }
+    }
+
+    // Pictures
+    let pics = container['p:pic'] || []
+    if (!Array.isArray(pics)) pics = [pics]
+    for (const pic of pics) {
+      const cNvPr = pic?.['p:nvPicPr']?.['p:cNvPr']
+      if (cNvPr) {
+        const name = cNvPr['@_name']
+        const id = String(cNvPr['@_id'])
+        const embedId = pic?.['p:blipFill']?.['a:blip']?.['@_r:embed']
+        const entry = { pic, parent: container, type: 'pic' }
+        if (name) picMap.set(name, entry)
+        if (id) picMap.set(id, entry)
+        if (embedId) picMap.set(embedId, entry)
+      }
+    }
+
+    // Graphic frames
+    let frames = container['p:graphicFrame'] || []
+    if (!Array.isArray(frames)) frames = [frames]
+    for (const frame of frames) {
+      const cNvPr = frame?.['p:nvGraphicFramePr']?.['p:cNvPr']
+      const name = cNvPr ? cNvPr['@_name'] : null
+      const id = cNvPr ? String(cNvPr['@_id']) : null
+
+      const tbl = frame?.['a:graphic']?.['a:graphicData']?.['a:tbl']
+      if (tbl) {
+        const entry = { table: tbl, frame, parent: container, type: 'table' }
+        if (name) tableMap.set(name, entry)
+        if (id) tableMap.set(id, entry)
+      }
+
+      const chart = frame?.['a:graphic']?.['a:graphicData']?.['c:chart']
+      if (chart) {
+        const embedId = chart['@_r:id']
+        const entry = { chart, frame, parent: container, type: 'chart' }
+        if (name) chartMap.set(name, entry)
+        if (id) chartMap.set(id, entry)
+        if (embedId) chartMap.set(embedId, entry)
+      }
+    }
+
+    // Groups
+    let groups = container['p:grpSp'] || []
+    if (!Array.isArray(groups)) groups = [groups]
+    for (const group of groups) {
+      const cNvPr = group?.['p:nvGrpSpPr']?.['p:cNvPr']
+      if (cNvPr) {
+        const name = cNvPr['@_name']
+        const id = String(cNvPr['@_id'])
+        const entry = { shape: group, parent: container, type: 'grpSp' }
+        if (name) shapeMap.set(name, entry)
+        if (id) shapeMap.set(id, entry)
+      }
+      this.#buildSlideIndexRecursive(group, shapeMap, picMap, tableMap, chartMap)
+    }
+  }
+
+  flush() {
+    for (const [index, state] of this.#slideStates) {
+      if (state.dirty && state.xmlObj) {
+        this.getSlideXml(index)
+      }
+    }
+  }
+
+  markSlideObjDirty(slideIndex) {
+    this.#assertSlideExists(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+    state.dirty = true
+    state.indexBuilt = false
+  }
+
+  getSlideShape(slideIndex, shapeId) {
+    this.getSlideObj(slideIndex)
+    return this.#slideStates.get(slideIndex).shapeMap.get(String(shapeId)) || null
+  }
+
+  getSlidePic(slideIndex, picId) {
+    this.getSlideObj(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+    if (picId === 'first') {
+      return Array.from(state.picMap.values())[0] || null
+    }
+    return state.picMap.get(String(picId)) || null
+  }
+
+  getSlideTable(slideIndex, tableId) {
+    this.getSlideObj(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+    if (tableId === 'first') {
+      return Array.from(state.tableMap.values())[0] || null
+    }
+    return state.tableMap.get(String(tableId)) || null
+  }
+
+  getSlideChart(slideIndex, chartId) {
+    this.getSlideObj(slideIndex)
+    const state = this.#slideStates.get(slideIndex)
+    if (chartId === 'first') {
+      return Array.from(state.chartMap.values())[0] || null
+    }
+    return state.chartMap.get(String(chartId)) || null
+  }
 }
 
 module.exports = { SlideManager }

package/src/managers/TableManager.js

@@ -67,12 +67,7 @@ class TableManager {
    * @throws {TableNotFoundError} If the table is not found.
    */
   updateTable(slideIndex, tableId, data, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (trs.length === 0) {
@@ -174,8 +169,7 @@ class TableManager {
 
     tblObj['a:tr'] = newRows
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
 
     const finalMerges = [...templateMerges, ...generatedMerges]
     for (const merge of finalMerges) {
@@ -204,12 +198,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   addTableRow(slideIndex, tableId, rowData, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (trs.length === 0) {
@@ -230,8 +219,7 @@ class TableManager {
 
     trs.push(newRow)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -243,12 +231,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   removeTableRow(slideIndex, tableId, rowIndex, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (rowIndex < 0 || rowIndex >= trs.length) {
@@ -257,8 +240,7 @@ class TableManager {
 
     trs.splice(rowIndex, 1)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -271,12 +253,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   insertTableRow(slideIndex, tableId, rowIndex, rowData, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (rowIndex < 0 || rowIndex > trs.length) {
@@ -302,8 +279,7 @@ class TableManager {
 
     trs.splice(rowIndex, 0, newRow)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -316,12 +292,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   cloneTableRow(slideIndex, tableId, sourceRowIndex, targetRowIndex, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     if (sourceRowIndex < 0 || sourceRowIndex >= trs.length) {
@@ -337,8 +308,7 @@ class TableManager {
 
     trs.splice(targetRowIndex, 0, newRow)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -353,12 +323,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   updateCell(slideIndex, tableId, rowIndex, colIndex, value, options = {}, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const row = tblObj['a:tr']?.[rowIndex]
     if (!row) {
@@ -407,8 +372,7 @@ class TableManager {
       }
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -425,9 +389,8 @@ class TableManager {
    */
   validateMergeRegion(slideIndex, tableId, startRow, startCol, endRow, endCol, slideManager) {
     const errors = []
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const tblObj = this.#findTableObj(slideObj, tableId, slideManager, slideIndex)
     if (!tblObj) {
       errors.push(`Table "${tableId}" not found in slide ${slideIndex}`)
       return { valid: false, errors }
@@ -507,9 +470,7 @@ class TableManager {
       throw new PPTXError(`Invalid merge region: ${validation.errors.join('; ')}`)
     }
 
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
     const trs = tblObj['a:tr'] || []
 
     const allTexts = []
@@ -561,8 +522,7 @@ class TableManager {
     const combinedText = allTexts.filter(t => t.trim() !== '').join('\n')
     this.#setCellTextObj(originCell, combinedText)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -587,9 +547,8 @@ class TableManager {
       actualEndCol = undefined
     }
 
-    const slideXml = actualSlideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
+    const slideObj = actualSlideManager.getSlideObj(slideIndex)
+    const tblObj = this.#findTableObj(slideObj, tableId, actualSlideManager, slideIndex)
     if (!tblObj) {
       throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
     }
@@ -629,8 +588,7 @@ class TableManager {
       }
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    actualSlideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    actualSlideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -642,9 +600,8 @@ class TableManager {
    * @returns {Array<Object>} List of merged region coordinates
    */
   getMergedCells(slideIndex, tableId, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const tblObj = this.#findTableObj(slideObj, tableId, slideManager, slideIndex)
     if (!tblObj) {
       throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
     }
@@ -759,9 +716,8 @@ class TableManager {
       slideManager
     )
 
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const tblObj = this.#findTableObj(slideObj, tableId, slideManager, slideIndex)
     if (!tblObj) return
 
     const trs = tblObj['a:tr'] || []
@@ -777,8 +733,7 @@ class TableManager {
       }
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -789,12 +744,7 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   autoFitTable(slideIndex, tableId, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const tblObj = this.#findTableObj(slideObj, tableId)
-    if (!tblObj) {
-      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
-    }
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
     const gridCols = tblObj['a:tblGrid']?.['a:gridCol']
@@ -835,8 +785,7 @@ class TableManager {
       gridCols[c]['@_w'] = String(width)
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -849,10 +798,12 @@ class TableManager {
    * @param {SlideManager} slideManager
    */
   resizeTable(slideIndex, tableId, width, height, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
+    const slideObj = slideManager.getSlideObj(slideIndex)
 
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
     if (!spTree) return
 
     let frames = spTree['p:graphicFrame'] || []
@@ -931,8 +882,7 @@ class TableManager {
       }
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
   }
 
   /**
@@ -943,11 +893,13 @@ class TableManager {
    * @returns {Array<{name: string, id: string, rows: number, cols: number}>}
    */
   inspectTables(slideIndex, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
+    const slideObj = slideManager.getSlideObj(slideIndex)
     const tables = []
 
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
     if (!spTree) return []
 
     let frames = spTree['p:graphicFrame'] || []
@@ -1064,8 +1016,16 @@ class TableManager {
   /**
    * Helper to find a table element inside a slide parsed object.
    */
-  #findTableObj(slideObj, tableId) {
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+  #findTableObj(slideObj, tableId, slideManager, slideIndex) {
+    if (slideManager && slideIndex !== undefined) {
+      const res = slideManager.getSlideTable(slideIndex, tableId)
+      return res ? res.table : null
+    }
+
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
     if (!spTree) return null
 
     let frames = spTree['p:graphicFrame'] || []
@@ -1089,6 +1049,15 @@ class TableManager {
     return null
   }
 
+  #getTableContext(slideIndex, tableId, slideManager) {
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const tblObj = this.#findTableObj(slideObj, tableId, slideManager, slideIndex)
+    if (!tblObj) {
+      throw new TableNotFoundError(`Table "${tableId}" not found in slide ${slideIndex}`)
+    }
+    return { slideObj, tblObj }
+  }
+
   /**
    * Generates a new rowId for the given row object.
    */

package/src/managers/ZOrderManager.js

@@ -2,14 +2,9 @@
  * @fileoverview ZOrderManager - Handles slide element Z-order (layer stacking) operations.
  */
 
-const { createLogger } = require('../utils/logger.js')
 const { PPTXError } = require('../utils/errors.js')
 const { Z_ORDER_SYMBOL } = require('../parsers/XMLParser.js')
 
-const logger = createLogger('ZOrderManager')
-
-const drawingTags = new Set(['p:sp', 'p:pic', 'p:graphicFrame', 'p:grpSp', 'p:cxnSp'])
-
 function detectElementType(tag, item) {
   if (tag === 'p:sp') {
     const isTxBox =