node-pptx-templater 1.0.20 → 1.0.21

package/README.md

@@ -173,6 +173,22 @@ if (!report.valid) {
 }
 ```
 
+### 5. PPTX Extraction & Rebuilding Utilities
+
+You can programmatically extract standard zipped `.pptx` archives into OpenXML folder templates or compile them back. Target directories are created automatically:
+
+#### Extract PPTX to Folder Template
+```javascript
+const { PPTXTemplate } = require('node-pptx-templater');
+
+await PPTXTemplate.extractPptx('./sample.pptx', './output/template', { overwrite: true });
+```
+
+#### Rebuild PPTX from Folder Template
+```javascript
+await PPTXTemplate.buildPptx('./templates/sample', './output.pptx');
+```
+
 ---
 
 ## 📋 OpenXML Presentation Architecture
@@ -208,6 +224,95 @@ Naively duplicating rows in slide tables can leave duplicate `rowId` values or b
 
 ---
 
+## 📊 Reading Table Data & JSON Extraction
+
+PPTXForge allows you to read table data from your template and return it as structured JSON objects or raw arrays. This is extremely useful for reverse-engineering data or verifying layouts.
+
+### 1. Object-Based Extraction (Default)
+By default, the first row is treated as headers, and subsequent rows are returned as objects keyed by header names. Merged cells automatically resolve to their parent cell's value:
+```javascript
+const rows = await ppt.getTableRows('SalesTable');
+// Returns:
+// [
+//   { region: 'North', sales: '1200', growth: '15%' },
+//   { region: 'South', sales: '1800', growth: '22%' }
+// ]
+```
+
+### 2. Raw Extraction
+Return a raw 2D array of string values (excluding the header row) by passing `{ raw: true }`:
+```javascript
+const rows = await ppt.getTableRows('SalesTable', { raw: true });
+// Returns:
+// [
+//   ['North', '1200', '15%'],
+//   ['South', '1800', '22%']
+// ]
+```
+
+### 3. Including Table Metadata
+Pass `{ includeMetadata: true }` to retrieve row counts, column counts, and the list of merged cell ranges alongside the rows:
+```javascript
+const result = await ppt.getTableRows('SalesTable', { includeMetadata: true });
+// Returns:
+// {
+//   rows: [...],
+//   rowCount: 10,
+//   columnCount: 5,
+//   mergedCells: [ { startRow: 1, startCol: 0, endRow: 2, endCol: 0 }, ... ]
+// }
+```
+
+---
+
+## 📈 Nested Table Rows & Rowspan Support
+
+When building financial sheets, invoices, or hierarchical dashboards, you often need to stack multiple rows vertically inside a single column while spanning cells in other columns. PPTXForge supports nested arrays in `addTableRow()` to automatically handle:
+- Proportional height scaling.
+- Vertical merge (`vMerge`) and row span (`rowSpan`) generation.
+- Dynamic layout adjustments.
+
+### 1. Vertical Row Nesting Example
+```javascript
+await ppt.addTableRow('Table1', [
+  'Region',
+  ['Sales', '1200'],
+  ['Growth', '15%']
+]);
+```
+Generates:
+```text
++---------+---------+---------+
+| Region  | Sales   | Growth  |
+|         | 1200    | 15%     |
++---------+---------+---------+
+```
+
+### 2. Deep Nesting Example
+```javascript
+await ppt.addTableRow('Table1', [
+  'Parent',
+  [
+    'Child 1',
+    'Child 2',
+    'Child 3'
+  ]
+]);
+```
+Generates 3 sub-rows where column 0 automatically spans all 3 rows.
+
+### 3. Merge Strategies
+Configure merge behavior via `options.mergeStrategy`:
+- `'auto'` (default): Creates structural merges from nested arrays, and additionally merges consecutive duplicate values in the same column.
+- `'rowspan'`: Creates structural rowspan/merges strictly from the nested array structure.
+- `'none'`: Pads columns to match the target generated height but does not merge cells (leaving them as individual cells).
+
+```javascript
+await ppt.addTableRow('Table1', data, { mergeStrategy: 'rowspan' });
+```
+
+---
+
 ## 📊 Feature Comparison Matrix
 
 Compare PPTXForge with other popular PowerPoint automation libraries:
@@ -300,6 +405,41 @@ Discovers and retrieves details of an existing cell shape on the targeted slide.
 const shape = ppt.getCellShape('Table', 1, 2, 0);
 ```
 
+#### `getCellBounds(tableId, rowIndex, colIndex)`
+Retrieves final rendered bounds of a table cell in pixels.
+
+* **Arguments**:
+  * `tableId` (`string`): Table name or shape ID.
+  * `rowIndex` (`number`): 0-based row index.
+  * `colIndex` (`number`): 0-based column index.
+* **Returns**: `Object|null` - Cell bounds { x, y, width, height } in pixels, or null.
+
+```javascript
+const bounds = ppt.getCellBounds('summary-table', 1, 1);
+```
+
+#### `getCellPosition(tableId, rowIndex, colIndex)`
+Retrieves final rendered position of a table cell in pixels.
+
+* **Arguments**:
+  * `tableId` (`string`): Table name or shape ID.
+  * `rowIndex` (`number`): 0-based row index.
+  * `colIndex` (`number`): 0-based column index.
+* **Returns**: `Object|null` - Cell position { row, column, x, y } in pixels, or null.
+
+```javascript
+const pos = ppt.getCellPosition('summary-table', 1, 1);
+```
+
+#### `getTableRows(())`
+Delegates core actions to slide element sub-managers.
+
+* **Returns**: `PPTXTemplater` - The fluent engine instance.
+
+```javascript
+const rows = await ppt.getTableRows('SalesTable');
+```
+
 #### `addTableRow(())`
 Delegates core actions to slide element sub-managers.
 
@@ -1587,6 +1727,24 @@ Delegates core actions to slide element sub-managers.
 const ppt = await PPTXTemplate.fromPresentationXml('./template-folder');
 ```
 
+#### `extractPptx(())`
+Delegates core actions to slide element sub-managers.
+
+* **Returns**: `PPTXTemplater` - The fluent engine instance.
+
+```javascript
+await PPTXTemplater.extractPptx('sample.pptx', './extracted');
+```
+
+#### `buildPptx(())`
+Delegates core actions to slide element sub-managers.
+
+* **Returns**: `PPTXTemplater` - The fluent engine instance.
+
+```javascript
+await PPTXTemplater.buildPptx('./extracted', 'output.pptx');
+```
+
 #### `validatePresentation(())`
 Delegates core actions to slide element sub-managers.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-pptx-templater",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "High-performance, low-level PowerPoint (PPTX) OpenXML template engine for Node.js. Dynamically replace text, insert images, update charts (with Excel workbook data caching), and merge table cells without PowerPoint corruption or Repair Mode prompts.",
   "main": "./src/index.js",
   "type": "commonjs",

package/src/core/PPTXTemplater.js

@@ -340,6 +340,89 @@ class PPTXTemplater {
     return engine
   }
 
+  /**
+   * Extracts a PPTX file into an unzipped OpenXML folder structure.
+   *
+   * @static
+   * @param {string} pptxPath - Path to the source PPTX file.
+   * @param {string} outputPath - Path to the destination folder.
+   * @param {Object} [options] - Options (e.g. { overwrite: true }).
+   * @returns {Promise<void>}
+   */
+  static async extractPptx(pptxPath, outputPath, options = {}) {
+    const fs = require('fs-extra')
+    const path = require('path')
+
+    const resolvedPptx = path.resolve(pptxPath)
+    const resolvedOut = path.resolve(outputPath)
+
+    if (!fs.existsSync(resolvedPptx)) {
+      throw new PPTXError(`Source PPTX file not found: ${pptxPath}`)
+    }
+
+    if (fs.existsSync(resolvedOut)) {
+      const stats = fs.statSync(resolvedOut)
+      if (stats.isFile()) {
+        throw new PPTXError(`Destination is a file: ${outputPath}`)
+      }
+      const files = fs.readdirSync(resolvedOut)
+      if (files.length > 0 && !options.overwrite) {
+        throw new PPTXError(
+          `Destination directory "${outputPath}" is not empty. Set overwrite: true to overwrite.`
+        )
+      }
+    } else {
+      await fs.ensureDir(resolvedOut)
+    }
+
+    const engine = await PPTXTemplater.load(resolvedPptx)
+    await engine.#zipManager.toFolder(resolvedOut)
+
+    // Validation
+    const criticalParts = ['ppt/presentation.xml', 'ppt/slides', 'ppt/_rels', '[Content_Types].xml']
+
+    for (const part of criticalParts) {
+      const p = path.join(resolvedOut, part)
+      if (!fs.existsSync(p)) {
+        throw new PPTXError(`Extracted structure is missing critical part: ${part}`)
+      }
+    }
+  }
+
+  /**
+   * Rebuilds a PPTX file from an unzipped OpenXML folder structure.
+   *
+   * @static
+   * @param {string} folderPath - Path to the source folder structure.
+   * @param {string} pptxPath - Path to the destination PPTX file.
+   * @returns {Promise<void>}
+   */
+  static async buildPptx(folderPath, pptxPath) {
+    const fs = require('fs-extra')
+    const path = require('path')
+
+    const resolvedFolder = path.resolve(folderPath)
+    const resolvedPptx = path.resolve(pptxPath)
+
+    if (!fs.existsSync(resolvedFolder)) {
+      throw new PPTXError(`Source folder not found: ${folderPath}`)
+    }
+
+    // Validation of the source folder
+    const criticalParts = ['ppt/presentation.xml', 'ppt/slides', 'ppt/_rels', '[Content_Types].xml']
+
+    for (const part of criticalParts) {
+      const p = path.join(resolvedFolder, part)
+      if (!fs.existsSync(p)) {
+        throw new PPTXError(`Source folder is missing critical OpenXML part: ${part}`)
+      }
+    }
+
+    const engine = await PPTXTemplater.load(resolvedFolder)
+    await fs.ensureDir(path.dirname(resolvedPptx))
+    await engine.saveToFile(resolvedPptx)
+  }
+
   /**
    * Initializes the engine by loading a PPTX file/buffer.
    * @private
@@ -1297,11 +1380,21 @@ class PPTXTemplater {
   }
 
   // === Table Features ===
-  addTableRow(tableId, rowData) {
+  getTableRows(tableId, options = {}) {
+    this.#assertLoaded()
+    const targetIndices = this.#getTargetSlideIndices()
+    if (targetIndices.length === 0) {
+      throw new PPTXError('No slides active/loaded')
+    }
+    const idx = targetIndices[0]
+    return this.#tableManager.getTableRows(idx, tableId, options, this.#slideManager)
+  }
+
+  addTableRow(tableId, rowData, options = {}) {
     this.#assertLoaded()
     const targetIndices = this.#getTargetSlideIndices()
     for (const idx of targetIndices) {
-      this.#tableManager.addTableRow(idx, tableId, rowData, this.#slideManager)
+      this.#tableManager.addTableRow(idx, tableId, rowData, this.#slideManager, options)
     }
     return this
   }
@@ -2099,6 +2192,66 @@ class PPTXTemplater {
     return null
   }
 
+  /**
+   * Retrieves final rendered bounds of a table cell in pixels.
+   *
+   * @param {string} tableId - Table name or shape ID.
+   * @param {number} rowIndex - 0-based row index.
+   * @param {number} colIndex - 0-based column index.
+   * @returns {Object|null} Cell bounds { x, y, width, height } in pixels, or null.
+   */
+  getCellBounds(tableId, rowIndex, colIndex) {
+    this.#assertLoaded()
+    const targetIndices = this.#getTargetSlideIndices()
+    for (const idx of targetIndices) {
+      try {
+        const bounds = this.#tableManager.getCellBounds(
+          idx,
+          tableId,
+          rowIndex,
+          colIndex,
+          this.#slideManager
+        )
+        if (bounds) return bounds
+      } catch (err) {
+        logger.debug(
+          `Could not get cell bounds for table ${tableId} on slide ${idx}: ${err.message}`
+        )
+      }
+    }
+    return null
+  }
+
+  /**
+   * Retrieves final rendered position of a table cell in pixels.
+   *
+   * @param {string} tableId - Table name or shape ID.
+   * @param {number} rowIndex - 0-based row index.
+   * @param {number} colIndex - 0-based column index.
+   * @returns {Object|null} Cell position { row, column, x, y } in pixels, or null.
+   */
+  getCellPosition(tableId, rowIndex, colIndex) {
+    this.#assertLoaded()
+    const targetIndices = this.#getTargetSlideIndices()
+    for (const idx of targetIndices) {
+      try {
+        const pos = this.#tableManager.getCellPosition(
+          idx,
+          tableId,
+          rowIndex,
+          colIndex,
+          this.#slideManager
+        )
+        if (pos) return pos
+      } catch (err) {
+        logger.debug(
+          `Could not get cell position for table ${tableId} on slide ${idx}: ${err.message}`
+        )
+      }
+    }
+    return null
+  }
+
   // === Image Features ===
   async replaceImage(imageIdOrName, sourcePathOrBuffer) {
     this.#assertLoaded()

package/src/managers/TableManager.js

@@ -223,6 +223,8 @@ class TableManager {
       )
     }
 
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
+
     if (cellShapes) {
       this.#processCellShapes(
         slideIndex,
@@ -251,7 +253,7 @@ class TableManager {
    * @param {string[]} rowData
    * @param {SlideManager} slideManager
    */
-  addTableRow(slideIndex, tableId, rowData, slideManager) {
+  addTableRow(slideIndex, tableId, rowData, slideManager, options = {}) {
     const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
 
     const trs = tblObj['a:tr'] || []
@@ -260,18 +262,69 @@ class TableManager {
     }
 
     const lastRow = trs[trs.length - 1]
-    const newRow = this.#xmlParser.deepClone(lastRow)
-    this.#updateRowId(newRow)
+    const numCols = lastRow['a:tc']?.length || 0
 
-    const tcs = newRow['a:tc'] || []
-    for (let j = 0; j < tcs.length; j++) {
-      this.#setCellTextObj(tcs[j], rowData[j] !== undefined ? rowData[j] : '')
-      // Clear any merged indicators for the new row by default
-      if (tcs[j]['@_hMerge']) delete tcs[j]['@_hMerge']
-      if (tcs[j]['@_vMerge']) delete tcs[j]['@_vMerge']
+    // Compute target generated height
+    const heights = []
+    for (let c = 0; c < numCols; c++) {
+      heights.push(this.#getNestedHeight(rowData[c]))
     }
+    const targetHeight = Math.max(1, ...heights)
 
-    trs.push(newRow)
+    // Expand each column value to targetHeight
+    const expandedCols = []
+    const strategy = options.mergeStrategy || 'auto'
+    for (let c = 0; c < numCols; c++) {
+      let colCells = this.#expandCellVal(rowData[c], targetHeight)
+      if (strategy === 'none') {
+        for (let i = 0; i < colCells.length; i++) {
+          if (colCells[i].vMerge) {
+            colCells[i] = { value: '', rowSpan: 1 }
+          } else {
+            colCells[i].rowSpan = 1
+          }
+        }
+      } else if (strategy === 'auto') {
+        colCells = this.#applyAutoMerge(colCells)
+      }
+      expandedCols.push(colCells)
+    }
+
+    // Clone and append rows
+    for (let r = 0; r < targetHeight; r++) {
+      const newRow = this.#xmlParser.deepClone(lastRow)
+      this.#updateRowId(newRow)
+
+      const tcs = newRow['a:tc'] || []
+      for (let c = 0; c < numCols; c++) {
+        const cellDef = expandedCols[c][r]
+        const tcObj = tcs[c]
+
+        // Clear any previous merge attributes
+        if (tcObj['@_hMerge']) delete tcObj['@_hMerge']
+        if (tcObj['@_vMerge']) delete tcObj['@_vMerge']
+        if (tcObj['@_gridSpan']) delete tcObj['@_gridSpan']
+        if (tcObj['@_rowSpan']) delete tcObj['@_rowSpan']
+
+        if (cellDef.vMerge) {
+          tcObj['@_vMerge'] = '1'
+          this.#setCellTextObj(tcObj, '')
+        } else {
+          let text = cellDef.value
+          let cellOpts = {}
+          if (cellDef.value && typeof cellDef.value === 'object') {
+            text = cellDef.value.value !== undefined ? cellDef.value.value : ''
+            cellOpts = cellDef.value
+          }
+          this.#setCellTextObj(tcObj, text)
+          if (cellDef.rowSpan && cellDef.rowSpan > 1 && strategy !== 'none') {
+            tcObj['@_rowSpan'] = String(cellDef.rowSpan)
+          }
+          this.#applyCellOptions(tcObj, cellOpts)
+        }
+      }
+      trs.push(newRow)
+    }
 
     slideManager.markSlideObjDirty(slideIndex)
   }
@@ -740,6 +793,68 @@ class TableManager {
     return { row, col }
   }
 
+  getCellBounds(slideIndex, tableId, rowIndex, colIndex, slideManager) {
+    const { tblObj, frameObj } = this.#getTableContext(slideIndex, tableId, slideManager)
+
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
+
+    const xfrm = frameObj['p:xfrm']
+    const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
+    const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
+
+    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
+    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
+    const colWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
+
+    const trsArr = tblObj['a:tr'] || []
+    const rowHeights = trsArr.map(row => parseInt(row['@_h'] || 0, 10))
+
+    const parent = this.getMergeParent(slideIndex, tableId, rowIndex, colIndex, slideManager)
+    const pr = parent.row
+    const pc = parent.col
+
+    let cellLeft = tableX
+    for (let idx = 0; idx < pc; idx++) {
+      cellLeft += colWidths[idx] || 0
+    }
+
+    let cellTop = tableY
+    for (let idx = 0; idx < pr; idx++) {
+      cellTop += rowHeights[idx] || 0
+    }
+
+    const parentCell = trsArr[pr]?.['a:tc']?.[pc]
+    const gridSpan = parentCell?.['@_gridSpan'] ? parseInt(parentCell['@_gridSpan'], 10) : 1
+    const rowSpan = parentCell?.['@_rowSpan'] ? parseInt(parentCell['@_rowSpan'], 10) : 1
+
+    let cellWidth = 0
+    for (let idx = 0; idx < gridSpan; idx++) {
+      cellWidth += colWidths[pc + idx] || 0
+    }
+
+    let cellHeight = 0
+    for (let idx = 0; idx < rowSpan; idx++) {
+      cellHeight += rowHeights[pr + idx] || 0
+    }
+
+    return {
+      x: Math.round(cellLeft / 9525),
+      y: Math.round(cellTop / 9525),
+      width: Math.round(cellWidth / 9525),
+      height: Math.round(cellHeight / 9525),
+    }
+  }
+
+  getCellPosition(slideIndex, tableId, rowIndex, colIndex, slideManager) {
+    const bounds = this.getCellBounds(slideIndex, tableId, rowIndex, colIndex, slideManager)
+    return {
+      row: rowIndex,
+      column: colIndex,
+      x: bounds.x,
+      y: bounds.y,
+    }
+  }
+
   /**
    * Splits a merged region containing cell (row, col).
    */
@@ -1152,45 +1267,226 @@ class TableManager {
   }
 
   #expandCellShape(config, cellBounds) {
-    const cellLeft_px = cellBounds.left / 9525
-    const cellTop_px = cellBounds.top / 9525
-    const cellWidth_px = cellBounds.width / 9525
-    const cellHeight_px = cellBounds.height / 9525
+    const cellLeft_px = Math.round(cellBounds.left / 9525)
+    const cellTop_px = Math.round(cellBounds.top / 9525)
+    const cellWidth_px = Math.round(cellBounds.width / 9525)
+    const cellHeight_px = Math.round(cellBounds.height / 9525)
+
+    const parseLength = (val, maxVal) => {
+      if (typeof val === 'string' && val.endsWith('%')) {
+        return (parseFloat(val) / 100) * maxVal
+      }
+      return val !== undefined ? parseFloat(val) : undefined
+    }
+
+    const isCellAnchored = config.anchor !== 'slide'
+
+    // 1. Determine bounding box width and height
+    let shapeWidth
+    let shapeHeight
 
+    if (config.type === 'progressBar') {
+      shapeHeight = parseLength(config.height !== undefined ? config.height : 8, cellHeight_px)
+      shapeWidth = parseLength(
+        config.width !== undefined ? config.width : cellWidth_px - 10,
+        cellWidth_px
+      )
+    } else if (config.type === 'badge') {
+      const text = String(config.text !== undefined ? config.text : '')
+      const fontSize = config.textStyle?.fontSize || 10
+      const textWidth = text.length * fontSize * 0.6
+      const paddingX = 12
+      shapeWidth =
+        parseLength(config.width, cellWidth_px) !== undefined
+          ? parseLength(config.width, cellWidth_px)
+          : textWidth + paddingX * 2
+      shapeHeight =
+        parseLength(config.height, cellHeight_px) !== undefined
+          ? parseLength(config.height, cellHeight_px)
+          : fontSize + 12
+    } else if (config.type === 'icon') {
+      const size = parseLength(
+        config.size !== undefined ? config.size : 16,
+        Math.min(cellWidth_px, cellHeight_px)
+      )
+      shapeWidth = size
+      shapeHeight = size
+    } else {
+      shapeWidth = parseLength(config.width, cellWidth_px)
+      if (shapeWidth === undefined) {
+        const sizeVal = parseLength(config.size, Math.min(cellWidth_px, cellHeight_px))
+        if (sizeVal !== undefined) {
+          shapeWidth = sizeVal
+        } else {
+          const radiusVal = parseLength(config.radius, Math.min(cellWidth_px, cellHeight_px) / 2)
+          if (radiusVal !== undefined) {
+            shapeWidth = radiusVal * 2
+          } else {
+            shapeWidth = 12 // default
+          }
+        }
+      }
+
+      shapeHeight = parseLength(config.height, cellHeight_px)
+      if (shapeHeight === undefined) {
+        const sizeVal = parseLength(config.size, Math.min(cellWidth_px, cellHeight_px))
+        if (sizeVal !== undefined) {
+          shapeHeight = sizeVal
+        } else {
+          const radiusVal = parseLength(config.radius, Math.min(cellWidth_px, cellHeight_px) / 2)
+          if (radiusVal !== undefined) {
+            shapeHeight = radiusVal * 2
+          } else {
+            shapeHeight = 12 // default
+          }
+        }
+      }
+    }
+
+    // 2. Determine alignment settings
+    let alignX = config.alignX
+    let alignY = config.alignY
+
+    if (config.position) {
+      switch (config.position) {
+        case 'top-left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'top'
+          break
+        case 'top-center':
+        case 'top':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'top'
+          break
+        case 'top-right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'top'
+          break
+        case 'middle-left':
+        case 'left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'center':
+        case 'middle-center':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'middle-right':
+        case 'right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'middle'
+          break
+        case 'bottom-left':
+          if (!alignX) alignX = 'left'
+          if (!alignY) alignY = 'bottom'
+          break
+        case 'bottom-center':
+        case 'bottom':
+          if (!alignX) alignX = 'center'
+          if (!alignY) alignY = 'bottom'
+          break
+        case 'bottom-right':
+          if (!alignX) alignX = 'right'
+          if (!alignY) alignY = 'bottom'
+          break
+      }
+    }
+
+    if (alignX && !alignY && config.y === undefined) {
+      alignY = 'middle'
+    }
+    if (alignY && !alignX && config.x === undefined) {
+      alignX = 'center'
+    }
+
+    if (!alignX && !alignY && config.x === undefined && config.y === undefined) {
+      alignX = 'center'
+      alignY = 'middle'
+    }
+
+    // 3. Compute coordinates
+    let shapeLeft = cellLeft_px
+    let shapeTop = cellTop_px
+
+    if (isCellAnchored) {
+      if (alignX === 'left') {
+        shapeLeft = cellLeft_px + (config.x !== undefined ? config.x : 5)
+      } else if (alignX === 'center') {
+        shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2 + (config.x || 0)
+      } else if (alignX === 'right') {
+        shapeLeft =
+          cellLeft_px + cellWidth_px - shapeWidth - (config.x !== undefined ? config.x : 5)
+      } else {
+        shapeLeft =
+          cellLeft_px + (config.x !== undefined ? config.x : (cellWidth_px - shapeWidth) / 2)
+      }
+
+      if (alignY === 'top') {
+        shapeTop = cellTop_px + (config.y !== undefined ? config.y : 5)
+      } else if (alignY === 'middle') {
+        shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2 + (config.y || 0)
+      } else if (alignY === 'bottom') {
+        shapeTop =
+          cellTop_px + cellHeight_px - shapeHeight - (config.y !== undefined ? config.y : 5)
+      } else {
+        shapeTop =
+          cellTop_px + (config.y !== undefined ? config.y : (cellHeight_px - shapeHeight) / 2)
+      }
+
+      // 4. Boundary Constraints Validation/Enforcement
+      if (shapeWidth > cellWidth_px) {
+        shapeLeft = cellLeft_px
+      } else {
+        shapeLeft = Math.max(
+          cellLeft_px,
+          Math.min(shapeLeft, cellLeft_px + cellWidth_px - shapeWidth)
+        )
+      }
+
+      if (shapeHeight > cellHeight_px) {
+        shapeTop = cellTop_px
+      } else {
+        shapeTop = Math.max(
+          cellTop_px,
+          Math.min(shapeTop, cellTop_px + cellHeight_px - shapeHeight)
+        )
+      }
+    } else {
+      shapeLeft = config.x || 0
+      shapeTop = config.y || 0
+    }
+
+    // 5. Expand individual sub-elements / custom shapes
     if (config.type === 'progressBar') {
       const value = config.value !== undefined ? config.value : 0
       const max = config.max !== undefined ? config.max : 100
       const fill = config.fill || '#3B82F6'
       const bgFill = config.backgroundFill || '#E5E7EB'
-      const pbHeight = config.height !== undefined ? config.height : 8
-      const pbWidth = config.width !== undefined ? config.width : cellWidth_px - 10
-
-      const pbX = cellLeft_px + (config.x !== undefined ? config.x : (cellWidth_px - pbWidth) / 2)
-      const pbY = cellTop_px + (config.y !== undefined ? config.y : (cellHeight_px - pbHeight) / 2)
 
       const shapes = []
       shapes.push({
         type: 'roundedRectangle',
         fill: bgFill,
-        x: pbX,
-        y: pbY,
-        width: pbWidth,
-        height: pbHeight,
-        borderRadius: pbHeight / 2,
+        x: shapeLeft,
+        y: shapeTop,
+        width: shapeWidth,
+        height: shapeHeight,
+        borderRadius: shapeHeight / 2,
         zIndex: config.zIndex,
       })
 
       const pct = Math.min(1, Math.max(0, value / max))
       if (pct > 0) {
-        const filledWidth = pbWidth * pct
+        const filledWidth = shapeWidth * pct
         shapes.push({
           type: 'roundedRectangle',
           fill: fill,
-          x: pbX,
-          y: pbY,
+          x: shapeLeft,
+          y: shapeTop,
           width: filledWidth,
-          height: pbHeight,
-          borderRadius: pbHeight / 2,
+          height: shapeHeight,
+          borderRadius: shapeHeight / 2,
           zIndex: (config.zIndex || 0) + 1,
         })
       }
@@ -1200,23 +1496,15 @@ class TableManager {
     if (config.type === 'badge') {
       const text = String(config.text !== undefined ? config.text : '')
       const fontSize = config.textStyle?.fontSize || 10
-      const textWidth = text.length * fontSize * 0.6
-      const paddingX = 12
-      const badgeWidth = config.width !== undefined ? config.width : textWidth + paddingX * 2
-      const badgeHeight = config.height !== undefined ? config.height : fontSize + 12
-
-      const x = cellLeft_px + (config.x !== undefined ? config.x : (cellWidth_px - badgeWidth) / 2)
-      const y = cellTop_px + (config.y !== undefined ? config.y : (cellHeight_px - badgeHeight) / 2)
-
       return [
         {
           type: 'roundedRectangle',
           fill: config.fill || '#10B981',
-          borderRadius: badgeHeight / 2,
-          x: x,
-          y: y,
-          width: badgeWidth,
-          height: badgeHeight,
+          borderRadius: shapeHeight / 2,
+          x: shapeLeft,
+          y: shapeTop,
+          width: shapeWidth,
+          height: shapeHeight,
           text: text,
           textStyle: {
             color: config.textStyle?.color || '#FFFFFF',
@@ -1234,9 +1522,8 @@ class TableManager {
     }
 
     if (config.type === 'icon') {
-      const size = config.size || 16
       const iconFill = config.fill
-      const fontSize = Math.round(size * 0.8)
+      const fontSize = Math.round(shapeWidth * 0.8)
 
       let baseConfig = null
       switch (config.icon) {
@@ -1245,8 +1532,8 @@ class TableManager {
             type: 'rectangle',
             fill: 'none',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
             text: '✔',
             textStyle: {
               color: iconFill || '#10B981',
@@ -1261,8 +1548,8 @@ class TableManager {
             type: 'rectangle',
             fill: 'none',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
             text: '✘',
             textStyle: {
               color: iconFill || '#EF4444',
@@ -1277,8 +1564,8 @@ class TableManager {
             type: 'triangle',
             fill: iconFill || '#F59E0B',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
             text: '!',
             textStyle: {
               color: '#FFFFFF',
@@ -1293,7 +1580,7 @@ class TableManager {
             type: 'circle',
             fill: iconFill || '#3B82F6',
             border: null,
-            radius: size / 2,
+            radius: shapeWidth / 2,
             text: 'i',
             textStyle: {
               color: '#FFFFFF',
@@ -1308,8 +1595,8 @@ class TableManager {
             type: 'star5',
             fill: iconFill || '#FBBF24',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
           }
           break
         case 'up':
@@ -1317,8 +1604,8 @@ class TableManager {
             type: 'upArrow',
             fill: iconFill || '#10B981',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
           }
           break
         case 'down':
@@ -1326,8 +1613,8 @@ class TableManager {
             type: 'downArrow',
             fill: iconFill || '#EF4444',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
           }
           break
         case 'arrow-right':
@@ -1335,8 +1622,8 @@ class TableManager {
             type: 'rightArrow',
             fill: iconFill || '#3B82F6',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
           }
           break
         case 'arrow-left':
@@ -1344,19 +1631,16 @@ class TableManager {
             type: 'leftArrow',
             fill: iconFill || '#3B82F6',
             border: null,
-            width: size,
-            height: size,
+            width: shapeWidth,
+            height: shapeHeight,
           }
           break
         default:
           return []
       }
 
-      const x = cellLeft_px + (config.x !== undefined ? config.x : (cellWidth_px - size) / 2)
-      const y = cellTop_px + (config.y !== undefined ? config.y : (cellHeight_px - size) / 2)
-
-      baseConfig.x = x
-      baseConfig.y = y
+      baseConfig.x = shapeLeft
+      baseConfig.y = shapeTop
       baseConfig.zIndex = config.zIndex
       if (config.border) baseConfig.border = config.border
       if (config.transparency !== undefined) baseConfig.transparency = config.transparency
@@ -1366,58 +1650,11 @@ class TableManager {
       return [baseConfig]
     }
 
-    const shapeWidth =
-      config.width !== undefined
-        ? config.width
-        : config.size !== undefined
-          ? config.size
-          : config.radius !== undefined
-            ? config.radius * 2
-            : 12
-    const shapeHeight =
-      config.height !== undefined
-        ? config.height
-        : config.size !== undefined
-          ? config.size
-          : config.radius !== undefined
-            ? config.radius * 2
-            : 12
-
-    let shapeLeft = cellLeft_px
-    let shapeTop = cellTop_px
-
-    if (config.position === 'center') {
-      shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2
-      shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2
-    } else if (config.position === 'left') {
-      shapeLeft = cellLeft_px + 5
-      shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2
-    } else if (config.position === 'right') {
-      shapeLeft = cellLeft_px + cellWidth_px - shapeWidth - 5
-      shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2
-    } else if (config.position === 'top') {
-      shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2
-      shapeTop = cellTop_px + 5
-    } else if (config.position === 'bottom') {
-      shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2
-      shapeTop = cellTop_px + cellHeight_px - shapeHeight - 5
-    } else {
-      if (config.x === undefined && config.y === undefined) {
-        shapeLeft = cellLeft_px + (cellWidth_px - shapeWidth) / 2
-        shapeTop = cellTop_px + (cellHeight_px - shapeHeight) / 2
-      }
-    }
-
-    if (config.x !== undefined) {
-      shapeLeft += config.x
-    }
-    if (config.y !== undefined) {
-      shapeTop += config.y
-    }
-
     const expanded = Object.assign({}, config, {
       x: shapeLeft,
       y: shapeTop,
+      width: shapeWidth,
+      height: shapeHeight,
     })
 
     if (expanded.type === 'circle' && expanded.radius === undefined) {
@@ -1458,6 +1695,8 @@ class TableManager {
       }
     }
 
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
+
     const xfrm = frameObj['p:xfrm']
     const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
     const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
@@ -1561,6 +1800,69 @@ class TableManager {
     })
   }
 
+  getTableRows(slideIndex, tableId, options = {}, slideManager) {
+    const { tblObj } = this.#getTableContext(slideIndex, tableId, slideManager)
+    const trs = tblObj['a:tr'] || []
+    if (trs.length === 0) {
+      return options.includeMetadata
+        ? { rows: [], rowCount: 0, columnCount: 0, mergedCells: [] }
+        : []
+    }
+
+    const numRows = trs.length
+    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
+    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
+    const numCols = gridColsArr.length
+
+    // Extract all raw cell text, resolving merges to their parent's text
+    const matrix = []
+    for (let r = 0; r < numRows; r++) {
+      const rowCells = []
+      for (let c = 0; c < numCols; c++) {
+        const parent = this.getMergeParent(slideIndex, tableId, r, c, slideManager)
+        const cell = trs[parent.row]?.['a:tc']?.[parent.col]
+        const text = cell ? this.#getCellText(cell) : ''
+        rowCells.push(text)
+      }
+      matrix.push(rowCells)
+    }
+
+    // Header names are extracted from the first row (index 0)
+    const headerNames = matrix[0].map((hText, cIdx) => {
+      const cleaned = hText.trim()
+      return cleaned || `column${cIdx + 1}`
+    })
+
+    // Compute the data rows (excluding the header row at index 0)
+    const dataRows = matrix.slice(1)
+
+    let rowsResult = []
+    if (options.raw) {
+      rowsResult = dataRows
+    } else {
+      for (const rowCells of dataRows) {
+        const rowObj = {}
+        for (let c = 0; c < numCols; c++) {
+          const key = headerNames[c]
+          rowObj[key] = rowCells[c] || ''
+        }
+        rowsResult.push(rowObj)
+      }
+    }
+
+    if (options.includeMetadata) {
+      const mergedCells = this.getMergedCells(slideIndex, tableId, slideManager)
+      return {
+        rows: rowsResult,
+        rowCount: numRows,
+        columnCount: numCols,
+        mergedCells,
+      }
+    }
+
+    return rowsResult
+  }
+
   addCellShape(slideIndex, tableId, rowIndex, colIndex, options, slideManager, shapeManager) {
     const { tblObj, frameObj, resolvedTableId } = this.#getTableContext(
       slideIndex,
@@ -1568,6 +1870,8 @@ class TableManager {
       slideManager
     )
 
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
+
     const xfrm = frameObj['p:xfrm']
     const tableX = xfrm?.['a:off']?.['@_x'] ? parseInt(xfrm['a:off']['@_x'], 10) : 0
     const tableY = xfrm?.['a:off']?.['@_y'] ? parseInt(xfrm['a:off']['@_y'], 10) : 0
@@ -1651,6 +1955,8 @@ class TableManager {
       slideManager
     )
 
+    this.#calculateRowHeights(slideIndex, tableId, slideManager, tblObj)
+
     const shapes = shapeManager.getShapes(slideIndex, slideManager)
     const prefix = `cellshape_${resolvedTableId}_${rowIndex}_${colIndex}_${shapeIndex}`
     const matchingShapes = shapes.filter(
@@ -1786,6 +2092,297 @@ class TableManager {
     }
   }
 
+  #calculateRowHeights(slideIndex, tableId, slideManager, tblObj) {
+    const trsArr = tblObj['a:tr'] || []
+    if (trsArr.length === 0) return []
+
+    const gridCols = tblObj['a:tblGrid']?.['a:gridCol'] || []
+    const gridColsArr = Array.isArray(gridCols) ? gridCols : [gridCols]
+    const colWidths = gridColsArr.map(col => parseInt(col['@_w'] || 0, 10))
+
+    const numRows = trsArr.length
+    const numCols = colWidths.length
+
+    // Initialize rowHeights with original height or 0
+    const rowHeights = trsArr.map(row => parseInt(row['@_h'] || 0, 10))
+
+    // Helper to get paragraph font size
+    const getParagraphFontSize = p => {
+      let maxSz = 14 // default 14pt
+      if (p['a:pPr']?.['a:defRPr']?.['@_sz']) {
+        maxSz = parseInt(p['a:pPr']['a:defRPr']['@_sz'], 10) / 100
+      }
+      if (p['a:r']) {
+        const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
+        for (const r of runs) {
+          if (r['a:rPr']?.['@_sz']) {
+            const szVal = parseInt(r['a:rPr']['@_sz'], 10) / 100
+            if (szVal > maxSz) {
+              maxSz = szVal
+            }
+          }
+        }
+      }
+      return maxSz
+    }
+
+    // Helper to wrap text
+    const wrapText = (text, availWidth_px, fontSize) => {
+      const charWidth = fontSize * 0.65
+      const words = text.split(/(\s+)/)
+      let linesCount = 0
+      let currentLineLen = 0
+
+      for (const word of words) {
+        if (!word) continue
+        const wordWidth = word.length * charWidth
+        if (wordWidth > availWidth_px) {
+          if (currentLineLen > 0) {
+            linesCount++
+            currentLineLen = 0
+          }
+          let remainingWidth = wordWidth
+          while (remainingWidth > 0) {
+            linesCount++
+            remainingWidth -= availWidth_px
+          }
+        } else {
+          if (currentLineLen + wordWidth > availWidth_px) {
+            linesCount++
+            currentLineLen = word.trim() ? wordWidth : 0
+          } else {
+            currentLineLen += wordWidth
+          }
+        }
+      }
+      if (currentLineLen > 0 || linesCount === 0) {
+        linesCount++
+      }
+      return linesCount
+    }
+
+    // Helper to get cell margins
+    const getCellMargins = cell => {
+      const tcPr = cell['a:tcPr']
+      const marL = tcPr?.['@_marL'] !== undefined ? parseInt(tcPr['@_marL'], 10) : 91440
+      const marR = tcPr?.['@_marR'] !== undefined ? parseInt(tcPr['@_marR'], 10) : 91440
+      const marT = tcPr?.['@_marT'] !== undefined ? parseInt(tcPr['@_marT'], 10) : 45720
+      const marB = tcPr?.['@_marB'] !== undefined ? parseInt(tcPr['@_marB'], 10) : 45720
+      return { marL, marR, marT, marB }
+    }
+
+    // Calculate required height for each cell
+    const cellHeights = Array.from({ length: numRows }, () => new Array(numCols).fill(0))
+
+    for (let r = 0; r < numRows; r++) {
+      const row = trsArr[r]
+      const tcs = row['a:tc'] || []
+      for (let c = 0; c < numCols; c++) {
+        const cell = tcs[c]
+        if (!cell || cell['@_hMerge'] || cell['@_vMerge']) continue
+
+        const parent = this.getMergeParent(slideIndex, tableId, r, c, slideManager)
+        const gridSpan = cell['@_gridSpan'] ? parseInt(cell['@_gridSpan'], 10) : 1
+
+        // Calculate cell width
+        let cellWidth = 0
+        for (let idx = 0; idx < gridSpan; idx++) {
+          cellWidth += colWidths[parent.col + idx] || 0
+        }
+
+        const { marL, marR, marT, marB } = getCellMargins(cell)
+        const availWidth = cellWidth - marL - marR
+        const availWidth_px = Math.max(1, availWidth / 9525)
+
+        // Calculate text height
+        const txBody = cell['a:txBody']
+        let textHeight_emu = 0
+        if (txBody) {
+          const paras = Array.isArray(txBody['a:p']) ? txBody['a:p'] : [txBody['a:p']]
+          for (const p of paras) {
+            const fontSize = getParagraphFontSize(p)
+            let pText = ''
+            if (p['a:r']) {
+              const runs = Array.isArray(p['a:r']) ? p['a:r'] : [p['a:r']]
+              for (const r of runs) {
+                if (r['a:t']) {
+                  pText += String(r['a:t'])
+                }
+              }
+            }
+
+            const linesCount = wrapText(pText, availWidth_px, fontSize)
+            const lineHeight_emu = fontSize * 20780 // 1.4 line height multiplier
+
+            let pHeight_emu = linesCount * lineHeight_emu
+            if (p['a:pPr']?.['a:spcBef']?.['a:spcPts']?.['@_val']) {
+              pHeight_emu += parseInt(p['a:pPr']['a:spcBef']['a:spcPts']['@_val'], 10) * 127
+            }
+            if (p['a:pPr']?.['a:spcAft']?.['a:spcPts']?.['@_val']) {
+              pHeight_emu += parseInt(p['a:pPr']['a:spcAft']['a:spcPts']['@_val'], 10) * 127
+            }
+            textHeight_emu += pHeight_emu
+          }
+        }
+
+        const totalCellHeight_emu = marT + marB + textHeight_emu
+        cellHeights[r][c] = totalCellHeight_emu
+      }
+    }
+
+    // Now resolve row heights based on required cell heights
+    // First, non-vertically-merged cells define row heights directly
+    for (let r = 0; r < numRows; r++) {
+      let maxCellHeight = rowHeights[r] // Start with original template height as floor
+      const row = trsArr[r]
+      const tcs = row['a:tc'] || []
+      for (let c = 0; c < numCols; c++) {
+        const cell = tcs[c]
+        if (!cell || cell['@_vMerge'] || cell['@_hMerge']) continue
+        const rowSpan = cell['@_rowSpan'] ? parseInt(cell['@_rowSpan'], 10) : 1
+        if (rowSpan === 1) {
+          if (cellHeights[r][c] > maxCellHeight) {
+            maxCellHeight = cellHeights[r][c]
+          }
+        }
+      }
+      rowHeights[r] = maxCellHeight
+    }
+
+    // Next, adjust for vertically merged cells (rowSpan > 1)
+    for (let r = 0; r < numRows; r++) {
+      const row = trsArr[r]
+      const tcs = row['a:tc'] || []
+      for (let c = 0; c < numCols; c++) {
+        const cell = tcs[c]
+        if (!cell || cell['@_vMerge'] || cell['@_hMerge']) continue
+        const rowSpan = cell['@_rowSpan'] ? parseInt(cell['@_rowSpan'], 10) : 1
+        if (rowSpan > 1) {
+          const reqHeight = cellHeights[r][c]
+          // Sum currently allocated row heights for spanned rows
+          let currentSpanHeight = 0
+          for (let idx = 0; idx < rowSpan; idx++) {
+            currentSpanHeight += rowHeights[r + idx] || 0
+          }
+          if (reqHeight > currentSpanHeight) {
+            // Distribute the extra required height equally across all spanned rows
+            const diff = reqHeight - currentSpanHeight
+            const extraPerRow = Math.ceil(diff / rowSpan)
+            for (let idx = 0; idx < rowSpan; idx++) {
+              rowHeights[r + idx] += extraPerRow
+            }
+          }
+        }
+      }
+    }
+
+    // Update row heights in XML
+    for (let r = 0; r < numRows; r++) {
+      trsArr[r]['@_h'] = String(rowHeights[r])
+    }
+
+    return rowHeights
+  }
+
+  #getNestedHeight(val) {
+    if (Array.isArray(val)) {
+      if (val.length === 0) return 1
+      return val.reduce((sum, item) => sum + this.#getNestedHeight(item), 0)
+    }
+    return 1
+  }
+
+  #expandCellVal(val, targetHeight) {
+    if (!Array.isArray(val)) {
+      const res = []
+      res.push({ value: val !== undefined ? val : '', rowSpan: targetHeight })
+      for (let i = 1; i < targetHeight; i++) {
+        res.push({ vMerge: true })
+      }
+      return res
+    }
+
+    if (val.length === 0) {
+      const res = []
+      res.push({ value: '', rowSpan: targetHeight })
+      for (let i = 1; i < targetHeight; i++) {
+        res.push({ vMerge: true })
+      }
+      return res
+    }
+
+    const itemHeights = val.map(item => this.#getNestedHeight(item))
+    const currentSum = itemHeights.reduce((a, b) => a + b, 0)
+
+    const allocatedHeights = []
+    let remaining = targetHeight
+    for (let i = 0; i < val.length; i++) {
+      const share = Math.round((itemHeights[i] / currentSum) * targetHeight)
+      allocatedHeights.push(share)
+      remaining -= share
+    }
+
+    if (remaining !== 0) {
+      let idx = 0
+      while (remaining > 0) {
+        allocatedHeights[idx % allocatedHeights.length]++
+        remaining--
+        idx++
+      }
+      while (remaining < 0) {
+        let reduced = false
+        for (let i = 0; i < allocatedHeights.length; i++) {
+          const actualIdx = (idx + i) % allocatedHeights.length
+          if (allocatedHeights[actualIdx] > 1) {
+            allocatedHeights[actualIdx]--
+            remaining++
+            reduced = true
+            break
+          }
+        }
+        if (!reduced) break
+        idx++
+      }
+    }
+
+    const result = []
+    for (let i = 0; i < val.length; i++) {
+      result.push(...this.#expandCellVal(val[i], allocatedHeights[i]))
+    }
+    return result
+  }
+
+  #applyAutoMerge(cells) {
+    const result = [...cells]
+    let i = 0
+    while (i < result.length) {
+      const cell = result[i]
+      if (cell.vMerge) {
+        i++
+        continue
+      }
+      let count = 1
+      let j = i + 1
+      while (
+        j < result.length &&
+        !result[j].vMerge &&
+        result[j].value === cell.value &&
+        cell.value !== ''
+      ) {
+        count++
+        j++
+      }
+      if (count > 1) {
+        cell.rowSpan = count
+        for (let k = i + 1; k < j; k++) {
+          result[k] = { vMerge: true }
+        }
+      }
+      i = j
+    }
+    return result
+  }
+
   #generateRandomUint32() {
     return Math.floor(Math.random() * 4294967296)
   }