@node-projects/excelforge 2.3.0 → 3.0.0

package/dist/core/WorkbookReader.js

@@ -1,18 +1,23 @@
 import { readZip, entryText } from '../utils/zipReader.js';
-import { parseXml, child, children, localName, nodeToXml } from '../utils/xmlParser.js';
+import { parseXml, child, children, attr, localName, nodeToXml } from '../utils/xmlParser.js';
 import { parseCoreXml, parseAppXml, parseCustomXml, } from './properties.js';
+import { CellError, } from './types.js';
 import { Worksheet } from './Worksheet.js';
 import { cellRefToIndices } from '../utils/helpers.js';
+import { OBJ_TYPE_TO_CTRL, CHECKED_REV } from '../features/FormControlBuilder.js';
 function parseRels(xml) {
     const map = new Map();
     try {
         const root = parseXml(xml);
         for (const c of root.children) {
             if (localName(c.tag) === 'Relationship') {
-                map.set(c.attrs['Id'] ?? '', {
+                const entry = {
                     type: c.attrs['Type'] ?? '',
                     target: c.attrs['Target'] ?? '',
-                });
+                };
+                if (c.attrs['TargetMode'])
+                    entry.targetMode = c.attrs['TargetMode'];
+                map.set(c.attrs['Id'] ?? '', entry);
             }
         }
     }
@@ -119,7 +124,33 @@ function parseStyles(xml) {
             xfs.push(style);
         }
     }
-    return { xfs, numFmts };
+    const dxfs = [];
+    const dxfsNode = find(root, 'dxfs');
+    if (dxfsNode) {
+        for (const dxf of children(dxfsNode, 'dxf')) {
+            const style = {};
+            const fontNode = child(dxf, 'font');
+            if (fontNode)
+                style.font = parseFont(fontNode);
+            const fillNode = child(dxf, 'fill');
+            if (fillNode)
+                style.fill = parseFill(fillNode);
+            const borderNode = child(dxf, 'border');
+            if (borderNode)
+                style.border = parseBorder(borderNode);
+            const numFmtDxf = child(dxf, 'numFmt');
+            if (numFmtDxf) {
+                const code = numFmtDxf.attrs['formatCode'] ?? '';
+                if (code)
+                    style.numberFormat = { formatCode: code };
+            }
+            const alignDxf = child(dxf, 'alignment');
+            if (alignDxf)
+                style.alignment = parseAlignment(alignDxf);
+            dxfs.push(style);
+        }
+    }
+    return { xfs, numFmts, dxfs };
 }
 function find(node, localTag) {
     if (localName(node.tag) === localTag)
@@ -166,9 +197,12 @@ function parseFont(node) {
                 f.vertAlign = c.attrs['val'];
                 break;
             case 'color': {
-                const rgb = c.attrs['rgb'] ?? c.attrs['theme'];
+                const rgb = c.attrs['rgb'];
+                const theme = c.attrs['theme'];
                 if (rgb)
                     f.color = rgb;
+                else if (theme)
+                    f.color = `theme:${theme}`;
                 break;
             }
         }
@@ -183,8 +217,8 @@ function parseFill(node) {
         return {
             type: 'pattern',
             pattern: (pattern.attrs['patternType'] ?? 'none'),
-            fgColor: fg?.attrs['rgb'] ?? fg?.attrs['theme'],
-            bgColor: bg?.attrs['rgb'] ?? bg?.attrs['theme'],
+            fgColor: fg?.attrs['rgb'] ?? (fg?.attrs['theme'] ? `theme:${fg.attrs['theme']}` : undefined),
+            bgColor: bg?.attrs['rgb'] ?? (bg?.attrs['theme'] ? `theme:${bg.attrs['theme']}` : undefined),
         };
     }
     const gradient = child(node, 'gradientFill');
@@ -193,7 +227,7 @@ function parseFill(node) {
             const colorNode = child(s, 'color');
             return {
                 position: parseFloat(s.attrs['position'] ?? '0'),
-                color: colorNode?.attrs['rgb'] ?? colorNode?.attrs['theme'] ?? 'FF000000',
+                color: colorNode?.attrs['rgb'] ?? (colorNode?.attrs['theme'] ? `theme:${colorNode.attrs['theme']}` : 'FF000000'),
             };
         });
         return {
@@ -214,7 +248,8 @@ function parseBorder(node) {
         const color = child(n, 'color');
         if (!style && !color)
             return undefined;
-        return { style: style, color: color?.attrs['rgb'] };
+        const colorVal = color?.attrs['rgb'] ?? (color?.attrs['theme'] ? `theme:${color.attrs['theme']}` : undefined);
+        return { style: style, color: colorVal };
     };
     return {
         left: parseSide('left'),
@@ -248,9 +283,22 @@ function parseSharedStrings(xml) {
     const root = parseXml(xml);
     return children(root, 'si').map(si => {
         const t = child(si, 't');
-        if (t && !child(si, 'r'))
-            return t.text ?? '';
-        return children(si, 'r').map(r => child(r, 't')?.text ?? '').join('');
+        const runs = children(si, 'r');
+        if (t && !runs.length)
+            return { text: t.text ?? '' };
+        const richRuns = runs.map(r => {
+            const runText = child(r, 't')?.text ?? '';
+            const rPr = child(r, 'rPr');
+            const run = { text: runText };
+            if (rPr)
+                run.font = parseFont(rPr);
+            return run;
+        });
+        const plainText = richRuns.map(r => r.text).join('');
+        const hasFormatting = richRuns.some(r => r.font && Object.keys(r.font).length > 0);
+        if (hasFormatting)
+            return { text: plainText, richText: richRuns };
+        return { text: plainText };
     });
 }
 function parseWorksheet(xml, name, styles, sharedStrings) {
@@ -258,12 +306,17 @@ function parseWorksheet(xml, name, styles, sharedStrings) {
     const root = parseXml(xml);
     const unknownParts = [];
     const tableRIds = [];
+    let legacyDrawingRId = '';
+    let drawingRId = '';
+    const ctrlPropRIds = [];
+    const vmCells = new Map();
     const knownTags = new Set([
         'sheetPr', 'dimension', 'sheetViews', 'sheetFormatPr', 'cols',
         'sheetData', 'mergeCells', 'conditionalFormatting', 'dataValidations',
         'sheetProtection', 'printOptions', 'pageMargins', 'pageSetup',
         'headerFooter', 'drawing', 'tableParts', 'autoFilter',
         'rowBreaks', 'colBreaks', 'picture', 'oleObjects', 'ctrlProps',
+        'legacyDrawing', 'AlternateContent', 'extLst',
     ]);
     for (const node of root.children) {
         const tag = localName(node.tag);
@@ -275,7 +328,7 @@ function parseWorksheet(xml, name, styles, sharedStrings) {
                 parseCols(node, ws, styles);
                 break;
             case 'sheetData':
-                parseSheetData(node, ws, styles, sharedStrings);
+                parseSheetData(node, ws, styles, sharedStrings, vmCells);
                 break;
             case 'mergeCells':
                 parseMerges(node, ws);
@@ -305,6 +358,60 @@ function parseWorksheet(xml, name, styles, sharedStrings) {
             case 'printOptions':
                 parsePrintOptions(node, ws);
                 break;
+            case 'conditionalFormatting':
+                parseConditionalFormatting(node, ws, styles);
+                break;
+            case 'dataValidations':
+                parseDataValidations(node, ws);
+                break;
+            case 'rowBreaks':
+                for (const brk of children(node, 'brk')) {
+                    const id = parseInt(brk.attrs['id'] ?? '0', 10);
+                    if (id > 0)
+                        ws.addRowBreak(id, brk.attrs['man'] === '1');
+                }
+                break;
+            case 'colBreaks':
+                for (const brk of children(node, 'brk')) {
+                    const id = parseInt(brk.attrs['id'] ?? '0', 10);
+                    if (id > 0)
+                        ws.addColBreak(id, brk.attrs['man'] === '1');
+                }
+                break;
+            case 'drawing':
+                drawingRId = node.attrs['r:id'] ?? '';
+                break;
+            case 'legacyDrawing':
+                legacyDrawingRId = node.attrs['r:id'] ?? '';
+                break;
+            case 'AlternateContent': {
+                const choiceNode = node.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'Choice');
+                const controlsNode = choiceNode ? choiceNode.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'controls') : undefined;
+                if (controlsNode) {
+                    for (const acNode of controlsNode.children) {
+                        if (typeof acNode === 'string')
+                            continue;
+                        let ctrlNode;
+                        if (localName(acNode.tag) === 'control') {
+                            ctrlNode = acNode;
+                        }
+                        else if (localName(acNode.tag) === 'AlternateContent') {
+                            const innerChoice = acNode.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'Choice');
+                            ctrlNode = innerChoice?.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'control');
+                        }
+                        if (!ctrlNode)
+                            continue;
+                        const controlPr = ctrlNode.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'controlPr');
+                        const ctrlRId = ctrlNode.attrs['r:id'] ?? controlPr?.attrs['r:id'] ?? '';
+                        if (ctrlRId)
+                            ctrlPropRIds.push(ctrlRId);
+                    }
+                }
+                break;
+            }
+            case 'extLst':
+                parseSparklineExtensions(node, ws);
+                break;
             default:
                 if (!knownTags.has(tag)) {
                     unknownParts.push(nodeToXml(node));
@@ -312,7 +419,7 @@ function parseWorksheet(xml, name, styles, sharedStrings) {
                 break;
         }
     }
-    return { ws, originalXml: xml, unknownParts, tableRIds };
+    return { ws, originalXml: xml, unknownParts, tableRIds, legacyDrawingRId, ctrlPropRIds, drawingRId, vmCells };
 }
 function parseSheetViews(node, ws) {
     const sv = children(node, 'sheetView')[0];
@@ -349,7 +456,7 @@ function parseCols(node, ws, styles) {
             ws.setColumn(c, def);
     }
 }
-function parseSheetData(node, ws, styles, sharedStrings) {
+function parseSheetData(node, ws, styles, sharedStrings, vmCells) {
     for (const rowNode of children(node, 'row')) {
         const rowIdx = parseInt(rowNode.attrs['r'] ?? '0', 10);
         if (!rowIdx)
@@ -380,6 +487,10 @@ function parseSheetData(node, ws, styles, sharedStrings) {
             const cell = {};
             if (cellStyle)
                 cell.style = cellStyle;
+            const vmAttr = cNode.attrs['vm'];
+            if (vmAttr && vmCells) {
+                vmCells.set(ref, parseInt(vmAttr, 10));
+            }
             if (fNode) {
                 if (fNode.attrs['t'] === 'array') {
                     cell.arrayFormula = fNode.text ?? '';
@@ -393,7 +504,15 @@ function parseSheetData(node, ws, styles, sharedStrings) {
                 switch (t) {
                     case 's': {
                         const idx = parseInt(raw, 10);
-                        cell.value = sharedStrings[idx] ?? '';
+                        const ss = sharedStrings[idx];
+                        if (ss) {
+                            cell.value = ss.text;
+                            if (ss.richText)
+                                cell.richText = ss.richText;
+                        }
+                        else {
+                            cell.value = '';
+                        }
                         break;
                     }
                     case 'b':
@@ -406,7 +525,7 @@ function parseSheetData(node, ws, styles, sharedStrings) {
                         break;
                     }
                     case 'e':
-                        cell.value = raw;
+                        cell.value = new CellError(raw);
                         break;
                     default: {
                         const n = parseFloat(raw);
@@ -490,6 +609,115 @@ function parsePrintOptions(node, ws) {
         centerVertical: node.attrs['verticalCentered'] === '1',
     };
 }
+function parseConditionalFormatting(node, ws, styles) {
+    const sqref = node.attrs['sqref'] ?? '';
+    for (const rule of children(node, 'cfRule')) {
+        const type = (rule.attrs['type'] ?? 'cellIs');
+        const cf = { sqref, type };
+        if (rule.attrs['operator'])
+            cf.operator = rule.attrs['operator'];
+        if (rule.attrs['priority'])
+            cf.priority = parseInt(rule.attrs['priority'], 10);
+        if (rule.attrs['text'])
+            cf.text = rule.attrs['text'];
+        if (rule.attrs['aboveAverage'] === '0')
+            cf.aboveAverage = false;
+        if (rule.attrs['percent'] === '1')
+            cf.percent = true;
+        if (rule.attrs['rank'])
+            cf.rank = parseInt(rule.attrs['rank'], 10);
+        if (rule.attrs['timePeriod'])
+            cf.timePeriod = rule.attrs['timePeriod'];
+        if (rule.attrs['dxfId'] !== undefined) {
+            const dxfId = parseInt(rule.attrs['dxfId'], 10);
+            if (styles.dxfs[dxfId])
+                cf.style = styles.dxfs[dxfId];
+        }
+        const formulas = children(rule, 'formula');
+        if (formulas[0]?.text)
+            cf.formula = formulas[0].text;
+        if (formulas[1]?.text)
+            cf.formula2 = formulas[1].text;
+        const csNode = child(rule, 'colorScale');
+        if (csNode) {
+            const cfvos = children(csNode, 'cfvo').map(c => ({
+                type: (c.attrs['type'] ?? 'min'),
+                val: c.attrs['val'],
+            }));
+            const colors = children(csNode, 'color').map(c => c.attrs['rgb'] ?? c.attrs['theme'] ?? '');
+            cf.colorScale = { type: 'colorScale', cfvo: cfvos, color: colors };
+        }
+        const dbNode = child(rule, 'dataBar');
+        if (dbNode) {
+            const cfvos = children(dbNode, 'cfvo');
+            const colorNode = child(dbNode, 'color');
+            cf.dataBar = {
+                type: 'dataBar',
+                showValue: dbNode.attrs['showValue'] !== '0' ? undefined : false,
+                minType: cfvos[0]?.attrs['type'],
+                minVal: cfvos[0]?.attrs['val'],
+                maxType: cfvos[1]?.attrs['type'],
+                maxVal: cfvos[1]?.attrs['val'],
+                color: colorNode?.attrs['rgb'],
+            };
+        }
+        const isNode = child(rule, 'iconSet');
+        if (isNode) {
+            const cfvos = children(isNode, 'cfvo').map(c => ({
+                type: c.attrs['type'] ?? 'percent',
+                val: c.attrs['val'],
+            }));
+            cf.iconSet = {
+                type: 'iconSet',
+                iconSet: (isNode.attrs['iconSet'] ?? '3TrafficLights1'),
+                cfvo: cfvos,
+                showValue: isNode.attrs['showValue'] === '0' ? false : undefined,
+                reverse: isNode.attrs['reverse'] === '1' ? true : undefined,
+            };
+        }
+        ws.addConditionalFormat(cf);
+    }
+}
+function parseDataValidations(node, ws) {
+    for (const dv of children(node, 'dataValidation')) {
+        const sqref = dv.attrs['sqref'] ?? '';
+        if (!sqref)
+            continue;
+        const type = (dv.attrs['type'] ?? 'whole');
+        const val = { type };
+        if (dv.attrs['operator'])
+            val.operator = dv.attrs['operator'];
+        if (dv.attrs['allowBlank'] === '1')
+            val.allowBlank = true;
+        if (dv.attrs['showErrorMessage'] === '1')
+            val.showErrorAlert = true;
+        if (dv.attrs['errorTitle'])
+            val.errorTitle = dv.attrs['errorTitle'];
+        if (dv.attrs['error'])
+            val.error = dv.attrs['error'];
+        if (dv.attrs['showInputMessage'] === '1')
+            val.showInputMessage = true;
+        if (dv.attrs['promptTitle'])
+            val.promptTitle = dv.attrs['promptTitle'];
+        if (dv.attrs['prompt'])
+            val.prompt = dv.attrs['prompt'];
+        if (dv.attrs['showDropDown'] === '1')
+            val.showDropDown = false;
+        const f1 = child(dv, 'formula1');
+        const f2 = child(dv, 'formula2');
+        if (f1?.text) {
+            if (type === 'list' && f1.text.startsWith('"') && f1.text.endsWith('"')) {
+                val.list = f1.text.slice(1, -1).split(',');
+            }
+            else {
+                val.formula1 = f1.text;
+            }
+        }
+        if (f2?.text)
+            val.formula2 = f2.text;
+        ws.addDataValidation(sqref, val);
+    }
+}
 function parseTableXml(xml) {
     try {
         const root = parseXml(xml);
@@ -538,6 +766,873 @@ function parseTableXml(xml) {
         return null;
     }
 }
+const EMU_PX = 9525;
+function parseAnchorPos(node) {
+    return {
+        col: parseInt(child(node, 'col')?.text ?? '0', 10),
+        row: parseInt(child(node, 'row')?.text ?? '0', 10),
+        colOff: parseInt(child(node, 'colOff')?.text ?? '0', 10),
+        rowOff: parseInt(child(node, 'rowOff')?.text ?? '0', 10),
+    };
+}
+function extToFormat(ext) {
+    const map = {
+        png: 'png', jpg: 'jpeg', jpeg: 'jpeg', gif: 'gif',
+        emf: 'emf', wmf: 'wmf', tiff: 'tiff', tif: 'tiff',
+        svg: 'svg', ico: 'ico', webp: 'webp', bmp: 'bmp',
+    };
+    return map[ext.toLowerCase()] ?? 'png';
+}
+function parseDrawingObjects(drawXml, drawRels, drawDir, getEntry, ws) {
+    const root = parseXml(drawXml);
+    for (const anchor of root.children) {
+        if (typeof anchor === 'string')
+            continue;
+        const tag = localName(anchor.tag);
+        if (tag !== 'twoCellAnchor' && tag !== 'oneCellAnchor' && tag !== 'absoluteAnchor')
+            continue;
+        const anchorFrom = parseDrawingAnchorFrom(anchor, tag);
+        const pic = findDescendant(anchor, 'pic');
+        if (pic) {
+            parseDrawingImage(pic, anchor, tag, anchorFrom, drawRels, drawDir, getEntry, ws);
+            continue;
+        }
+        const graphicFrame = findDescendant(anchor, 'graphicFrame');
+        if (graphicFrame) {
+            parseDrawingChart(graphicFrame, anchor, tag, drawRels, drawDir, getEntry, ws);
+            continue;
+        }
+        const oMath = findDescendant(anchor, 'oMath');
+        if (oMath) {
+            parseDrawingMathEquation(oMath, anchor, tag, anchorFrom, ws);
+            continue;
+        }
+        const sp = findDescendant(anchor, 'sp');
+        if (sp) {
+            parseDrawingShape(sp, anchor, tag, ws);
+            continue;
+        }
+    }
+}
+function parseDrawingChart(graphicFrame, anchor, tag, drawRels, drawDir, getEntry, ws) {
+    const chartRef = findDescendant(graphicFrame, 'chart');
+    if (!chartRef || !drawRels)
+        return;
+    const rId = chartRef.attrs['r:id'] ?? attr(chartRef, 'r:id') ?? '';
+    if (!rId)
+        return;
+    const rel = drawRels.get(rId);
+    if (!rel)
+        return;
+    const chartPath = rel.target.startsWith('/')
+        ? rel.target.slice(1)
+        : resolvePath(drawDir, rel.target);
+    const chartEntry = getEntry(chartPath);
+    if (!chartEntry)
+        return;
+    const dec = new TextDecoder();
+    const chartXml = dec.decode(chartEntry.data);
+    const chartRoot = parseXml(chartXml);
+    let from = { col: 0, row: 0 };
+    let to = { col: 8, row: 15 };
+    if (tag === 'twoCellAnchor') {
+        const fromNode = child(anchor, 'from');
+        const toNode = child(anchor, 'to');
+        if (fromNode) {
+            from = {
+                col: parseInt(child(fromNode, 'col')?.text ?? '0', 10),
+                row: parseInt(child(fromNode, 'row')?.text ?? '0', 10),
+            };
+        }
+        if (toNode) {
+            to = {
+                col: parseInt(child(toNode, 'col')?.text ?? '0', 10),
+                row: parseInt(child(toNode, 'row')?.text ?? '0', 10),
+            };
+        }
+    }
+    const plotArea = findDescendant(chartRoot, 'plotArea');
+    if (!plotArea)
+        return;
+    const chartTypeMap = {
+        'barChart': 'column', 'bar3DChart': 'column',
+        'lineChart': 'line', 'line3DChart': 'line',
+        'areaChart': 'area', 'area3DChart': 'area',
+        'pieChart': 'pie', 'pie3DChart': 'pie',
+        'doughnutChart': 'doughnut',
+        'scatterChart': 'scatter',
+        'bubbleChart': 'bubble',
+        'radarChart': 'radar',
+        'stockChart': 'stock',
+    };
+    let chartType = 'column';
+    let chartGroupNode;
+    for (const plotChild of plotArea.children) {
+        if (typeof plotChild === 'string')
+            continue;
+        const localTag = localName(plotChild.tag);
+        if (chartTypeMap[localTag]) {
+            chartType = chartTypeMap[localTag];
+            chartGroupNode = plotChild;
+            if (localTag === 'barChart' || localTag === 'bar3DChart') {
+                const barDir = child(plotChild, 'barDir');
+                const barDirVal = barDir?.attrs['val'] ?? '';
+                if (barDirVal === 'bar')
+                    chartType = 'bar';
+                const grouping = child(plotChild, 'grouping');
+                const grpVal = grouping?.attrs['val'] ?? '';
+                if (grpVal === 'stacked')
+                    chartType = (chartType === 'bar' ? 'barStacked' : 'columnStacked');
+                if (grpVal === 'percentStacked')
+                    chartType = (chartType === 'bar' ? 'barStacked100' : 'columnStacked100');
+            }
+            if (localTag === 'lineChart') {
+                const marker = findDescendant(plotChild, 'marker');
+                if (marker) {
+                    const markerVal = child(marker, 'symbol')?.attrs['val'] ?? '';
+                    if (markerVal && markerVal !== 'none')
+                        chartType = 'lineMarker';
+                }
+            }
+            if (localTag === 'scatterChart') {
+                const scatterStyle = child(plotChild, 'scatterStyle');
+                if (scatterStyle?.attrs['val']?.includes('Smooth'))
+                    chartType = 'scatterSmooth';
+            }
+            if (localTag === 'radarChart') {
+                const radarStyle = child(plotChild, 'radarStyle');
+                if (radarStyle?.attrs['val'] === 'filled')
+                    chartType = 'radarFilled';
+            }
+            break;
+        }
+    }
+    if (!chartGroupNode)
+        return;
+    const series = [];
+    for (const ser of children(chartGroupNode, 'ser')) {
+        const s = { values: '' };
+        const tx = child(ser, 'tx');
+        if (tx) {
+            const strRef = findDescendant(tx, 'strRef');
+            if (strRef) {
+                const f = child(strRef, 'f');
+                if (f?.text)
+                    s.name = f.text;
+                const strCache = child(strRef, 'strCache');
+                if (strCache) {
+                    const pt = findDescendant(strCache, 'pt');
+                    const v = pt ? findDescendant(pt, 'v') : undefined;
+                    if (v?.text)
+                        s.name = v.text;
+                }
+            }
+            const v = findDescendant(tx, 'v');
+            if (v?.text && !s.name)
+                s.name = v.text;
+        }
+        const val = child(ser, 'val') || child(ser, 'yVal');
+        if (val) {
+            const numRef = findDescendant(val, 'numRef');
+            if (numRef) {
+                const f = child(numRef, 'f');
+                if (f?.text)
+                    s.values = f.text;
+            }
+        }
+        const cat = child(ser, 'cat') || child(ser, 'xVal');
+        if (cat) {
+            const strRef = findDescendant(cat, 'strRef');
+            const numRef = findDescendant(cat, 'numRef');
+            const ref = strRef || numRef;
+            if (ref) {
+                const f = child(ref, 'f');
+                if (f?.text)
+                    s.categories = f.text;
+            }
+        }
+        const spPr = child(ser, 'spPr');
+        if (spPr) {
+            const solidFill = child(spPr, 'solidFill');
+            if (solidFill) {
+                const srgb = child(solidFill, 'srgbClr');
+                if (srgb?.attrs['val'])
+                    s.color = '#' + srgb.attrs['val'];
+            }
+        }
+        if (s.values)
+            series.push(s);
+    }
+    if (!series.length)
+        return;
+    let title;
+    const titleNode = child(chartRoot, 'title') || findDescendant(chartRoot, 'title');
+    if (titleNode) {
+        const aT = findDescendant(titleNode, 't');
+        if (aT?.text)
+            title = aT.text;
+    }
+    let xAxis;
+    let yAxis;
+    const catAx = findDescendant(plotArea, 'catAx') || findDescendant(plotArea, 'dateAx');
+    const valAx = findDescendant(plotArea, 'valAx');
+    if (catAx) {
+        xAxis = {};
+        const axTitle = findDescendant(catAx, 'title');
+        if (axTitle) {
+            const t = findDescendant(axTitle, 't');
+            if (t?.text)
+                xAxis.title = t.text;
+        }
+    }
+    if (valAx) {
+        yAxis = {};
+        const axTitle = findDescendant(valAx, 'title');
+        if (axTitle) {
+            const t = findDescendant(axTitle, 't');
+            if (t?.text)
+                yAxis.title = t.text;
+        }
+        const gridLines = child(valAx, 'majorGridlines');
+        if (gridLines)
+            yAxis.gridLines = true;
+    }
+    let legend = false;
+    const legendNode = findDescendant(chartRoot, 'legend');
+    if (legendNode) {
+        const legendPos = child(legendNode, 'legendPos');
+        const posVal = legendPos?.attrs['val'];
+        legend = posVal || true;
+    }
+    const varyColors = child(chartGroupNode, 'varyColors');
+    const varyColorsVal = varyColors?.attrs['val'] !== '0';
+    const chart = { type: chartType, series, from, to };
+    if (title)
+        chart.title = title;
+    if (xAxis)
+        chart.xAxis = xAxis;
+    if (yAxis)
+        chart.yAxis = yAxis;
+    if (legend !== false)
+        chart.legend = legend;
+    if (varyColorsVal)
+        chart.varyColors = true;
+    ws.addChart(chart);
+}
+function parseDrawingShape(sp, anchor, tag, ws) {
+    let from = { col: 0, row: 0 };
+    let to = { col: 2, row: 2 };
+    if (tag === 'twoCellAnchor') {
+        const fromNode = child(anchor, 'from');
+        const toNode = child(anchor, 'to');
+        if (fromNode) {
+            from = {
+                col: parseInt(child(fromNode, 'col')?.text ?? '0', 10),
+                row: parseInt(child(fromNode, 'row')?.text ?? '0', 10),
+            };
+        }
+        if (toNode) {
+            to = {
+                col: parseInt(child(toNode, 'col')?.text ?? '0', 10),
+                row: parseInt(child(toNode, 'row')?.text ?? '0', 10),
+            };
+        }
+    }
+    const spPr = findDescendant(sp, 'spPr');
+    let shapeType = 'rect';
+    let fillColor;
+    let lineColor;
+    let lineWidth;
+    let rotation;
+    if (spPr) {
+        const prstGeom = findDescendant(spPr, 'prstGeom');
+        if (prstGeom) {
+            const prst = prstGeom.attrs['prst'] ?? '';
+            const validTypes = new Set([
+                'rect', 'roundRect', 'ellipse', 'triangle', 'diamond',
+                'pentagon', 'hexagon', 'octagon', 'star5', 'star6',
+                'rightArrow', 'leftArrow', 'upArrow', 'downArrow',
+                'line', 'curvedConnector3', 'callout1', 'callout2',
+                'cloud', 'heart', 'lightningBolt', 'sun', 'moon',
+                'smileyFace', 'flowChartProcess', 'flowChartDecision',
+                'flowChartTerminator', 'flowChartDocument',
+            ]);
+            if (validTypes.has(prst))
+                shapeType = prst;
+        }
+        const solidFill = child(spPr, 'solidFill');
+        if (solidFill) {
+            const srgb = child(solidFill, 'srgbClr');
+            if (srgb?.attrs['val'])
+                fillColor = '#' + srgb.attrs['val'];
+            const schemeClr = child(solidFill, 'schemeClr');
+            if (schemeClr?.attrs['val'])
+                fillColor = 'theme:' + schemeClr.attrs['val'];
+        }
+        const ln = child(spPr, 'ln');
+        if (ln) {
+            const w = ln.attrs['w'];
+            if (w)
+                lineWidth = Math.round(parseInt(w, 10) / EMU_PX);
+            const lineFill = child(ln, 'solidFill');
+            if (lineFill) {
+                const srgb = child(lineFill, 'srgbClr');
+                if (srgb?.attrs['val'])
+                    lineColor = '#' + srgb.attrs['val'];
+            }
+        }
+        const xfrm = findDescendant(spPr, 'xfrm');
+        if (xfrm?.attrs['rot'])
+            rotation = parseInt(xfrm.attrs['rot'], 10) / 60000;
+    }
+    let text;
+    let font;
+    const txBody = findDescendant(sp, 'txBody');
+    if (txBody) {
+        const bodyPr = child(txBody, 'bodyPr');
+        const prstTxWarp = bodyPr ? child(bodyPr, 'prstTxWarp') : undefined;
+        const wordArtPreset = prstTxWarp?.attrs['prst'] ?? bodyPr?.attrs['prstTxWarp'] ?? '';
+        const textParts = [];
+        for (const p of children(txBody, 'p')) {
+            for (const r of children(p, 'r')) {
+                const t = child(r, 't');
+                if (t?.text)
+                    textParts.push(t.text);
+                if (!font) {
+                    const rPr = child(r, 'rPr');
+                    if (rPr) {
+                        font = {};
+                        if (rPr.attrs['sz'])
+                            font.size = parseInt(rPr.attrs['sz'], 10) / 100;
+                        if (rPr.attrs['b'] === '1')
+                            font.bold = true;
+                        if (rPr.attrs['i'] === '1')
+                            font.italic = true;
+                        const latin = findDescendant(rPr, 'latin');
+                        if (latin?.attrs['typeface'])
+                            font.name = latin.attrs['typeface'];
+                        const solidFill = child(rPr, 'solidFill');
+                        if (solidFill) {
+                            const srgb = child(solidFill, 'srgbClr');
+                            if (srgb?.attrs['val'])
+                                font.color = '#' + srgb.attrs['val'];
+                        }
+                    }
+                }
+            }
+        }
+        text = textParts.join('');
+        const validWordArtPresets = new Set([
+            'textPlain', 'textArchUp', 'textArchDown', 'textCircle',
+            'textWave1', 'textWave2', 'textInflate', 'textDeflate',
+            'textFadeUp', 'textFadeDown', 'textFadeLeft', 'textFadeRight',
+            'textSlantUp', 'textSlantDown', 'textCascadeUp', 'textCascadeDown',
+            'textChevron', 'textRingInside', 'textRingOutside', 'textStop',
+        ]);
+        if (wordArtPreset && validWordArtPresets.has(wordArtPreset) && text) {
+            const wa = { text, from, to };
+            if (wordArtPreset !== 'textPlain')
+                wa.preset = wordArtPreset;
+            if (font)
+                wa.font = font;
+            if (fillColor)
+                wa.fillColor = fillColor;
+            if (lineColor)
+                wa.outlineColor = lineColor;
+            ws.addWordArt(wa);
+            return;
+        }
+    }
+    const shape = { type: shapeType, from, to };
+    if (text)
+        shape.text = text;
+    if (fillColor)
+        shape.fillColor = fillColor;
+    if (lineColor)
+        shape.lineColor = lineColor;
+    if (lineWidth)
+        shape.lineWidth = lineWidth;
+    if (font)
+        shape.font = font;
+    if (rotation)
+        shape.rotation = rotation;
+    ws.addShape(shape);
+}
+function parseSparklineExtensions(extLst, ws) {
+    for (const ext of children(extLst, 'ext')) {
+        const sparklineGroups = ext.children?.filter(c => typeof c !== 'string' && localName(c.tag) === 'sparklineGroups');
+        if (!sparklineGroups?.length)
+            continue;
+        for (const groups of sparklineGroups) {
+            for (const group of children(groups, 'sparklineGroup')) {
+                const typeAttr = group.attrs['type'] ?? 'line';
+                const spkType = typeAttr === 'column' ? 'bar' :
+                    typeAttr === 'stacked' ? 'stacked' : 'line';
+                const colorSeries = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorSeries');
+                const colorHigh = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorHigh');
+                const colorLow = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorLow');
+                const colorFirst = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorFirst');
+                const colorLast = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorLast');
+                const colorNegative = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorNegative');
+                const colorMarkers = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'colorMarkers');
+                const showHigh = group.attrs['high'] === '1';
+                const showLow = group.attrs['low'] === '1';
+                const showFirst = group.attrs['first'] === '1';
+                const showLast = group.attrs['last'] === '1';
+                const showNegative = group.attrs['negative'] === '1';
+                const showMarkers = group.attrs['markers'] === '1';
+                const lwAttr = group.attrs['lineWeight'];
+                const lineWidth = lwAttr ? parseFloat(lwAttr) : undefined;
+                const minAxisType = group.attrs['minAxisType'] === 'individual' ? 'individual'
+                    : group.attrs['minAxisType'] === 'custom' ? 'custom' : undefined;
+                const maxAxisType = group.attrs['maxAxisType'] === 'individual' ? 'individual'
+                    : group.attrs['maxAxisType'] === 'custom' ? 'custom' : undefined;
+                const sparklinesNode = group.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'sparklines');
+                if (!sparklinesNode)
+                    continue;
+                const sparklineNodes = sparklinesNode.children?.filter(c => typeof c !== 'string' && localName(c.tag) === 'sparkline');
+                if (!sparklineNodes)
+                    continue;
+                for (const spk of sparklineNodes) {
+                    const fNode = spk.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'f');
+                    const sqrefNode = spk.children?.find(c => typeof c !== 'string' && localName(c.tag) === 'sqref');
+                    const dataRange = fNode?.text ?? '';
+                    const location = sqrefNode?.text ?? '';
+                    if (!dataRange || !location)
+                        continue;
+                    const sp = { type: spkType, dataRange, location };
+                    if (colorSeries) {
+                        const rgb = colorSeries.attrs['rgb'];
+                        if (rgb)
+                            sp.color = '#' + rgb.slice(2);
+                        const theme = colorSeries.attrs['theme'];
+                        if (theme)
+                            sp.color = 'theme:' + theme;
+                    }
+                    if (colorHigh) {
+                        const rgb = colorHigh.attrs['rgb'];
+                        if (rgb)
+                            sp.highColor = '#' + rgb.slice(2);
+                        const theme = colorHigh.attrs['theme'];
+                        if (theme)
+                            sp.highColor = 'theme:' + theme;
+                    }
+                    if (colorLow) {
+                        const rgb = colorLow.attrs['rgb'];
+                        if (rgb)
+                            sp.lowColor = '#' + rgb.slice(2);
+                        const theme = colorLow.attrs['theme'];
+                        if (theme)
+                            sp.lowColor = 'theme:' + theme;
+                    }
+                    if (colorFirst) {
+                        const rgb = colorFirst.attrs['rgb'];
+                        if (rgb)
+                            sp.firstColor = '#' + rgb.slice(2);
+                        const theme = colorFirst.attrs['theme'];
+                        if (theme)
+                            sp.firstColor = 'theme:' + theme;
+                    }
+                    if (colorLast) {
+                        const rgb = colorLast.attrs['rgb'];
+                        if (rgb)
+                            sp.lastColor = '#' + rgb.slice(2);
+                        const theme = colorLast.attrs['theme'];
+                        if (theme)
+                            sp.lastColor = 'theme:' + theme;
+                    }
+                    if (colorNegative) {
+                        const rgb = colorNegative.attrs['rgb'];
+                        if (rgb)
+                            sp.negativeColor = '#' + rgb.slice(2);
+                        const theme = colorNegative.attrs['theme'];
+                        if (theme)
+                            sp.negativeColor = 'theme:' + theme;
+                    }
+                    if (colorMarkers) {
+                        const rgb = colorMarkers.attrs['rgb'];
+                        if (rgb)
+                            sp.markersColor = '#' + rgb.slice(2);
+                        const theme = colorMarkers.attrs['theme'];
+                        if (theme)
+                            sp.markersColor = 'theme:' + theme;
+                    }
+                    if (showHigh)
+                        sp.showHigh = true;
+                    if (showLow)
+                        sp.showLow = true;
+                    if (showFirst)
+                        sp.showFirst = true;
+                    if (showLast)
+                        sp.showLast = true;
+                    if (showNegative)
+                        sp.showNegative = true;
+                    if (showMarkers)
+                        sp.showMarkers = true;
+                    if (lineWidth !== undefined)
+                        sp.lineWidth = lineWidth;
+                    if (minAxisType)
+                        sp.minAxisType = minAxisType;
+                    if (maxAxisType)
+                        sp.maxAxisType = maxAxisType;
+                    ws.addSparkline(sp);
+                }
+            }
+        }
+    }
+}
+function parseDrawingAnchorFrom(anchor, tag) {
+    const result = {};
+    if (tag === 'twoCellAnchor' || tag === 'oneCellAnchor') {
+        const fromNode = child(anchor, 'from');
+        if (fromNode) {
+            result.from = {
+                col: parseInt(child(fromNode, 'col')?.text ?? '0', 10),
+                row: parseInt(child(fromNode, 'row')?.text ?? '0', 10),
+                colOff: parseInt(child(fromNode, 'colOff')?.text ?? '0', 10),
+                rowOff: parseInt(child(fromNode, 'rowOff')?.text ?? '0', 10),
+            };
+        }
+    }
+    if (tag === 'oneCellAnchor') {
+        const ext2 = findDescendant(anchor, 'ext');
+        if (ext2) {
+            result.width = parseInt(ext2.attrs['cx'] ?? '0', 10);
+            result.height = parseInt(ext2.attrs['cy'] ?? '0', 10);
+        }
+    }
+    return result;
+}
+function parseDrawingImage(pic, anchor, tag, anchorInfo, drawRels, drawDir, getEntry, ws) {
+    const blipFill = findDescendant(pic, 'blipFill');
+    const blip = blipFill ? findDescendant(blipFill, 'blip') : undefined;
+    const embedId = blip?.attrs['r:embed'] ?? blip?.attrs['embed'] ?? '';
+    if (!embedId || !drawRels)
+        return;
+    const imgRel = drawRels.get(embedId);
+    if (!imgRel)
+        return;
+    const imgPath = imgRel.target.startsWith('/')
+        ? imgRel.target.slice(1)
+        : resolvePath(drawDir, imgRel.target);
+    const imgEntry = getEntry(imgPath);
+    if (!imgEntry)
+        return;
+    const ext = imgPath.split('.').pop() ?? 'png';
+    const format = extToFormat(ext);
+    const cNvPr = findDescendant(pic, 'cNvPr');
+    const altText = cNvPr?.attrs['descr'] || undefined;
+    const img = { data: imgEntry.data, format };
+    if (altText)
+        img.altText = altText;
+    if (tag === 'twoCellAnchor') {
+        const fromNode = child(anchor, 'from');
+        const toNode = child(anchor, 'to');
+        if (fromNode)
+            img.from = parseAnchorPos(fromNode);
+        if (toNode)
+            img.to = parseAnchorPos(toNode);
+    }
+    else if (tag === 'oneCellAnchor') {
+        if (anchorInfo.from)
+            img.from = anchorInfo.from;
+        if (anchorInfo.width)
+            img.width = Math.round(anchorInfo.width / EMU_PX);
+        if (anchorInfo.height)
+            img.height = Math.round(anchorInfo.height / EMU_PX);
+    }
+    else {
+        const posNode = child(anchor, 'pos');
+        const ext2 = child(anchor, 'ext');
+        if (posNode) {
+            img.position = {
+                x: Math.round(parseInt(posNode.attrs['x'] ?? '0', 10) / EMU_PX),
+                y: Math.round(parseInt(posNode.attrs['y'] ?? '0', 10) / EMU_PX),
+            };
+        }
+        if (ext2) {
+            img.width = Math.round(parseInt(ext2.attrs['cx'] ?? '0', 10) / EMU_PX);
+            img.height = Math.round(parseInt(ext2.attrs['cy'] ?? '0', 10) / EMU_PX);
+        }
+    }
+    ws.addImage(img);
+}
+function parseDrawingMathEquation(oMath, anchor, tag, anchorInfo, ws) {
+    const elements = parseOmmlChildren(oMath);
+    if (!elements.length)
+        return;
+    const from = anchorInfo.from ?? { col: 0, row: 0 };
+    const eq = { elements, from };
+    if (anchorInfo.width)
+        eq.width = anchorInfo.width;
+    if (anchorInfo.height)
+        eq.height = anchorInfo.height;
+    const firstRPr = findDescendant(oMath, 'rPr');
+    if (firstRPr) {
+        const szAttr = firstRPr.attrs['sz'];
+        if (szAttr)
+            eq.fontSize = parseInt(szAttr, 10) / 100;
+        const latin = findDescendant(firstRPr, 'latin');
+        if (latin?.attrs['typeface'])
+            eq.fontName = latin.attrs['typeface'];
+    }
+    ws.addMathEquation(eq);
+}
+function parseOmmlChildren(node) {
+    const elements = [];
+    for (const c of node.children) {
+        if (typeof c === 'string')
+            continue;
+        const el = parseOmmlElement(c);
+        if (el)
+            elements.push(el);
+    }
+    return elements;
+}
+function parseOmmlElement(node) {
+    const tag = localName(node.tag);
+    switch (tag) {
+        case 'r': {
+            const t = findDescendant(node, 't');
+            return { type: 'text', text: t?.text ?? '' };
+        }
+        case 'f': {
+            const num = child(node, 'num');
+            const den = child(node, 'den');
+            return {
+                type: 'frac',
+                base: num ? parseOmmlChildren(num) : [],
+                argument: den ? parseOmmlChildren(den) : [],
+            };
+        }
+        case 'sSup': {
+            const e = child(node, 'e');
+            const sup = child(node, 'sup');
+            return {
+                type: 'sup',
+                base: e ? parseOmmlChildren(e) : [],
+                argument: sup ? parseOmmlChildren(sup) : [],
+            };
+        }
+        case 'sSub': {
+            const e = child(node, 'e');
+            const sub = child(node, 'sub');
+            return {
+                type: 'sub',
+                base: e ? parseOmmlChildren(e) : [],
+                argument: sub ? parseOmmlChildren(sub) : [],
+            };
+        }
+        case 'sSubSup': {
+            const e = child(node, 'e');
+            const sub = child(node, 'sub');
+            const sup = child(node, 'sup');
+            return {
+                type: 'subSup',
+                base: e ? parseOmmlChildren(e) : [],
+                subscript: sub ? parseOmmlChildren(sub) : [],
+                superscript: sup ? parseOmmlChildren(sup) : [],
+            };
+        }
+        case 'nary': {
+            const naryPr = child(node, 'naryPr');
+            const chrNode = naryPr ? child(naryPr, 'chr') : undefined;
+            const operator = chrNode?.attrs['m:val'] ?? chrNode?.attrs['val'] ?? '∑';
+            const sub = child(node, 'sub');
+            const sup = child(node, 'sup');
+            const e = child(node, 'e');
+            return {
+                type: 'nary',
+                operator,
+                lower: sub ? parseOmmlChildren(sub) : [],
+                upper: sup ? parseOmmlChildren(sup) : [],
+                body: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'rad': {
+            const radPr = child(node, 'radPr');
+            const degHide = radPr ? child(radPr, 'degHide') : undefined;
+            const hideDegree = degHide?.attrs['m:val'] === '1' || degHide?.attrs['val'] === '1';
+            const deg = child(node, 'deg');
+            const e = child(node, 'e');
+            return {
+                type: 'rad',
+                hideDegree,
+                degree: deg ? parseOmmlChildren(deg) : [],
+                body: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'd': {
+            const dPr = child(node, 'dPr');
+            const begChr = dPr ? child(dPr, 'begChr') : undefined;
+            const endChr = dPr ? child(dPr, 'endChr') : undefined;
+            const e = child(node, 'e');
+            return {
+                type: 'delim',
+                open: begChr?.attrs['m:val'] ?? begChr?.attrs['val'] ?? '(',
+                close: endChr?.attrs['m:val'] ?? endChr?.attrs['val'] ?? ')',
+                body: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'func': {
+            const fName = child(node, 'fName');
+            const e = child(node, 'e');
+            return {
+                type: 'func',
+                base: fName ? parseOmmlChildren(fName) : [],
+                argument: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'groupChr': {
+            const groupChrPr = child(node, 'groupChrPr');
+            const chrNode = groupChrPr ? child(groupChrPr, 'chr') : undefined;
+            const e = child(node, 'e');
+            return {
+                type: 'groupChar',
+                operator: chrNode?.attrs['m:val'] ?? chrNode?.attrs['val'] ?? '⏟',
+                base: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'acc': {
+            const accPr = child(node, 'accPr');
+            const chrNode = accPr ? child(accPr, 'chr') : undefined;
+            const e = child(node, 'e');
+            return {
+                type: 'accent',
+                operator: chrNode?.attrs['m:val'] ?? chrNode?.attrs['val'] ?? '̂',
+                base: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'bar': {
+            const e = child(node, 'e');
+            return {
+                type: 'bar',
+                base: e ? parseOmmlChildren(e) : [],
+            };
+        }
+        case 'limLow': {
+            const e = child(node, 'e');
+            const lim = child(node, 'lim');
+            return {
+                type: 'limLow',
+                base: e ? parseOmmlChildren(e) : [],
+                argument: lim ? parseOmmlChildren(lim) : [],
+            };
+        }
+        case 'limUpp': {
+            const e = child(node, 'e');
+            const lim = child(node, 'lim');
+            return {
+                type: 'limUpp',
+                base: e ? parseOmmlChildren(e) : [],
+                argument: lim ? parseOmmlChildren(lim) : [],
+            };
+        }
+        case 'm': {
+            const rows = [];
+            for (const mr of children(node, 'mr')) {
+                const row = [];
+                for (const e of children(mr, 'e')) {
+                    const cellElements = parseOmmlChildren(e);
+                    if (cellElements.length === 1)
+                        row.push(cellElements[0]);
+                    else
+                        row.push({ type: 'text', text: cellElements.map(el => el.text ?? '').join('') });
+                }
+                rows.push(row);
+            }
+            return { type: 'matrix', rows };
+        }
+        case 'eqArr': {
+            const rows = [];
+            for (const e of children(node, 'e')) {
+                rows.push(parseOmmlChildren(e));
+            }
+            return { type: 'eqArr', rows };
+        }
+        default:
+            return null;
+    }
+}
+function parseCellImagesFromRichData(vmCells, getText, getEntry, ws) {
+    const metaXml = getText('xl/metadata.xml');
+    if (!metaXml)
+        return;
+    const metaRoot = parseXml(metaXml);
+    const valueMeta = child(metaRoot, 'valueMetadata');
+    if (!valueMeta)
+        return;
+    const vmBks = children(valueMeta, 'bk');
+    const futureMeta = metaRoot.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'futureMetadata');
+    const fmBks = futureMeta ? children(futureMeta, 'bk') : [];
+    const rvXml = getText('xl/richData/rdrichvalue.xml');
+    if (!rvXml)
+        return;
+    const rvRoot = parseXml(rvXml);
+    const rvEntries = children(rvRoot, 'rv');
+    const rvRelRelsXml = getText('xl/richData/_rels/richValueRel.xml.rels');
+    if (!rvRelRelsXml)
+        return;
+    const rvRelRels = parseRels(rvRelRelsXml);
+    const rvRelXml = getText('xl/richData/richValueRel.xml');
+    if (!rvRelXml)
+        return;
+    const rvRelRoot = parseXml(rvRelXml);
+    const relEntries = children(rvRelRoot, 'rel');
+    for (const [cellRef, vmIdx] of vmCells) {
+        const vmBk = vmBks[vmIdx - 1];
+        if (!vmBk)
+            continue;
+        const rc = vmBk.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'rc');
+        if (!rc)
+            continue;
+        const fmIdx = parseInt(rc.attrs['v'] ?? '-1', 10);
+        if (fmIdx < 0)
+            continue;
+        const fmBk = fmBks[fmIdx];
+        if (!fmBk)
+            continue;
+        const rvb = findDescendant(fmBk, 'rvb');
+        const rvIdx = parseInt(rvb?.attrs['i'] ?? '-1', 10);
+        if (rvIdx < 0)
+            continue;
+        const rv = rvEntries[rvIdx];
+        if (!rv)
+            continue;
+        const vNodes = children(rv, 'v');
+        const relIdx = parseInt(vNodes[0]?.text ?? '-1', 10);
+        if (relIdx < 0)
+            continue;
+        const relEntry = relEntries[relIdx];
+        if (!relEntry)
+            continue;
+        const rId = relEntry.attrs['r:id'] ?? '';
+        const imgRel = rvRelRels.get(rId);
+        if (!imgRel)
+            continue;
+        const imgPath = imgRel.target.startsWith('/')
+            ? imgRel.target.slice(1)
+            : `xl/richData/${imgRel.target}`;
+        const imgEntry = getEntry(imgPath);
+        if (!imgEntry)
+            continue;
+        const ext = imgPath.split('.').pop() ?? 'png';
+        const format = extToFormat(ext);
+        ws.addCellImage({ data: imgEntry.data, format, cell: cellRef });
+    }
+}
+function findDescendant(node, tagName) {
+    for (const c of node.children) {
+        if (typeof c === 'string')
+            continue;
+        if (localName(c.tag) === tagName)
+            return c;
+        const found = findDescendant(c, tagName);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
 function resolvePath(base, relative) {
     const parts = base.replace(/\/$/, '').split('/');
     for (const seg of relative.split('/')) {
@@ -581,6 +1676,26 @@ export async function readWorkbook(data) {
     const wbRoot = parseXml(wbXml);
     const sheetsNode = find(wbRoot, 'sheets');
     const sheetNodes = sheetsNode ? children(sheetsNode, 'sheet') : [];
+    const namedRanges = [];
+    const definedNamesNode = find(wbRoot, 'definedNames');
+    if (definedNamesNode) {
+        for (const dn of children(definedNamesNode, 'definedName')) {
+            const name = dn.attrs['name'] ?? '';
+            const ref = dn.text ?? '';
+            if (!name || !ref)
+                continue;
+            const nr = { name, ref };
+            if (dn.attrs['localSheetId'] !== undefined) {
+                const idx = parseInt(dn.attrs['localSheetId'], 10);
+                const scopeSheet = sheetNodes[idx];
+                if (scopeSheet)
+                    nr.scope = scopeSheet.attrs['name'] ?? undefined;
+            }
+            if (dn.attrs['comment'])
+                nr.comment = dn.attrs['comment'];
+            namedRanges.push(nr);
+        }
+    }
     const allRels = new Map();
     for (const [path, entry] of zip) {
         if (path.includes('_rels/')) {
@@ -599,10 +1714,11 @@ export async function readWorkbook(data) {
         const sheetXml = getText(target) ?? '';
         if (!sheetXml)
             continue;
-        const { ws, originalXml, unknownParts: sheetUnknown, tableRIds } = parseWorksheet(sheetXml, name, styles, sharedStrings);
+        const { ws, originalXml, unknownParts: sheetUnknown, tableRIds, legacyDrawingRId, ctrlPropRIds, drawingRId, vmCells } = parseWorksheet(sheetXml, name, styles, sharedStrings);
         ws.sheetIndex = sheets.length + 1;
         ws.rId = rId;
         const tablePaths = [];
+        const tableXmls = [];
         if (tableRIds.length) {
             const sheetFileName = target.split('/').pop() ?? '';
             const sheetDir = target.substring(0, target.lastIndexOf('/') + 1);
@@ -622,17 +1738,179 @@ export async function readWorkbook(data) {
                         if (table)
                             ws.addTable(table);
                         tablePaths.push(tblTarget);
+                        tableXmls.push(tblXml);
                     }
                 }
                 ws.tableRIds = tableRIds;
             }
         }
-        sheets.push({ ws, sheetId, rId, originalXml, unknownParts: sheetUnknown, tablePaths });
+        if (legacyDrawingRId && ctrlPropRIds.length) {
+            const sheetFileName = target.split('/').pop() ?? '';
+            const sheetDir = target.substring(0, target.lastIndexOf('/') + 1);
+            const sheetRelsPath = `${sheetDir}_rels/${sheetFileName}.rels`;
+            const sheetRels = allRels.get(sheetRelsPath);
+            if (sheetRels) {
+                const vmlRel = sheetRels.get(legacyDrawingRId);
+                const vmlPath = vmlRel
+                    ? (vmlRel.target.startsWith('/') ? vmlRel.target.slice(1) : resolvePath(sheetDir, vmlRel.target))
+                    : '';
+                const vmlXml = vmlPath ? getText(vmlPath) : '';
+                const vmlControls = [];
+                if (vmlXml) {
+                    const vmlRoot = parseXml(vmlXml);
+                    for (const shape of vmlRoot.children) {
+                        if (typeof shape === 'string')
+                            continue;
+                        if (localName(shape.tag) !== 'shape')
+                            continue;
+                        const cd = shape.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'ClientData');
+                        if (!cd)
+                            continue;
+                        const objType = cd.attrs['ObjectType'] ?? '';
+                        if (objType === 'Note' || !objType)
+                            continue;
+                        const idStr = (shape.attrs['id'] ?? '').replace(/\D/g, '');
+                        const shapeId = parseInt(idStr, 10) || 0;
+                        vmlControls.push({ objectType: objType, shapeXml: nodeToXml(shape), clientData: cd, shapeId });
+                    }
+                }
+                for (let ci = 0; ci < ctrlPropRIds.length; ci++) {
+                    const cpRel = sheetRels.get(ctrlPropRIds[ci]);
+                    if (!cpRel)
+                        continue;
+                    const cpPath = cpRel.target.startsWith('/') ? cpRel.target.slice(1) : resolvePath(sheetDir, cpRel.target);
+                    const cpXml = getText(cpPath) ?? '';
+                    const cpRoot = cpXml ? parseXml(cpXml) : null;
+                    const objType = cpRoot?.attrs['objectType'] ?? '';
+                    const typeName = (OBJ_TYPE_TO_CTRL[objType] ?? 'button');
+                    const vml = vmlControls[ci];
+                    const anchor = parseVmlAnchor(vml?.clientData);
+                    const ctrl = {
+                        type: typeName,
+                        from: anchor.from,
+                        to: anchor.to,
+                        _ctrlPropXml: cpXml || undefined,
+                        _vmlShapeXml: vml?.shapeXml,
+                        _shapeId: vml?.shapeId,
+                    };
+                    if (cpRoot) {
+                        if (cpRoot.attrs['fmlaLink'])
+                            ctrl.linkedCell = cpRoot.attrs['fmlaLink'];
+                        if (cpRoot.attrs['fmlaRange'])
+                            ctrl.inputRange = cpRoot.attrs['fmlaRange'];
+                        if (cpRoot.attrs['checked'])
+                            ctrl.checked = (CHECKED_REV[cpRoot.attrs['checked']] ?? 'unchecked');
+                        if (cpRoot.attrs['dropLines'])
+                            ctrl.dropLines = parseInt(cpRoot.attrs['dropLines'], 10);
+                        if (cpRoot.attrs['min'])
+                            ctrl.min = parseInt(cpRoot.attrs['min'], 10);
+                        if (cpRoot.attrs['max'])
+                            ctrl.max = parseInt(cpRoot.attrs['max'], 10);
+                        if (cpRoot.attrs['inc'])
+                            ctrl.inc = parseInt(cpRoot.attrs['inc'], 10);
+                        if (cpRoot.attrs['page'])
+                            ctrl.page = parseInt(cpRoot.attrs['page'], 10);
+                        if (cpRoot.attrs['val'])
+                            ctrl.val = parseInt(cpRoot.attrs['val'], 10);
+                        if (cpRoot.attrs['selType']) {
+                            const selRev = { Single: 'single', Multi: 'multi', Extend: 'extend' };
+                            ctrl.selType = (selRev[cpRoot.attrs['selType']] ?? 'single');
+                        }
+                        if (cpRoot.attrs['noThreeD'] === '1')
+                            ctrl.noThreeD = true;
+                    }
+                    if (vml?.clientData) {
+                        const macroNode = vml.clientData.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'FmlaMacro');
+                        if (macroNode)
+                            ctrl.macro = macroNode.text ?? '';
+                    }
+                    ws.addFormControl(ctrl);
+                }
+                ws.legacyDrawingRId = legacyDrawingRId;
+                ws.ctrlPropRIds = ctrlPropRIds;
+            }
+        }
+        if (drawingRId) {
+            const sheetFileName = target.split('/').pop() ?? '';
+            const sheetDir = target.substring(0, target.lastIndexOf('/') + 1);
+            const sheetRelsPath = `${sheetDir}_rels/${sheetFileName}.rels`;
+            const sheetRels = allRels.get(sheetRelsPath);
+            if (sheetRels) {
+                const drawRel = sheetRels.get(drawingRId);
+                if (drawRel) {
+                    const drawPath = drawRel.target.startsWith('/')
+                        ? drawRel.target.slice(1)
+                        : resolvePath(sheetDir, drawRel.target);
+                    const drawXml = getText(drawPath);
+                    if (drawXml) {
+                        const drawDir = drawPath.substring(0, drawPath.lastIndexOf('/') + 1);
+                        const drawFileName = drawPath.split('/').pop() ?? '';
+                        const drawRelsPath = `${drawDir}_rels/${drawFileName}.rels`;
+                        const drawRels = allRels.get(drawRelsPath);
+                        parseDrawingObjects(drawXml, drawRels, drawDir, get, ws);
+                    }
+                }
+            }
+        }
+        if (vmCells.size > 0) {
+            parseCellImagesFromRichData(vmCells, getText, get, ws);
+        }
+        sheets.push({ ws, sheetId, rId, originalXml, unknownParts: sheetUnknown, tablePaths, tableXmls });
+    }
+    const connectionsXml = getText('xl/connections.xml') ?? '';
+    const connections = [];
+    if (connectionsXml) {
+        const connRoot = parseXml(connectionsXml);
+        for (const cn of children(connRoot, 'connection')) {
+            const id = parseInt(cn.attrs['id'] ?? '0', 10);
+            const name = cn.attrs['name'] ?? '';
+            const typeNum = parseInt(cn.attrs['type'] ?? '0', 10);
+            const type = connTypeFromNum(typeNum);
+            if (!name || !type)
+                continue;
+            const conn = { id, name, type };
+            if (cn.attrs['description'])
+                conn.description = cn.attrs['description'];
+            if (cn.attrs['refreshOnLoad'] === '1')
+                conn.refreshOnLoad = true;
+            if (cn.attrs['background'] === '1')
+                conn.background = true;
+            if (cn.attrs['saveData'] === '1')
+                conn.saveData = true;
+            if (cn.attrs['keepAlive'] === '1')
+                conn.keepAlive = true;
+            if (cn.attrs['interval'])
+                conn.interval = parseInt(cn.attrs['interval'], 10);
+            const dbPr = child(cn, 'dbPr');
+            if (dbPr) {
+                if (dbPr.attrs['connection'])
+                    conn.connectionString = dbPr.attrs['connection'];
+                if (dbPr.attrs['command'])
+                    conn.command = dbPr.attrs['command'];
+                if (dbPr.attrs['commandType'])
+                    conn.commandType = cmdTypeFromNum(parseInt(dbPr.attrs['commandType'], 10));
+            }
+            conn._rawXml = nodeToXml(cn);
+            connections.push(conn);
+        }
+    }
+    const powerQueries = [];
+    for (const [path, entry] of zip) {
+        if (!path.startsWith('customXml/item') || path.includes('Props') || path.includes('_rels'))
+            continue;
+        try {
+            const pqs = await parseDataMashup(entry.data);
+            if (pqs.length) {
+                powerQueries.push(...pqs);
+                break;
+            }
+        }
+        catch { }
     }
     const handledPrefixes = new Set([
         'xl/workbook.xml', 'xl/styles.xml', 'xl/sharedStrings.xml',
         'xl/worksheets/', 'docProps/', '[Content_Types].xml',
-        '_rels/', 'xl/_rels/',
+        '_rels/', 'xl/_rels/', 'xl/connections.xml',
     ]);
     const unknownParts = new Map();
     for (const [path, entry] of zip) {
@@ -643,12 +1921,100 @@ export async function readWorkbook(data) {
             unknownParts.set(path, entry.data);
         }
     }
+    const nonPrintAreaRanges = [];
+    for (const nr of namedRanges) {
+        if (nr.name === '_xlnm.Print_Area' && nr.scope) {
+            const ws = sheets.find(s => s.ws.name === nr.scope);
+            if (ws)
+                ws.ws.printArea = nr.ref;
+        }
+        else {
+            nonPrintAreaRanges.push(nr);
+        }
+    }
     return {
         sheets, styles, stylesXml, sharedStrings, sharedXml: ssXml,
         workbookXml: wbXml, workbookRels,
         contentTypes, contentTypesXml: ctXml,
         core, extended, extendedUnknownRaw, custom, hasCustomProps: custom.length > 0,
+        namedRanges: nonPrintAreaRanges, connections, connectionsXml, powerQueries,
         unknownParts, allRels,
     };
 }
+function parseVmlAnchor(clientData) {
+    const defaultAnchor = { from: { col: 0, row: 0 }, to: { col: 2, row: 2 } };
+    if (!clientData)
+        return defaultAnchor;
+    const anchorNode = clientData.children.find((c) => typeof c !== 'string' && localName(c.tag) === 'Anchor');
+    if (!anchorNode)
+        return defaultAnchor;
+    const text = anchorNode.text ?? '';
+    const parts = text.split(',').map(s => parseInt(s.trim(), 10));
+    if (parts.length < 8 || parts.some(isNaN))
+        return defaultAnchor;
+    return {
+        from: { col: parts[0], colOff: parts[1], row: parts[2], rowOff: parts[3] },
+        to: { col: parts[4], colOff: parts[5], row: parts[6], rowOff: parts[7] },
+    };
+}
+const CONN_TYPE_MAP = {
+    1: 'odbc', 2: 'dao', 3: 'file', 4: 'web', 5: 'oledb', 6: 'text', 7: 'dsp',
+};
+const CONN_TYPE_REV = Object.fromEntries(Object.entries(CONN_TYPE_MAP).map(([k, v]) => [v, Number(k)]));
+function connTypeFromNum(n) { return CONN_TYPE_MAP[n]; }
+export function connTypeToNum(t) { return CONN_TYPE_REV[t]; }
+const CMD_TYPE_MAP = {
+    1: 'sql', 2: 'table', 3: 'default', 4: 'web', 5: 'oledb',
+};
+const CMD_TYPE_REV = Object.fromEntries(Object.entries(CMD_TYPE_MAP).map(([k, v]) => [v, Number(k)]));
+function cmdTypeFromNum(n) { return CMD_TYPE_MAP[n]; }
+export function cmdTypeToNum(t) { return CMD_TYPE_REV[t]; }
+async function parseDataMashup(data) {
+    if (data.length < 12)
+        return [];
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const version = view.getUint32(0, true);
+    if (version !== 0)
+        return [];
+    const pkgLen = view.getUint32(4, true);
+    if (pkgLen < 4 || 8 + pkgLen > data.length)
+        return [];
+    const pkgBytes = data.subarray(8, 8 + pkgLen);
+    if (pkgBytes[0] !== 0x50 || pkgBytes[1] !== 0x4B)
+        return [];
+    const innerZip = await readZip(pkgBytes);
+    const queries = [];
+    for (const [path, entry] of innerZip) {
+        if (!path.includes('/Formula/') || !path.endsWith('.m'))
+            continue;
+        const formula = entryText(entry);
+        if (!formula)
+            continue;
+        const pathMatch = path.match(/Formulas\/([^/]+)\//);
+        const nameFromPath = pathMatch ? pathMatch[1] : undefined;
+        const sharedRe = /shared\s+(?:#"([^"]+)"|(\w+))\s*=/g;
+        let m;
+        const foundNames = new Set();
+        while ((m = sharedRe.exec(formula)) !== null) {
+            const qName = m[1] ?? m[2];
+            foundNames.add(qName);
+        }
+        if (foundNames.size > 0) {
+            const sectionRe = /shared\s+(?:#"([^"]+)"|(\w+))\s*=\s*([\s\S]*?)(?=,\s*shared\s|\]\s*$)/g;
+            let sm;
+            while ((sm = sectionRe.exec(formula)) !== null) {
+                const qName = sm[1] ?? sm[2];
+                const qFormula = sm[3].replace(/,\s*$/, '').trim();
+                queries.push({ name: qName, formula: qFormula });
+            }
+            if (queries.length === 0) {
+                queries.push({ name: nameFromPath ?? 'Section1', formula });
+            }
+        }
+        else if (nameFromPath) {
+            queries.push({ name: nameFromPath, formula });
+        }
+    }
+    return queries;
+}
 //# sourceMappingURL=WorkbookReader.js.map