node-pptx-templater 1.0.17 → 1.0.19

package/src/managers/ImageManager.js

@@ -41,10 +41,7 @@ class ImageManager {
     mediaManager,
     relationshipManager
   ) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const picRes = this.#findPicRecursive(spTree, imageIdOrName)
+    const picRes = slideManager.getSlidePic(slideIndex, imageIdOrName)
 
     if (!picRes) {
       throw new PPTXError(`Image shape "${imageIdOrName}" not found on slide ${slideIndex}`)
@@ -85,9 +82,11 @@ class ImageManager {
     relationshipManager
   ) {
     const slideInfo = slideManager.getSlideInfo(slideIndex)
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    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) {
       throw new PPTXError(`Invalid slide structure for slide ${slideIndex}`)
@@ -155,8 +154,7 @@ class ImageManager {
     }
     spTree['p:pic'].push(picObj)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Added image "${name}" with ID ${newId} and rId ${rId} to slide ${slideIndex}`)
   }
 
@@ -169,10 +167,7 @@ class ImageManager {
    * @param {RelationshipManager} relationshipManager
    */
   removeImage(slideIndex, imageIdOrName, slideManager, relationshipManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const picRes = this.#findPicRecursive(spTree, imageIdOrName)
+    const picRes = slideManager.getSlidePic(slideIndex, imageIdOrName)
 
     if (!picRes) {
       throw new PPTXError(`Image shape "${imageIdOrName}" not found on slide ${slideIndex}`)
@@ -195,8 +190,7 @@ class ImageManager {
       relationshipManager.removeRelationship(slideInfo.zipPath, rId)
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Removed image "${imageIdOrName}" from slide ${slideIndex}`)
   }
 
@@ -210,9 +204,11 @@ class ImageManager {
    */
   getImages(slideIndex, slideManager, relationshipManager) {
     const slideInfo = slideManager.getSlideInfo(slideIndex)
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
 
     const imagesInfo = []
     this.#collectImagesInfo(spTree, slideInfo.zipPath, relationshipManager, imagesInfo)

package/src/managers/MediaManager.js

@@ -43,6 +43,15 @@ const fsExtra = require('fs-extra')
 
 const logger = createLogger('MediaManager')
 
+function streamToBuffer(stream) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    stream.on('data', chunk => chunks.push(chunk))
+    stream.on('end', () => resolve(Buffer.concat(chunks)))
+    stream.on('error', reject)
+  })
+}
+
 /**
  * Extension to MIME type mapping.
  */
@@ -106,30 +115,37 @@ class MediaManager {
     this.#zipManager = zipManager
     const mediaFiles = zipManager.listFiles('ppt/media/')
 
-    // Index all existing media files by content hash for deduplication
-    await Promise.all(
-      mediaFiles.map(async mediaPath => {
-        const data = await zipManager.readBinaryFile(mediaPath)
+    // Register all existing media files without loading/hashing them yet
+    for (const mediaPath of mediaFiles) {
+      const ext = mediaPath.split('.').pop().toLowerCase()
+      const mimeType = EXT_TO_MIME[ext] || 'application/octet-stream'
+
+      const mediaInfo = { zipPath: mediaPath, hash: null, mimeType, size: null }
+      this.#mediaRegistry.set(mediaPath, mediaInfo)
+
+      // Track the highest media ID to avoid collisions
+      const numMatch = /\d+/.exec(mediaPath.split('/').pop())
+      if (numMatch) {
+        const num = parseInt(numMatch[0], 10)
+        if (num >= this.#nextMediaId) this.#nextMediaId = num + 1
+      }
+    }
+
+    logger.debug(`Registered ${this.#mediaRegistry.size} media file(s) (lazy loading enabled)`)
+  }
+
+  async #ensureAllMediaHashed() {
+    for (const [mediaPath, mediaInfo] of this.#mediaRegistry.entries()) {
+      if (mediaInfo.hash === null) {
+        const data = await this.#zipManager.readBinaryFile(mediaPath)
         if (data) {
           const hash = this.#hashBytes(data)
-          const ext = mediaPath.split('.').pop().toLowerCase()
-          const mimeType = EXT_TO_MIME[ext] || 'application/octet-stream'
-
-          const mediaInfo = { zipPath: mediaPath, hash, mimeType, size: data.length }
+          mediaInfo.hash = hash
+          mediaInfo.size = data.length
           this.#mediaHashIndex.set(hash, mediaPath)
-          this.#mediaRegistry.set(mediaPath, mediaInfo)
-
-          // Track the highest media ID to avoid collisions
-          const numMatch = /\d+/.exec(mediaPath.split('/').pop())
-          if (numMatch) {
-            const num = parseInt(numMatch[0], 10)
-            if (num >= this.#nextMediaId) this.#nextMediaId = num + 1
-          }
         }
-      })
-    )
-
-    logger.debug(`Indexed ${this.#mediaRegistry.size} media file(s)`)
+      }
+    }
   }
 
   /**
@@ -152,23 +168,50 @@ class MediaManager {
   async embedImage(source, mimeType) {
     let data
     let ext
+    let hash
+    let size
+    const isStream = source && typeof source.on === 'function' && typeof source.pipe === 'function'
 
-    if (typeof source === 'string') {
-      // Load from file path
+    if (isStream) {
+      // Buffer the stream to avoid JSZip streaming pipeline crashes and file locks
+      data = await streamToBuffer(source)
+      if (source.path && typeof source.path === 'string') {
+        const filePath = source.path
+        ext = filePath.split('.').pop().toLowerCase()
+      } else {
+        ext = this.#detectExtension(data)
+      }
+      mimeType = mimeType || EXT_TO_MIME[ext] || 'image/png'
+      hash = this.#hashBytes(data)
+      size = data.length
+    } else if (typeof source === 'string') {
+      // Load from file path directly to buffer
       data = await fsExtra.readFile(source)
       ext = source.split('.').pop().toLowerCase()
       mimeType = mimeType || EXT_TO_MIME[ext] || 'image/png'
+      hash = this.#hashBytes(data)
+      size = data.length
     } else if (Buffer.isBuffer(source) || source instanceof Uint8Array) {
       data = source
-      // Detect format from magic bytes
       ext = this.#detectExtension(data)
       mimeType = mimeType || EXT_TO_MIME[ext] || 'image/png'
+      hash = this.#hashBytes(data)
+      size = data.length
     } else {
-      throw new PPTXError('embedImage: source must be a file path string or Buffer')
+      throw new PPTXError(
+        'embedImage: source must be a file path string, Buffer, or Readable Stream'
+      )
+    }
+
+    if (this.#mediaHashIndex.has(hash)) {
+      const existingPath = this.#mediaHashIndex.get(hash)
+      logger.debug(`Reusing existing media: ${existingPath} (hash: ${hash.substring(0, 8)}...)`)
+      return existingPath
     }
 
-    // Check for duplicate (content-addressable dedup)
-    const hash = this.#hashBytes(data)
+    // Ensure all media from template is hashed to check for duplicates
+    await this.#ensureAllMediaHashed()
+
     if (this.#mediaHashIndex.has(hash)) {
       const existingPath = this.#mediaHashIndex.get(hash)
       logger.debug(`Reusing existing media: ${existingPath} (hash: ${hash.substring(0, 8)}...)`)
@@ -180,13 +223,14 @@ class MediaManager {
     const zipPath = `ppt/media/image${mediaId}.${ext}`
 
     this.#zipManager.writeBinaryFile(zipPath, data)
+
     this.#mediaHashIndex.set(hash, zipPath)
-    this.#mediaRegistry.set(zipPath, { zipPath, hash, mimeType, size: data.length })
+    this.#mediaRegistry.set(zipPath, { zipPath, hash, mimeType, size })
 
     // Register content type
     this.#registerContentType(ext, mimeType)
 
-    logger.debug(`Embedded new media: ${zipPath} (${data.length} bytes)`)
+    logger.debug(`Embedded new media: ${zipPath} (${size} bytes)`)
     return zipPath
   }
 

package/src/managers/ShapeManager.js

@@ -31,19 +31,14 @@ class ShapeManager {
    * @param {SlideManager} slideManager
    */
   updateShapeText(slideIndex, shapeId, text, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const res = this.findShapeRecursive(spTree, shapeId)
+    const res = slideManager.getSlideShape(slideIndex, shapeId)
 
     if (!res) {
       throw new PPTXError(`Shape "${shapeId}" not found in slide ${slideIndex}`)
     }
 
     this.#setShapeTextObj(res.shape, text)
-
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Updated text for shape "${shapeId}" on slide ${slideIndex}`)
   }
 
@@ -60,10 +55,7 @@ class ShapeManager {
    * @param {SlideManager} slideManager
    */
   updateShapePosition(slideIndex, shapeId, options = {}, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const res = this.findShapeRecursive(spTree, shapeId)
+    const res = slideManager.getSlideShape(slideIndex, shapeId)
 
     if (!res) {
       throw new PPTXError(`Shape "${shapeId}" not found in slide ${slideIndex}`)
@@ -108,8 +100,7 @@ class ShapeManager {
       xfrm['a:ext']['@_cy'] = '0'
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Updated position/dimensions for shape "${shapeId}" on slide ${slideIndex}`)
   }
 
@@ -146,10 +137,8 @@ class ShapeManager {
    * @param {SlideManager} slideManager
    */
   cloneShape(slideIndex, shapeId, newShapeId, options = {}, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const res = this.findShapeRecursive(spTree, shapeId)
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const res = slideManager.getSlideShape(slideIndex, shapeId)
 
     if (!res) {
       throw new PPTXError(`Shape "${shapeId}" not found in slide ${slideIndex}`)
@@ -158,6 +147,11 @@ class ShapeManager {
     const newShape = this.#xmlParser.deepClone(res.shape)
     const cNvPr = newShape['p:nvSpPr']?.['p:cNvPr']
 
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
+
     const existingIds = this.#getAllShapeIds(spTree)
     const maxId = existingIds.length > 0 ? Math.max(...existingIds) : 1000
     const newId = maxId + 1
@@ -204,8 +198,7 @@ class ShapeManager {
     }
     parent['p:sp'].push(newShape)
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Cloned shape "${shapeId}" as "${newShapeId}"`)
   }
 
@@ -217,10 +210,7 @@ class ShapeManager {
    * @param {SlideManager} slideManager
    */
   deleteShape(slideIndex, shapeId, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
-    const res = this.findShapeRecursive(spTree, shapeId)
+    const res = slideManager.getSlideShape(slideIndex, shapeId)
 
     if (!res) {
       throw new PPTXError(`Shape "${shapeId}" not found in slide ${slideIndex}`)
@@ -235,8 +225,7 @@ class ShapeManager {
       }
     }
 
-    const decl = this.#xmlParser.extractDeclaration(slideXml)
-    slideManager.setSlideXml(slideIndex, this.#xmlParser.build(slideObj, decl))
+    slideManager.markSlideObjDirty(slideIndex)
     logger.debug(`Deleted shape "${shapeId}" from slide ${slideIndex}`)
   }
 
@@ -248,9 +237,11 @@ class ShapeManager {
    * @returns {Array<Object>}
    */
   getShapes(slideIndex, slideManager) {
-    const slideXml = slideManager.getSlideXml(slideIndex)
-    const slideObj = this.#xmlParser.parse(slideXml, `slide${slideIndex}.xml`)
-    const spTree = slideObj?.['p:sld']?.['p:cSld']?.['p:spTree']
+    const slideObj = slideManager.getSlideObj(slideIndex)
+    const spTree =
+      slideObj?.['p:sld']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldLayout']?.['p:cSld']?.['p:spTree'] ||
+      slideObj?.['p:sldMaster']?.['p:cSld']?.['p:spTree']
 
     const shapesInfo = []
     this.#collectShapesInfo(spTree, shapesInfo)

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 }