node-pptx-templater 1.0.5 → 1.0.7

package/src/managers/charts/ChartCacheGenerator.js

@@ -162,6 +162,377 @@ class ChartCacheGenerator {
     }
   }
 
+  static updateDataLabelsInXml(xml, seriesIndex, options, categories = [], seriesData = {}) {
+    let serIndex = 0
+    const serPattern = /(<c:ser>)([\s\S]*?)(<\/c:ser>)/g
+
+    return xml.replace(serPattern, (match, open, content, close) => {
+      if (serIndex !== seriesIndex) {
+        serIndex++
+        return match
+      }
+      serIndex++
+
+      let pointsCount = categories.length
+      if (pointsCount === 0) {
+        const valMatch = /<c:val>([\s\S]*?)<\/c:val>/.exec(content)
+        if (valMatch) {
+          const countMatch = /<c:ptCount val="(\d+)"\/>/.exec(valMatch[1])
+          if (countMatch) pointsCount = parseInt(countMatch[1], 10)
+        }
+      }
+      if (pointsCount === 0 && options.labels) {
+        pointsCount = options.labels.length
+      }
+
+      // Parse existing styling and flags from the current <c:dLbls> block
+      let existingTxPr = ''
+      let existingDLblPos = ''
+      let existingNumFmt = ''
+      const existingShowTags = {}
+
+      const dLblsMatch = /<c:dLbls>([\s\S]*?)<\/c:dLbls>/.exec(content)
+      if (dLblsMatch) {
+        const dLblsContent = dLblsMatch[1]
+        const txPrMatch = /(<c:txPr>[\s\S]*?<\/c:txPr>)/.exec(dLblsContent)
+        if (txPrMatch) {
+          existingTxPr = txPrMatch[1]
+        }
+        const dLblPosMatch = /(<c:dLblPos\s+[^>]*\/>)/.exec(dLblsContent)
+        if (dLblPosMatch) {
+          existingDLblPos = dLblPosMatch[1]
+        }
+        const numFmtMatch = /(<c:numFmt\s+[^>]*\/>)/.exec(dLblsContent)
+        if (numFmtMatch) {
+          existingNumFmt = numFmtMatch[1]
+        }
+        const showTagsList = [
+          'showLegendKey',
+          'showVal',
+          'showCatName',
+          'showSerName',
+          'showPercent',
+          'showBubbleSize',
+        ]
+        showTagsList.forEach(tag => {
+          const tagPattern = new RegExp(`(<c:${tag}\\s+val="([^"]*)"\\s*\\/>)`)
+          const tagMatch = tagPattern.exec(dLblsContent)
+          if (tagMatch) {
+            existingShowTags[tag] = tagMatch[1]
+          }
+        })
+      }
+
+      const dLblsXml = this.generateDLblsXml(
+        pointsCount,
+        options,
+        categories,
+        seriesData,
+        existingTxPr,
+        existingDLblPos,
+        existingNumFmt,
+        existingShowTags
+      )
+
+      let updatedContent = content
+      const dLblsPattern = /(<c:dLbls>[\s\S]*?<\/c:dLbls>)/
+      if (dLblsPattern.test(updatedContent)) {
+        updatedContent = updatedContent.replace(dLblsPattern, dLblsXml)
+      } else {
+        const insertBefore = /(<c:cat>|<c:val>|<c:extLst>)/
+        if (insertBefore.test(updatedContent)) {
+          updatedContent = updatedContent.replace(insertBefore, `${dLblsXml}$1`)
+        } else {
+          updatedContent += dLblsXml
+        }
+      }
+
+      return `${open}${updatedContent}${close}`
+    })
+  }
+
+  static generateDLblsXml(
+    pointsCount,
+    options,
+    categories = [],
+    seriesData = {},
+    existingTxPr = '',
+    existingDLblPos = '',
+    existingNumFmt = '',
+    existingShowTags = {}
+  ) {
+    const { labels, labelsFromCells, template, position, labelStyle, labelMap } = options
+
+    let xml = '<c:dLbls>'
+
+    const posMap = {
+      center: 'ctr',
+      insideEnd: 'inEnd',
+      insideBase: 'inBase',
+      outsideEnd: 'outEnd',
+      bestFit: 'bestFit',
+      left: 'l',
+      right: 'r',
+      top: 't',
+      bottom: 'b',
+    }
+    const openxmlPos = position ? posMap[position] : null
+
+    const values = seriesData.values || []
+    const sumValues = values.reduce((sum, v) => sum + (Number(v) || 0), 0)
+    const seriesName = seriesData.name || ''
+
+    const hasCustomLabels = labels || labelsFromCells || template || labelMap
+
+    if (hasCustomLabels && pointsCount > 0) {
+      for (let i = 0; i < pointsCount; i++) {
+        const cat = categories[i] !== undefined ? String(categories[i]) : ''
+        const val = values[i] !== undefined ? values[i] : ''
+
+        let pct = 0
+        if (sumValues > 0 && val !== '') {
+          pct = Math.round((Number(val) / sumValues) * 100)
+        }
+
+        let customLabel = ''
+        if (labels && labels[i] !== undefined) {
+          customLabel = String(labels[i])
+        } else if (labelMap && cat && labelMap[cat] !== undefined) {
+          customLabel = String(labelMap[cat])
+        }
+
+        let textContent = customLabel
+        if (template) {
+          textContent = template
+            .replace(/{category}/g, cat)
+            .replace(/{value}/g, String(val))
+            .replace(/{percentage}/g, String(pct))
+            .replace(/{series}/g, seriesName)
+            .replace(/{customLabel}/g, customLabel)
+        }
+
+        xml += `<c:dLbl>`
+        xml += `<c:idx val="${i}"/>`
+
+        if (labelsFromCells && !template) {
+          const range = ChartWorkbookUpdater.parseCellRange(labelsFromCells)
+          const startColNum = ChartWorkbookUpdater.colLetterToNum(range.startCol)
+
+          let cellRef
+          if (range.startRow === range.endRow) {
+            cellRef = `${ChartWorkbookUpdater.numToColLetter(startColNum + i)}${range.startRow}`
+          } else {
+            cellRef = `${range.startCol}${range.startRow + i}`
+          }
+          const fullCellRef = `${range.sheetName}!$${cellRef.replace(/(\d+)/, '$$$1')}`
+          const displayVal = textContent || customLabel || ''
+
+          xml += `<c:tx>`
+          xml += `<c:strRef>`
+          xml += `<c:f>${fullCellRef}</c:f>`
+          xml += `<c:strCache>`
+          xml += `<c:ptCount val="1"/>`
+          xml += `<c:pt idx="0"><c:v>${this.#escapeXml(displayVal)}</c:v></c:pt>`
+          xml += `</c:strCache>`
+          xml += `</c:strRef>`
+          xml += `</c:tx>`
+        } else if (textContent) {
+          if (labelsFromCells) {
+            const range = ChartWorkbookUpdater.parseCellRange(labelsFromCells)
+            const startColNum = ChartWorkbookUpdater.colLetterToNum(range.startCol)
+            let cellRef
+            if (range.startRow === range.endRow) {
+              cellRef = `${ChartWorkbookUpdater.numToColLetter(startColNum + i)}${range.startRow}`
+            } else {
+              cellRef = `${range.startCol}${range.startRow + i}`
+            }
+            const fullCellRef = `${range.sheetName}!$${cellRef.replace(/(\d+)/, '$$$1')}`
+
+            xml += `<c:tx>`
+            xml += `<c:strRef>`
+            xml += `<c:f>${fullCellRef}</c:f>`
+            xml += `<c:strCache>`
+            xml += `<c:ptCount val="1"/>`
+            xml += `<c:pt idx="0"><c:v>${this.#escapeXml(textContent)}</c:v></c:pt>`
+            xml += `</c:strCache>`
+            xml += `</c:strRef>`
+            xml += `</c:tx>`
+          } else {
+            xml += `<c:tx>`
+            xml += `<c:rich>`
+            xml += `<a:bodyPr/>`
+            xml += `<a:lstStyle/>`
+            xml += `<a:p>`
+            xml += `<a:r>`
+            xml += `<a:t>${this.#escapeXml(textContent)}</a:t>`
+            xml += `</a:r>`
+            xml += `</a:p>`
+            xml += `</c:rich>`
+            xml += `</c:tx>`
+          }
+        }
+
+        if (labelStyle) {
+          xml += this.generateTxPrXml(labelStyle)
+        } else if (existingTxPr) {
+          xml += existingTxPr
+        }
+
+        if (openxmlPos) {
+          xml += `<c:dLblPos val="${openxmlPos}"/>`
+        } else if (existingDLblPos) {
+          xml += existingDLblPos
+        }
+
+        xml += `<c:showLegendKey val="0"/>`
+        xml += `<c:showVal val="0"/>`
+        xml += `<c:showCatName val="0"/>`
+        xml += `<c:showSerName val="0"/>`
+        xml += `<c:showPercent val="0"/>`
+        xml += `<c:showBubbleSize val="0"/>`
+
+        xml += `</c:dLbl>`
+      }
+    }
+
+    if (existingNumFmt) {
+      xml += existingNumFmt
+    }
+
+    if (labelStyle) {
+      xml += this.generateTxPrXml(labelStyle)
+    } else if (existingTxPr) {
+      xml += existingTxPr
+    }
+
+    if (openxmlPos) {
+      xml += `<c:dLblPos val="${openxmlPos}"/>`
+    } else if (existingDLblPos) {
+      xml += existingDLblPos
+    }
+
+    // showLegendKey
+    if (existingShowTags['showLegendKey']) {
+      xml += existingShowTags['showLegendKey']
+    } else {
+      xml += `<c:showLegendKey val="0"/>`
+    }
+
+    // showVal
+    const defaultShowVal = hasCustomLabels ? '0' : '1'
+    if (existingShowTags['showVal'] && !hasCustomLabels) {
+      xml += existingShowTags['showVal']
+    } else {
+      xml += `<c:showVal val="${defaultShowVal}"/>`
+    }
+
+    // showCatName
+    if (existingShowTags['showCatName']) {
+      xml += existingShowTags['showCatName']
+    } else {
+      xml += `<c:showCatName val="0"/>`
+    }
+
+    // showSerName
+    if (existingShowTags['showSerName']) {
+      xml += existingShowTags['showSerName']
+    } else {
+      xml += `<c:showSerName val="0"/>`
+    }
+
+    // showPercent
+    const defaultShowPercent = hasCustomLabels || !options.showPercent ? '0' : '1'
+    if (options.showPercent !== undefined) {
+      xml += `<c:showPercent val="${options.showPercent ? '1' : '0'}"/>`
+    } else if (existingShowTags['showPercent'] && !hasCustomLabels) {
+      xml += existingShowTags['showPercent']
+    } else {
+      xml += `<c:showPercent val="${defaultShowPercent}"/>`
+    }
+
+    // showBubbleSize
+    if (existingShowTags['showBubbleSize']) {
+      xml += existingShowTags['showBubbleSize']
+    } else {
+      xml += `<c:showBubbleSize val="0"/>`
+    }
+
+    xml += '</c:dLbls>'
+    return xml
+  }
+
+  static generateTxPrXml(style) {
+    const { fontFamily, fontSize, bold, italic, underline, color } = style
+
+    const sz = fontSize ? ` sz="${fontSize * 100}"` : ''
+    const b = bold !== undefined ? ` b="${bold ? '1' : '0'}"` : ''
+    const i = italic !== undefined ? ` i="${italic ? '1' : '0'}"` : ''
+    const u = underline !== undefined ? ` u="${underline ? 'sng' : 'none'}"` : ''
+
+    let fillXml = ''
+    if (color) {
+      const cleanColor = color.replace('#', '')
+      fillXml = `<a:solidFill><a:srgbClr val="${cleanColor}"/></a:solidFill>`
+    }
+
+    let latinXml = ''
+    if (fontFamily) {
+      latinXml = `<a:latin typeface="${fontFamily}"/><a:cs typeface="${fontFamily}"/>`
+    }
+
+    return `<c:txPr>
+      <a:bodyPr/>
+      <a:lstStyle/>
+      <a:p>
+        <a:pPr>
+          <a:defRPr${sz}${b}${i}${u}>
+            ${fillXml}
+            ${latinXml}
+          </a:defRPr>
+        </a:pPr>
+        <a:endParaRPr lang="en-US"/>
+      </a:p>
+    </c:txPr>`
+  }
+
+  static getDataLabelsFromXml(xml, seriesIndex) {
+    const serPattern = /<c:ser>([\s\S]*?)<\/c:ser>/g
+    const matches = [...xml.matchAll(serPattern)]
+    if (seriesIndex >= matches.length) return []
+
+    const serXml = matches[seriesIndex][1]
+    const dLblsMatch = /<c:dLbls>([\s\S]*?)<\/c:dLbls>/.exec(serXml)
+    if (!dLblsMatch) return []
+
+    const dLblsXml = dLblsMatch[1]
+    const dLblPattern = /<c:dLbl>([\s\S]*?)<\/c:dLbl>/g
+    const result = []
+
+    let dLblMatch
+    while ((dLblMatch = dLblPattern.exec(dLblsXml)) !== null) {
+      const dLblXml = dLblMatch[1]
+      const idxMatch = /<c:idx val="(\d+)"\/>/.exec(dLblXml)
+      if (!idxMatch) continue
+      const point = parseInt(idxMatch[1], 10)
+
+      let value = ''
+      const strCacheMatch = /<c:strCache>([\s\S]*?)<\/c:strCache>/.exec(dLblXml)
+      if (strCacheMatch) {
+        const vMatch = /<c:v>([^<]*)<\/c:v>/.exec(strCacheMatch[1])
+        if (vMatch) value = vMatch[1]
+      } else {
+        const tPattern = /<a:t>([^<]*)<\/a:t>/g
+        let tMatch
+        while ((tMatch = tPattern.exec(dLblXml)) !== null) {
+          value += tMatch[1]
+        }
+      }
+
+      result.push({ point, value })
+    }
+    return result
+  }
+
   static #escapeXml(str) {
     return str
       .replace(/&/g, '&amp;')

package/src/managers/charts/ChartWorkbookUpdater.js

@@ -20,14 +20,22 @@ class ChartWorkbookUpdater {
       // Look for sheet1.xml
       const sheetPath = 'xl/worksheets/sheet1.xml'
       if (!zip.file(sheetPath)) {
-        logger.warn('sheet1.xml not found in embedded workbook, trying to find first sheet')
-        // fallback to finding the first sheet
+        logger.warn('sheet1.xml not found in embedded workbook')
+        return workbookData
       }
 
-      const newSheetXml = this.#generateSheetXml(data)
-      zip.file(sheetPath, newSheetXml)
+      const sheetXml = await zip.file(sheetPath).async('text')
+      const sharedStrings = await this.getSharedStrings(zip)
+      const cells = this.parseWorksheetCells(sheetXml, sharedStrings)
 
-      // Clean up any existing Excel tables, as our new sheet data might not align with them
+      // Update categories, series values, and custom labels in the cell grid
+      this.#updateCellGrid(cells, data)
+
+      // Serialize cells to sheet XML
+      const updatedSheetXml = this.#serializeSheetXml(sheetXml, cells)
+      zip.file(sheetPath, updatedSheetXml)
+
+      // Clean up any existing Excel tables
       const tableFiles = Object.keys(zip.files).filter(f => f.startsWith('xl/tables/'))
       tableFiles.forEach(f => zip.remove(f))
 
@@ -56,50 +64,162 @@ class ChartWorkbookUpdater {
     }
   }
 
-  static #generateSheetXml(data) {
-    const { categories = [], series = [] } = data
+  static async getSharedStrings(zip) {
+    const sstFile = zip.file('xl/sharedStrings.xml')
+    if (!sstFile) return []
+    const xml = await sstFile.async('text')
+    const strings = []
+    const pattern = /<si>([\s\S]*?)<\/si>/g
+    let match
+    while ((match = pattern.exec(xml)) !== null) {
+      const siContent = match[1]
+      const tPattern = /<t\b[^>]*>([^<]*)<\/t>/g
+      let tMatch
+      let textVal = ''
+      while ((tMatch = tPattern.exec(siContent)) !== null) {
+        textVal += tMatch[1]
+      }
+      strings.push(textVal)
+    }
+    return strings
+  }
 
-    // Column count = 1 (categories) + series.length
-    const numCols = 1 + series.length
-    const numRows = 1 + categories.length // Row 1 = headers
+  static parseWorksheetCells(sheetXml, sharedStrings) {
+    const cells = {}
+    const cellPattern = /<c r="([A-Z]+\d+)"([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g
+    let match
+    while ((match = cellPattern.exec(sheetXml)) !== null) {
+      const ref = match[1]
+      const attrs = match[2]
+      const content = match[3] || ''
 
-    const lastColLetter = this.getColumnLetter(numCols - 1)
-    const dimensionRef = `A1:${lastColLetter}${numRows}`
+      const tMatch = /t="([^"]*)"/.exec(attrs)
+      const t = tMatch ? tMatch[1] : null
 
-    let sheetData = '<sheetData>'
+      let val = ''
+      if (t === 'inlineStr') {
+        const tValMatch = /<t\b[^>]*>([^<]*)<\/t>/.exec(content)
+        val = tValMatch ? tValMatch[1] : ''
+      } else if (t === 's') {
+        const vMatch = /<v>(\d+)<\/v>/.exec(content)
+        if (vMatch) {
+          const idx = parseInt(vMatch[1], 10)
+          val = sharedStrings[idx] !== undefined ? sharedStrings[idx] : ''
+        }
+      } else if (content) {
+        const vMatch = /<v>([^<]*)<\/v>/.exec(content)
+        if (vMatch) {
+          val = vMatch[1]
+          if (val !== '' && !isNaN(val)) {
+            val = Number(val)
+          }
+        }
+      }
+      cells[ref] = val
+    }
+    return cells
+  }
+
+  static #updateCellGrid(cells, data) {
+    const { categories = [], series = [] } = data
 
-    // Row 1: Headers (empty cell A1, then series names)
-    sheetData += '<row r="1">'
-    sheetData += `<c r="A1" t="inlineStr"><is><t></t></is></c>`
+    // 1. Write Header A1 as empty
+    cells['A1'] = ''
+
+    // 2. Write series titles in Row 1 (B1, C1, etc.)
     series.forEach((ser, i) => {
       const colLetter = this.getColumnLetter(i + 1)
-      sheetData += `<c r="${colLetter}1" t="inlineStr"><is><t>${this.#escapeXml(ser.name || '')}</t></is></c>`
+      cells[`${colLetter}1`] = ser.name || ''
     })
-    sheetData += '</row>'
 
-    // Rows 2..N: Data (category name in A, then values)
+    // 3. Write categories in column A (A2, A3, etc.)
     categories.forEach((cat, rowIndex) => {
-      const r = rowIndex + 2 // +1 for 1-based, +1 for header row
+      cells[`A${rowIndex + 2}`] = String(cat)
+    })
+
+    // 4. Write series values
+    series.forEach((ser, colIndex) => {
+      const colLetter = this.getColumnLetter(colIndex + 1)
+      if (ser.values) {
+        ser.values.forEach((val, rowIndex) => {
+          cells[`${colLetter}${rowIndex + 2}`] = val !== undefined ? val : 0
+        })
+      }
+    })
+
+    // 5. Write custom data labels
+    series.forEach(ser => {
+      if (ser.labels && ser.labelsFromCells) {
+        const range = this.parseCellRange(ser.labelsFromCells)
+        const startColNum = this.colLetterToNum(range.startCol)
+        ser.labels.forEach((lbl, i) => {
+          let cellRef
+          if (range.startRow === range.endRow) {
+            cellRef = `${this.numToColLetter(startColNum + i)}${range.startRow}`
+          } else {
+            cellRef = `${range.startCol}${range.startRow + i}`
+          }
+          cells[cellRef] = lbl
+        })
+      }
+    })
+  }
+
+  static #serializeSheetXml(sheetXml, cells) {
+    // Group cells by row
+    const rows = {}
+    for (const [ref, val] of Object.entries(cells)) {
+      const rowMatch = /\d+$/.exec(ref)
+      if (!rowMatch) continue
+      const r = parseInt(rowMatch[0], 10)
+      if (!rows[r]) rows[r] = []
+      rows[r].push(ref)
+    }
+
+    // Sort rows ascending
+    const sortedRowKeys = Object.keys(rows)
+      .map(Number)
+      .sort((a, b) => a - b)
+
+    let maxRow = 1
+    let maxColNum = 0
+
+    let sheetData = '<sheetData>'
+    for (const r of sortedRowKeys) {
+      if (r > maxRow) maxRow = r
       sheetData += `<row r="${r}">`
-      sheetData += `<c r="A${r}" t="inlineStr"><is><t>${this.#escapeXml(String(cat))}</t></is></c>`
 
-      series.forEach((ser, colIndex) => {
-        const colLetter = this.getColumnLetter(colIndex + 1)
-        const val = ser.values && ser.values[rowIndex] !== undefined ? ser.values[rowIndex] : 0
-        sheetData += `<c r="${colLetter}${r}"><v>${Number(val)}</v></c>`
+      // Sort cells in this row by column letters
+      const sortedRefs = rows[r].sort((a, b) => {
+        const colA = /^[A-Z]+/.exec(a)[0]
+        const colB = /^[A-Z]+/.exec(b)[0]
+        if (colA.length !== colB.length) return colA.length - colB.length
+        return colA.localeCompare(colB)
       })
-      sheetData += '</row>'
-    })
 
+      for (const ref of sortedRefs) {
+        const colLetter = /^[A-Z]+/.exec(ref)[0]
+        const colNum = this.colLetterToNum(colLetter)
+        if (colNum > maxColNum) maxColNum = colNum
+
+        const val = cells[ref]
+        if (typeof val === 'number') {
+          sheetData += `<c r="${ref}"><v>${val}</v></c>`
+        } else {
+          sheetData += `<c r="${ref}" t="inlineStr"><is><t>${this.#escapeXml(String(val))}</t></is></c>`
+        }
+      }
+      sheetData += '</row>'
+    }
     sheetData += '</sheetData>'
 
-    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
-  <dimension ref="${dimensionRef}"/>
-  <sheetViews><sheetView workbookViewId="0"/></sheetViews>
-  <sheetFormatPr defaultRowHeight="15"/>
-  ${sheetData}
-</worksheet>`
+    const maxColLetter = this.numToColLetter(maxColNum)
+    const newDimension = `<dimension ref="A1:${maxColLetter}${maxRow}"/>`
+
+    let updatedXml = sheetXml.replace(/<sheetData>[\s\S]*?<\/sheetData>/, sheetData)
+    updatedXml = updatedXml.replace(/<dimension ref="[^"]*"\/>/, newDimension)
+
+    return updatedXml
   }
 
   static getColumnLetter(colIndex) {
@@ -111,6 +231,39 @@ class ChartWorkbookUpdater {
     return letter
   }
 
+  static colLetterToNum(letter) {
+    let num = 0
+    for (let i = 0; i < letter.length; i++) {
+      num = num * 26 + (letter.charCodeAt(i) - 64)
+    }
+    return num - 1
+  }
+
+  static numToColLetter(num) {
+    return this.getColumnLetter(num)
+  }
+
+  static parseCellRange(rangeStr) {
+    const parts = rangeStr.split('!')
+    const range = parts.length > 1 ? parts[1] : parts[0]
+    const cleanRange = range.replace(/\$/g, '')
+    const [start, end] = cleanRange.split(':')
+
+    const startCol = /^[A-Z]+/.exec(start)[0]
+    const startRow = parseInt(/\d+$/.exec(start)[0], 10)
+
+    const endCol = end ? /^[A-Z]+/.exec(end)[0] : startCol
+    const endRow = end ? parseInt(/\d+$/.exec(end)[0], 10) : startRow
+
+    return {
+      sheetName: parts.length > 1 ? parts[0] : 'Sheet1',
+      startCol,
+      startRow,
+      endCol,
+      endRow,
+    }
+  }
+
   static getFormulaRange(sheetName, startRow, startCol, endRow, endCol) {
     const startLetter = this.getColumnLetter(startCol)
     const endLetter = this.getColumnLetter(endCol)

package/src/parsers/XMLParser.js

@@ -124,6 +124,38 @@ function attachZOrder(normalContainer, containerId, containerMap) {
   }
 }
 
+/**
+ * Unescapes XML entities safely and non-recursively.
+ * Supports standard XML entities and numeric decimal/hex code points.
+ *
+ * @param {string} str - XML value to unescape.
+ * @returns {string} Unescaped string.
+ */
+function unescapeXml(str) {
+  if (typeof str !== 'string') return str
+  if (str.indexOf('&') === -1) return str
+  return str
+    .replace(/&/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (match, dec) => {
+      try {
+        return String.fromCodePoint(parseInt(dec, 10))
+      } catch (e) {
+        return match
+      }
+    })
+    .replace(/&#x([0-9a-fA-F]+);/g, (match, hex) => {
+      try {
+        return String.fromCodePoint(parseInt(hex, 16))
+      } catch (e) {
+        return match
+      }
+    })
+}
+
 /**
  * Parser configuration for fast-xml-parser.
  * These settings ensure lossless round-trip XML parsing.
@@ -139,7 +171,9 @@ const PARSER_OPTIONS = {
   commentPropName: '__comment',
   preserveOrder: false,
   trimValues: false,
-  processEntities: true,
+  processEntities: false,
+  tagValueProcessor: (tagName, val) => unescapeXml(val),
+  attributeValueProcessor: (attrName, val) => unescapeXml(val),
   htmlEntities: false,
   isArray: (name, jpath) => {
     // Elements that should ALWAYS be arrays (even when there's only one)
@@ -217,6 +251,9 @@ class XMLParser {
       attributeNamePrefix: '@_',
       parseAttributeValue: false,
       parseTagValue: false,
+      processEntities: false,
+      tagValueProcessor: (tagName, val) => unescapeXml(val),
+      attributeValueProcessor: (attrName, val) => unescapeXml(val),
     })
   }