@a3s-lab/office 0.1.0

package/dist/0~work-office-diagnostics.js

@@ -0,0 +1,1377 @@
+import { docxCaptionSequenceKind, docxFieldOccurrences, docxCaptionBookmark, docxCaptionReferenceTarget, docxFieldInstructions } from "./0~152.js";
+import { documentCitationTagsFromInstruction, docxDocumentFieldKind } from "./4704.js";
+import { contentTypeForPart, directChildren, formulaHasStructuredReference, OoxmlPackage, formulaHasExternalReference, firstDescendant, parseSpreadsheetPrintTitles, stripSpreadsheetSheetQualifier, descendants, directChild, attribute, volatileSpreadsheetFormulaFunctions } from "./8715.js";
+import { readDocxBibliography } from "./0~work-docx-bibliography.js";
+import { isSupportedXlsxCombinationChartNodes, MAX_XLSX_WORKSHEET_IMAGE_BYTES, inspectXlsxPivotTables, isSupportedXlsxWorksheetImageContentType, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, xlsxChartNodeUsesStackedGrouping, isSupportedXlsxChartSeriesFormatting, readXlsxFormulaFeaturesFromPackage, inspectXlsxHeaderFooterText, isEditableXlsxPaperSizeCode, diagnoseXlsxProtection, xlsxChartSeriesFormattingShapeProperties } from "./4104.js";
+import { spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalIconSetName, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconSetCount } from "./8728.js";
+import { unsupportedSpreadsheetFormulaFunctions } from "./0~work-spreadsheet-formula-support.js";
+function diagnoseDocxCaptions(document) {
+    const fields = docxFieldOccurrences(document);
+    const sequences = fields.filter((field)=>docxCaptionSequenceKind(field.instruction));
+    const bodyFields = fields.filter((field)=>docxDocumentFieldKind(field.instruction));
+    const bookmarkNames = captionBookmarkNames(sequences);
+    return {
+        issues: [
+            ...sequences.length ? [
+                {
+                    code: 'docx.captions',
+                    feature: 'Captions and cross-references',
+                    message: 'Figure and table SEQ fields, independent numbering, caption bookmarks, and caption REF fields are preserved, editable, and updated in native DOCX output.',
+                    severity: 'info'
+                }
+            ] : [],
+            ...bodyFields.length ? [
+                {
+                    code: 'docx.fields.body',
+                    feature: 'Body fields',
+                    message: 'PAGE, NUMPAGES, SECTION, SECTIONPAGES, DATE, and TIME fields remain live, editable body fields and update in preview, PDF, and native DOCX output.',
+                    severity: 'info'
+                }
+            ] : []
+        ],
+        hasUnsupportedFields: fields.some((field)=>!isSupportedCaptionField(field.instruction, bookmarkNames))
+    };
+}
+function captionBookmarkNames(fields) {
+    const names = new Set();
+    for (const field of fields){
+        const paragraph = closestAncestor(field.start, 'p');
+        if (!paragraph) continue;
+        const bookmark = docxCaptionBookmark(paragraph, field);
+        const name = attribute(bookmark ?? paragraph, 'name')?.trim();
+        if (name) names.add(name);
+    }
+    return names;
+}
+function isSupportedCaptionField(instruction, bookmarkNames) {
+    if (documentCitationTagsFromInstruction(instruction).length || /^\s*BIBLIOGRAPHY\b/i.test(instruction)) return true;
+    if (docxDocumentFieldKind(instruction)) return true;
+    if (docxCaptionSequenceKind(instruction)) return true;
+    const target = docxCaptionReferenceTarget(instruction);
+    return Boolean(target && bookmarkNames.has(target));
+}
+function closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+async function diagnoseDocxCitations(archive, document) {
+    const fields = docxFieldOccurrences(document);
+    const citationFields = fields.map((field)=>({
+            instruction: field.instruction,
+            tags: documentCitationTagsFromInstruction(field.instruction)
+        })).filter((field)=>field.tags.length);
+    const bibliographyFields = fields.filter((field)=>/^\s*BIBLIOGRAPHY\b/i.test(field.instruction));
+    const result = await readDocxBibliography(archive);
+    const sourceTags = new Set(result.bibliography?.sources.map((source)=>source.tag) ?? []);
+    const citedTags = Array.from(new Set(citationFields.flatMap((field)=>field.tags)));
+    const missingTags = citedTags.filter((tag)=>!sourceTags.has(tag));
+    const issues = [];
+    if (citationFields.length || result.bibliography?.sources.length) issues.push({
+        code: 'docx.citations',
+        feature: 'Citations and bibliography sources',
+        message: `${citationFields.length} citation field(s) and ${result.bibliography?.sources.length ?? 0} bibliography source(s) retain tags, authors, source metadata, style selection, cached display values, and native DOCX field/custom-XML structure.`,
+        severity: 'info'
+    });
+    if (bibliographyFields.length) issues.push({
+        code: 'docx.bibliography',
+        feature: 'Bibliography',
+        message: `${bibliographyFields.length} live bibliography field(s) remain editable and regenerate from the document source library.`,
+        severity: 'info'
+    });
+    if (missingTags.length) issues.push({
+        code: 'docx.citations.missing-source',
+        feature: 'Citations and bibliography sources',
+        message: `Citation source${1 === missingTags.length ? '' : 's'} ${missingTags.join(', ')} could not be found in a connected Word bibliography source part and will be shown as missing.`,
+        severity: 'warning'
+    });
+    if (result.unreadablePartCount) issues.push({
+        code: 'docx.citations.unreadable',
+        feature: 'Citations and bibliography sources',
+        message: `${result.unreadablePartCount} bibliography custom-XML part(s) could not be read and remain available only in the original file.`,
+        severity: 'warning'
+    });
+    if (result.duplicateTags.length) issues.push({
+        code: 'docx.citations.duplicate-tags',
+        feature: 'Citations and bibliography sources',
+        message: `Duplicate bibliography tags ${result.duplicateTags.join(', ')} are assigned unique editable tags during import.`,
+        severity: 'warning'
+    });
+    if (result.uncommonSourceTypes.length) issues.push({
+        code: 'docx.citations.source-types',
+        feature: 'Citations and bibliography sources',
+        message: `Uncommon source type${1 === result.uncommonSourceTypes.length ? '' : 's'} ${result.uncommonSourceTypes.join(', ')} retain their original type and additional metadata; the editor exposes the common source fields directly.`,
+        severity: 'info'
+    });
+    if (result.uncommonStyle) issues.push({
+        code: 'docx.citations.style',
+        feature: 'Citations and bibliography sources',
+        message: `Citation style ${result.uncommonStyle} is retained for DOCX output; Work preview uses its editable APA fallback until a supported APA, MLA, Chicago, or IEEE style is selected.`,
+        severity: 'warning'
+    });
+    return issues;
+}
+async function diagnoseDocxNotes(archive, document) {
+    const noteParts = [
+        'word/footnotes.xml',
+        'word/endnotes.xml'
+    ].filter((part)=>archive.has(part));
+    const noteDocuments = await Promise.all(noteParts.map((part)=>archive.xml(part)));
+    const hasNotes = Boolean(document && (descendants(document, 'footnoteReference').length || descendants(document, 'endnoteReference').length)) || noteDocuments.some((notes)=>[
+            ...descendants(notes, 'footnote'),
+            ...descendants(notes, 'endnote')
+        ].some((note)=>Number(attribute(note, 'id')) > 0));
+    if (!hasNotes) return [];
+    const issues = [
+        noteIssue('docx.notes', 'Footnote and endnote references, editable note text, common inline formatting, preview placement, and native DOCX note parts are preserved.', 'info')
+    ];
+    if (noteDocuments.some((notes)=>descendants(notes, 'tbl').length > 0 || descendants(notes, 'drawing').length > 0 || descendants(notes, 'pict').length > 0)) issues.push(noteIssue('docx.notes.rich-content', 'Tables, drawings, and embedded media inside notes may be flattened or converted to inline content.'));
+    const settings = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const noteProperties = [
+        ...document ? descendants(document, 'footnotePr') : [],
+        ...document ? descendants(document, 'endnotePr') : [],
+        ...settings ? descendants(settings, 'footnotePr') : [],
+        ...settings ? descendants(settings, 'endnotePr') : []
+    ];
+    if (noteProperties.some((properties)=>directChildren(properties).length > 0)) issues.push(noteIssue('docx.notes.numbering', 'Custom note symbols, numbering formats, restart rules, separators, and placement settings normalize to continuous Arabic numbering with footnotes per page and endnotes at document end.'));
+    return issues;
+}
+function noteIssue(code, message, severity = 'warning') {
+    return {
+        code,
+        feature: 'Footnotes and endnotes',
+        message,
+        severity
+    };
+}
+const PAGE_FIELD = /^\s*PAGE(?:\s|\\|$)/i;
+const ADVANCED_POSITIONING = new Set([
+    'anchor',
+    'framePr',
+    'ind',
+    'pict',
+    'positionH',
+    'positionV',
+    'simplePos',
+    'tabs',
+    'tblpPr',
+    'txbxContent',
+    'wrapNone',
+    'wrapSquare',
+    'wrapThrough',
+    'wrapTight',
+    'wrapTopAndBottom'
+]);
+async function diagnoseDocxPageChrome(archive) {
+    const parts = [
+        ...archive.paths('word/header'),
+        ...archive.paths('word/footer')
+    ].filter((path)=>path.endsWith('.xml'));
+    if (!parts.length) return [];
+    const documents = await Promise.all(parts.map(async (path)=>({
+            path,
+            document: await archive.xml(path)
+        })));
+    const issues = [
+        pageChromeIssue('docx.headers', 'Rich default, first-page, and even-page headers and footers, common formatting, tables, links, inline raster images, and PAGE numbering are preserved, editable, and used by preview, PDF, and native DOCX output.', 'info')
+    ];
+    const instructions = documents.flatMap(({ document })=>docxFieldInstructions(document));
+    if (instructions.some((instruction)=>!PAGE_FIELD.test(instruction))) issues.push(pageChromeIssue('docx.headers.fields', 'PAGE numbering is preserved. Other header/footer field codes are flattened to their current displayed text and no longer update automatically.'));
+    if (documents.some(({ path, document })=>path.startsWith('word/header') && docxFieldInstructions(document).some((instruction)=>PAGE_FIELD.test(instruction)))) issues.push(pageChromeIssue('docx.headers.page-field-position', "PAGE fields placed in a header are preserved through Work's centered footer page-number slot."));
+    if (documents.some(({ document })=>descendants(document, 'sdt').length > 0)) issues.push(pageChromeIssue('docx.headers.content-controls', 'Header/footer content controls are flattened to editable content; bindings, locking, and repeating behavior are not preserved.'));
+    if (documents.some(({ document })=>Array.from(document.querySelectorAll('*')).some((element)=>ADVANCED_POSITIONING.has(element.localName)))) issues.push(pageChromeIssue('docx.headers.positioning', 'Floating drawings, text boxes, tab stops, indents, and advanced header/footer positioning are normalized to inline flow.'));
+    return issues;
+}
+function pageChromeIssue(code, message, severity = 'warning') {
+    return {
+        code,
+        feature: 'Headers and footers',
+        message,
+        severity
+    };
+}
+const SUPPORTED_CHART_ELEMENTS = new Set([
+    'barChart',
+    'lineChart',
+    'pieChart',
+    'doughnutChart',
+    'areaChart',
+    'radarChart',
+    'scatterChart',
+    'bubbleChart'
+]);
+const TRENDLINE_CHART_ELEMENTS = new Set([
+    'barChart',
+    'lineChart',
+    'areaChart',
+    'scatterChart',
+    'bubbleChart'
+]);
+const ERROR_BAR_CHART_ELEMENTS = new Set([
+    'barChart',
+    'lineChart',
+    'areaChart',
+    'scatterChart',
+    'bubbleChart'
+]);
+const ERROR_BAR_VALUE_TYPES = new Set([
+    'cust',
+    'fixedVal',
+    'percentage',
+    'stdDev',
+    'stdErr'
+]);
+const ERROR_BAR_CHILDREN = new Set([
+    'errDir',
+    'errBarType',
+    'errValType',
+    'noEndCap',
+    'plus',
+    'minus',
+    'val'
+]);
+const SUPPORTED_TRENDLINE_TYPES = new Set([
+    'exp',
+    'linear',
+    'log',
+    'movingAvg',
+    'poly',
+    'power'
+]);
+const SUPPORTED_TRENDLINE_CHILDREN = new Set([
+    'name',
+    'spPr',
+    'trendlineType',
+    'order',
+    'period',
+    'forward',
+    'backward',
+    'intercept',
+    'dispRSq',
+    'dispEq',
+    'trendlineLbl'
+]);
+const SUPPORTED_DATA_LABEL_CHILDREN = new Set([
+    'delete',
+    'spPr',
+    'txPr',
+    'dLblPos',
+    'showLegendKey',
+    'showVal',
+    'showCatName',
+    'showSerName',
+    'showPercent',
+    'showBubbleSize',
+    'separator',
+    'showLeaderLines'
+]);
+const SUPPORTED_DATA_LABEL_POSITIONS = new Set([
+    'bestFit',
+    'b',
+    'ctr',
+    'inBase',
+    'inEnd',
+    'l',
+    'outEnd',
+    'r',
+    't'
+]);
+async function diagnoseXlsxCharts(archive) {
+    const chartPaths = archive.paths('xl/charts/').filter((path)=>/^xl\/charts\/chart\d+\.xml$/i.test(path));
+    if (!chartPaths.length) return [];
+    const anchoredPaths = await anchoredChartPaths(archive);
+    let supported = 0;
+    let unsupportedTypes = 0;
+    let combinations = 0;
+    let trendlines = 0;
+    let errorBars = 0;
+    let dataLabels = 0;
+    let advancedFormatting = 0;
+    let advancedPlotLayout = 0;
+    let unsupportedLegends = 0;
+    let advancedAxes = 0;
+    let axisTitles = 0;
+    let axisSettings = 0;
+    let categoryAxisSettings = 0;
+    let unsupportedReferences = 0;
+    let externalData = 0;
+    for (const path of chartPaths){
+        const chart = await archive.xml(path);
+        const plotArea = firstDescendant(chart, 'plotArea');
+        const chartNodes = plotArea ? directChildren(plotArea).filter((element)=>/Chart$/i.test(element.localName)) : [];
+        const supportedCombination = isSupportedXlsxCombinationChartNodes(chartNodes);
+        if (chartNodes.length > 1 && !supportedCombination) combinations += 1;
+        if ((1 === chartNodes.length && SUPPORTED_CHART_ELEMENTS.has(chartNodes[0].localName) || supportedCombination) && anchoredPaths.has(path)) supported += 1;
+        else unsupportedTypes += 1;
+        trendlines += unsupportedTrendlineCount(chartNodes);
+        errorBars += unsupportedErrorBarCount(chartNodes);
+        dataLabels += unsupportedDataLabelCount(chartNodes);
+        if (hasAdvancedChartFormatting(chart, chartNodes)) advancedFormatting += 1;
+        if (chartNodes.some((node)=>!isSupportedXlsxChartPlotLayout(node))) advancedPlotLayout += 1;
+        if (!isSupportedXlsxChartLegend(chart)) unsupportedLegends += 1;
+        if (hasAdvancedAxes(chart, chartNodes)) advancedAxes += 1;
+        axisTitles += unsupportedAxisTitleCount(chart, chartNodes);
+        axisSettings += unsupportedValueAxisSettingsCount(chart);
+        categoryAxisSettings += unsupportedCategoryAxisSettingsCount(chart);
+        if (descendants(chart, 'multiLvlStrRef').length || descendants(chart, 'f').some((formula)=>!isSupportedChartReference(formula.textContent ?? ''))) unsupportedReferences += 1;
+        if (descendants(chart, 'externalData').length) externalData += 1;
+    }
+    const issues = [];
+    if (supported) issues.push(issue('xlsx.charts', `${supported} anchored column, bar, line, pie, doughnut, area, radar, scatter, bubble, or column/line/area combination chart(s), cached data, live cell references, simple series fills, transparency, lines, dashes, and markers, data labels, error bars, trendlines, chart and axis titles, axis order, label positions, major tick marks, category-label intervals, value-axis bounds, major units, major gridlines, number formats, legend positions and overlay, grouping, stacking, plot spacing, smoothing, names, alternative text, positions, sizes, and supported primary or secondary axes are preserved and editable.`, 'info'));
+    if (unsupportedTypes) issues.push(issue('xlsx.charts.unsupported-type', `${unsupportedTypes} unsupported, unanchored, 3D, stock, surface, or other chart part(s) cannot be edited and will not be included in a regenerated XLSX.`));
+    if (combinations) issues.push(issue('xlsx.charts.combination', `${combinations} combination chart(s) include unsupported plot families or axis layouts; Work does not flatten them into a misleading editable chart.`));
+    if (trendlines) issues.push(issue('xlsx.charts.trendline', `${trendlines} trendline(s) use an unsupported chart family, type, parameter, extension, or manual label setting and cannot be represented exactly by the editable chart model.`));
+    if (errorBars) issues.push(issue('xlsx.charts.error-bars', `${errorBars} error-bar setting(s) use an unsupported chart family, direction, type, value, custom range, duplicate direction, formatting, or extension and cannot be represented exactly by the editable chart model.`));
+    if (dataLabels) issues.push(issue('xlsx.charts.data-labels', `${dataLabels} data-label setting(s) use per-point overrides, legend keys, number formats, leader lines, extensions, invalid values, or chart-specific content that cannot be represented exactly by the editable chart model.`));
+    if (advancedAxes) issues.push(issue('xlsx.charts.axes', `${advancedAxes} chart(s) use date, series, or additional axes beyond the supported category/value and one-primary/one-secondary combination layouts.`));
+    if (axisTitles) issues.push(issue('xlsx.charts.axis-titles', `${axisTitles} axis-title setting(s) use an unsupported axis position, duplicate title, manual layout, overlay, rich-text structure, field, line break, or extension and cannot be represented exactly by the editable chart model.`));
+    if (axisSettings) issues.push(issue('xlsx.charts.axis-settings', `${axisSettings} value-axis setting(s) use a logarithmic scale, invalid bounds or major unit, minor unit or gridlines, display units, unsupported crossing or minor ticks, malformed label or major-tick placement, malformed number format, or extension that cannot be represented exactly by the editable chart model.`));
+    if (categoryAxisSettings) issues.push(issue('xlsx.charts.category-axis-settings', `${categoryAxisSettings} category-axis setting(s) use an invalid orientation, label position, major tick, label interval, tick interval, alignment, offset, crossing, number format, extension, or another setting that cannot be represented exactly by the editable chart model.`));
+    if (unsupportedLegends) issues.push(issue('xlsx.charts.legend', `${unsupportedLegends} chart(s) use a manual legend layout, per-entry override, invalid position or overlay, formatting, extension, or duplicate legend setting that cannot be represented exactly by the editable chart model.`));
+    if (advancedPlotLayout) issues.push(issue('xlsx.charts.layout', `${advancedPlotLayout} chart(s) use an invalid grouping, gap, overlap, mixed per-series smoothing, 3D bubble layout, explosion, slice rotation, unsupported combination layout, or another plot setting that cannot be represented exactly by the editable chart model.`));
+    if (unsupportedReferences) issues.push(issue('xlsx.charts.references', `${unsupportedReferences} chart(s) use external, named, multi-level, union, or otherwise unsupported data references; only cached values can be previewed where available.`));
+    if (externalData) issues.push(issue('xlsx.charts.external-data', `${externalData} chart(s) reference an embedded or external workbook; Work uses worksheet references and cached values without refreshing external data.`));
+    if (advancedFormatting && supported) issues.push(issue('xlsx.charts.format', `${advancedFormatting} chart(s) contain theme, label, fill, line, effect, wall, or other advanced formatting that is normalized to the Work chart style on export.`));
+    return issues;
+}
+async function anchoredChartPaths(archive) {
+    const paths = new Set();
+    const drawings = archive.paths('xl/drawings/').filter((path)=>/^xl\/drawings\/drawing\d+\.xml$/i.test(path));
+    for (const path of drawings){
+        const document = await archive.xml(path);
+        const relationships = await archive.relationships(path);
+        for (const frame of descendants(document, 'graphicFrame')){
+            const reference = firstDescendant(frame, 'chart');
+            const relationshipId = reference ? attribute(reference, 'r:id') ?? attribute(reference, 'id') : null;
+            const relationship = relationshipId ? relationships.get(relationshipId) : void 0;
+            if (relationship && 'External' !== relationship.targetMode && relationship.type.endsWith('/chart') && archive.has(relationship.target)) paths.add(relationship.target);
+        }
+    }
+    return paths;
+}
+function hasAdvancedChartFormatting(document, chartNodes) {
+    if ([
+        'upDownBars',
+        'pictureOptions',
+        'view3D',
+        'floor',
+        'sideWall',
+        'backWall'
+    ].some((name)=>descendants(document, name).length > 0) || descendants(document, 'txPr').length > 0 || descendants(document, 'style').length > 0) return true;
+    const supportedShapeProperties = new Set();
+    for (const chart of chartNodes)for (const series of directChildren(chart, 'ser')){
+        if (!isSupportedXlsxChartSeriesFormatting(series, chart.localName)) return true;
+        for (const shape of xlsxChartSeriesFormattingShapeProperties(series))supportedShapeProperties.add(shape);
+    }
+    return descendants(document, 'spPr').some((shape)=>!supportedShapeProperties.has(shape));
+}
+function isSupportedChartReference(value) {
+    const formula = value.trim().replace(/^=/, '');
+    if (formula.includes('[') || formula.includes(']')) return false;
+    return /^(?:(?:'(?:(?:[^']|'')+)'|[^!]+)!)?\$?[A-Z]{1,3}\$?[1-9]\d*(?::\$?[A-Z]{1,3}\$?[1-9]\d*)?$/i.test(formula);
+}
+function unsupportedTrendlineCount(chartNodes) {
+    return chartNodes.reduce((count, chart)=>{
+        const supportsTrendlines = TRENDLINE_CHART_ELEMENTS.has(chart.localName) && !xlsxChartNodeUsesStackedGrouping(chart);
+        const trendlines = directChildren(chart, 'ser').flatMap((series)=>directChildren(series, 'trendline'));
+        return count + trendlines.filter((trendline)=>!supportsTrendlines || !isSupportedTrendline(trendline)).length;
+    }, 0);
+}
+function unsupportedDataLabelCount(chartNodes) {
+    return chartNodes.reduce((count, chart)=>{
+        const dataLabels = [
+            ...directChildren(chart, 'dLbls'),
+            ...directChildren(chart, 'ser').flatMap((series)=>directChildren(series, 'dLbls'))
+        ];
+        return count + dataLabels.filter((labels)=>!isSupportedDataLabels(labels, chart.localName)).length;
+    }, 0);
+}
+function unsupportedErrorBarCount(chartNodes) {
+    return chartNodes.reduce((count, chart)=>{
+        const supportsErrorBars = ERROR_BAR_CHART_ELEMENTS.has(chart.localName) && !xlsxChartNodeUsesStackedGrouping(chart);
+        const seriesNodes = directChildren(chart, 'ser');
+        const directErrorBars = seriesNodes.flatMap((series)=>directChildren(series, 'errBars'));
+        const misplacedErrorBars = Math.max(0, descendants(chart, 'errBars').length - directErrorBars.length);
+        const unsupported = seriesNodes.reduce((seriesCount, series)=>{
+            const directions = new Set();
+            return seriesCount + directChildren(series, 'errBars').filter((errorBars)=>{
+                const direction = errorBarDirection(errorBars);
+                const duplicateDirection = Boolean(direction && directions.has(direction));
+                if (direction) directions.add(direction);
+                return duplicateDirection || !supportsErrorBars || !isSupportedErrorBars(errorBars, chart.localName);
+            }).length;
+        }, 0);
+        return count + misplacedErrorBars + unsupported;
+    }, 0);
+}
+function isSupportedErrorBars(errorBars, chartLocalName) {
+    const children = directChildren(errorBars);
+    if (children.some((child)=>!ERROR_BAR_CHILDREN.has(child.localName))) return false;
+    const direction = errorBarDirection(errorBars);
+    if (!direction) return false;
+    if ('x' === direction && 'scatterChart' !== chartLocalName && 'bubbleChart' !== chartLocalName) return false;
+    const barTypeElements = directChildren(errorBars, 'errBarType');
+    if (1 !== barTypeElements.length) return false;
+    const barType = attribute(barTypeElements[0], 'val');
+    if ('both' !== barType && 'plus' !== barType && 'minus' !== barType) return false;
+    const valueTypeElements = directChildren(errorBars, 'errValType');
+    if (1 !== valueTypeElements.length) return false;
+    const valueType = attribute(valueTypeElements[0], 'val');
+    if (!valueType || !ERROR_BAR_VALUE_TYPES.has(valueType)) return false;
+    if (!validOptionalBooleanAttribute(errorBars, 'noEndCap')) return false;
+    const values = directChildren(errorBars, 'val');
+    if (values.length > 1) return false;
+    const usesScalarValue = 'fixedVal' === valueType || 'percentage' === valueType || 'stdDev' === valueType;
+    if (values.length && (!usesScalarValue || !validNonNegativeNumberAttribute(values[0]))) return false;
+    const plus = directChildren(errorBars, 'plus');
+    const minus = directChildren(errorBars, 'minus');
+    if (plus.length > 1 || minus.length > 1) return false;
+    if ('cust' !== valueType) return 0 === plus.length && 0 === minus.length;
+    if (values.length) return false;
+    if ('minus' !== barType && (1 !== plus.length || !isSupportedErrorBarSource(plus[0]))) return false;
+    if ('minus' === barType && plus.length) return false;
+    if ('plus' !== barType && (1 !== minus.length || !isSupportedErrorBarSource(minus[0]))) return false;
+    return 'plus' !== barType || 0 === minus.length;
+}
+function errorBarDirection(errorBars) {
+    const elements = directChildren(errorBars, 'errDir');
+    if (1 !== elements.length) return null;
+    const direction = attribute(elements[0], 'val');
+    return 'x' === direction || 'y' === direction ? direction : null;
+}
+function isSupportedErrorBarSource(source) {
+    const children = directChildren(source);
+    if (1 !== children.length || 'numRef' !== children[0].localName && 'numLit' !== children[0].localName) return false;
+    const data = children[0];
+    if ('numRef' === data.localName) {
+        const dataChildren = directChildren(data);
+        if (dataChildren.some((child)=>'f' !== child.localName && 'numCache' !== child.localName)) return false;
+        const formulas = directChildren(data, 'f');
+        const caches = directChildren(data, 'numCache');
+        if (1 !== formulas.length || caches.length > 1 || !isSupportedChartReference(formulas[0].textContent ?? '')) return false;
+        return !caches.length || isSupportedErrorBarNumberCache(caches[0], false);
+    }
+    return isSupportedErrorBarNumberCache(data, true);
+}
+function isSupportedErrorBarNumberCache(cache, requireValues) {
+    const children = directChildren(cache);
+    if (children.some((child)=>![
+            'formatCode',
+            'ptCount',
+            'pt'
+        ].includes(child.localName))) return false;
+    if (directChildren(cache, 'formatCode').length > 1 || directChildren(cache, 'ptCount').length > 1) return false;
+    const points = directChildren(cache, 'pt');
+    if (requireValues && !points.length) return false;
+    const indexes = new Set();
+    for (const point of points){
+        const index = Number(attribute(point, 'idx'));
+        const values = directChildren(point, 'v');
+        if (!Number.isInteger(index) || index < 0 || indexes.has(index) || 1 !== values.length) return false;
+        indexes.add(index);
+        const value = Number(values[0].textContent);
+        if (!Number.isFinite(value) || value < 0) return false;
+    }
+    const pointCounts = directChildren(cache, 'ptCount');
+    if (!pointCounts.length) return true;
+    const pointCount = Number(attribute(pointCounts[0], 'val'));
+    return Number.isInteger(pointCount) && pointCount >= points.length;
+}
+function validNonNegativeNumberAttribute(element) {
+    const raw = attribute(element, 'val');
+    const value = null === raw || '' === raw.trim() ? NaN : Number(raw);
+    return Number.isFinite(value) && value >= 0;
+}
+function isSupportedDataLabels(labels, chartLocalName) {
+    const children = directChildren(labels);
+    if (children.some((child)=>!SUPPORTED_DATA_LABEL_CHILDREN.has(child.localName))) return false;
+    if ([
+        'spPr',
+        'txPr',
+        'separator'
+    ].some((name)=>directChildren(labels, name).length > 1)) return false;
+    const positions = directChildren(labels, 'dLblPos');
+    if (positions.length > 1 || 1 === positions.length && !SUPPORTED_DATA_LABEL_POSITIONS.has(attribute(positions[0], 'val') ?? '')) return false;
+    const booleanNames = [
+        'delete',
+        'showLegendKey',
+        'showVal',
+        'showCatName',
+        'showSerName',
+        'showPercent',
+        'showBubbleSize',
+        'showLeaderLines'
+    ];
+    if (booleanNames.some((name)=>!validOptionalBooleanAttribute(labels, name))) return false;
+    if (booleanElementIsTrue(labels, 'showLegendKey') || booleanElementIsTrue(labels, 'showLeaderLines')) return false;
+    if (booleanElementIsTrue(labels, 'showPercent') && 'pieChart' !== chartLocalName && 'doughnutChart' !== chartLocalName) return false;
+    return !booleanElementIsTrue(labels, 'showBubbleSize') || 'bubbleChart' === chartLocalName;
+}
+function booleanElementIsTrue(parent, localName) {
+    const element = directChildren(parent, localName)[0];
+    if (!element) return false;
+    const value = attribute(element, 'val');
+    return null === value || '1' === value || 'true' === value;
+}
+function isSupportedTrendline(trendline) {
+    const children = directChildren(trendline);
+    if (children.some((child)=>!SUPPORTED_TRENDLINE_CHILDREN.has(child.localName))) return false;
+    if (directChildren(trendline, 'name').length > 1 || directChildren(trendline, 'spPr').length > 1) return false;
+    const typeElements = directChildren(trendline, 'trendlineType');
+    if (1 !== typeElements.length) return false;
+    const type = attribute(typeElements[0], 'val');
+    if (!type || !SUPPORTED_TRENDLINE_TYPES.has(type)) return false;
+    const order = directChildren(trendline, 'order');
+    if ('poly' === type) {
+        if (1 !== order.length || !validIntegerAttribute(order[0], 2, 6)) return false;
+    } else if (order.length) return false;
+    const period = directChildren(trendline, 'period');
+    if ('movingAvg' === type) {
+        if (1 !== period.length || !validIntegerAttribute(period[0], 2, 255)) return false;
+    } else if (period.length) return false;
+    if (!validOptionalNumberAttribute(trendline, 'forward', (value)=>value >= 0)) return false;
+    if (!validOptionalNumberAttribute(trendline, 'backward', (value)=>value >= 0)) return false;
+    if (!validOptionalNumberAttribute(trendline, 'intercept', ()=>true)) return false;
+    if (!validOptionalBooleanAttribute(trendline, 'dispEq')) return false;
+    if (!validOptionalBooleanAttribute(trendline, 'dispRSq')) return false;
+    const labels = directChildren(trendline, 'trendlineLbl');
+    if (labels.length > 1) return false;
+    return !labels.some((label)=>[
+            'manualLayout',
+            'tx',
+            'numFmt'
+        ].some((name)=>descendants(label, name).length > 0));
+}
+function validIntegerAttribute(element, minimum, maximum) {
+    const value = Number(attribute(element, 'val'));
+    return Number.isInteger(value) && value >= minimum && value <= maximum;
+}
+function validOptionalNumberAttribute(parent, localName, predicate) {
+    const elements = directChildren(parent, localName);
+    if (elements.length > 1) return false;
+    if (!elements.length) return true;
+    const raw = attribute(elements[0], 'val');
+    const value = null === raw || '' === raw.trim() ? NaN : Number(raw);
+    return Number.isFinite(value) && predicate(value);
+}
+function validOptionalBooleanAttribute(parent, localName) {
+    const elements = directChildren(parent, localName);
+    if (elements.length > 1) return false;
+    if (!elements.length) return true;
+    const value = attribute(elements[0], 'val');
+    return null === value || [
+        '0',
+        '1',
+        'false',
+        'true'
+    ].includes(value);
+}
+function hasAdvancedAxes(document, chartNodes) {
+    if (descendants(document, 'serAx').length || descendants(document, 'dateAx').length) return true;
+    const valueAxes = descendants(document, 'valAx').length;
+    const categoryAxes = descendants(document, 'catAx').length;
+    if (isSupportedXlsxCombinationChartNodes(chartNodes)) return valueAxes > 2 || categoryAxes > 2;
+    const chartType = 1 === chartNodes.length ? chartNodes[0].localName : '';
+    const expectedValueAxes = 'scatterChart' === chartType || 'bubbleChart' === chartType ? 2 : 'pieChart' === chartType || 'doughnutChart' === chartType ? 0 : 1;
+    const expectedCategoryAxes = 'scatterChart' === chartType || 'bubbleChart' === chartType || 'pieChart' === chartType || 'doughnutChart' === chartType ? 0 : 1;
+    return valueAxes > expectedValueAxes || categoryAxes > expectedCategoryAxes;
+}
+function unsupportedAxisTitleCount(document, chartNodes) {
+    const plotArea = firstDescendant(document, 'plotArea');
+    if (!plotArea) return 0;
+    const axes = directChildren(plotArea).filter((axis)=>[
+            'catAx',
+            'valAx',
+            'serAx'
+        ].includes(axis.localName));
+    const supportedCombination = isSupportedXlsxCombinationChartNodes(chartNodes);
+    const chartType = 1 === chartNodes.length ? chartNodes[0].localName : '';
+    const supportsAxisTitles = supportedCombination || SUPPORTED_CHART_ELEMENTS.has(chartType) && 'pieChart' !== chartType && 'doughnutChart' !== chartType;
+    const supportsSecondaryTitles = supportedCombination;
+    const positions = new Set();
+    return axes.reduce((count, axis)=>{
+        const titles = directChildren(axis, 'title');
+        if (!titles.length) return count;
+        const positionElements = directChildren(axis, 'axPos');
+        const position = 1 === positionElements.length ? attribute(positionElements[0], 'val') : null;
+        const positionSupported = 'b' === position || 'l' === position || supportsSecondaryTitles && ('t' === position || 'r' === position);
+        const duplicatePosition = Boolean(position && positions.has(position));
+        if (position) positions.add(position);
+        const supported = supportsAxisTitles && 'serAx' !== axis.localName && 1 === titles.length && positionSupported && !duplicatePosition && isSupportedAxisTitle(titles[0]);
+        return count + (supported ? 0 : titles.length);
+    }, 0);
+}
+function unsupportedValueAxisSettingsCount(document) {
+    const plotArea = firstDescendant(document, 'plotArea');
+    if (!plotArea) return 0;
+    const hasCategoryAxes = directChildren(plotArea, 'catAx').length > 0;
+    return directChildren(plotArea, 'valAx').filter((axis)=>!isSupportedValueAxisSettings(axis, hasCategoryAxes)).length;
+}
+function isSupportedValueAxisSettings(axis, hasCategoryAxes) {
+    const scaling = directChildren(axis, 'scaling');
+    if (scaling.length > 1) return false;
+    if (1 === scaling.length) {
+        const children = directChildren(scaling[0]);
+        if (children.some((child)=>![
+                'orientation',
+                'max',
+                'min'
+            ].includes(child.localName))) return false;
+        const orientation = directChildren(scaling[0], 'orientation');
+        if (orientation.length > 1 || orientation.some((item)=>![
+                'minMax',
+                'maxMin'
+            ].includes(attribute(item, 'val') ?? ''))) return false;
+        const minimum = axisSettingNumber(scaling[0], 'min');
+        const maximum = axisSettingNumber(scaling[0], 'max');
+        if (!minimum.valid || !maximum.valid) return false;
+        if (void 0 !== minimum.value && void 0 !== maximum.value && minimum.value >= maximum.value) return false;
+    }
+    const majorUnit = axisSettingNumber(axis, 'majorUnit');
+    if (!majorUnit.valid || void 0 !== majorUnit.value && majorUnit.value <= 0) return false;
+    if (directChildren(axis, 'majorGridlines').length > 1) return false;
+    if ([
+        'minorUnit',
+        'minorGridlines',
+        'dispUnits',
+        'crossAt',
+        'extLst'
+    ].some((name)=>directChildren(axis, name).length > 0)) return false;
+    const majorTicks = directChildren(axis, 'majorTickMark');
+    if (majorTicks.length > 1 || majorTicks.some((tick)=>![
+            'none',
+            'in',
+            'out',
+            'cross'
+        ].includes(attribute(tick, 'val') ?? ''))) return false;
+    const minorTicks = directChildren(axis, 'minorTickMark');
+    if (minorTicks.length > 1 || minorTicks.some((tick)=>'none' !== attribute(tick, 'val'))) return false;
+    const tickLabelPositions = directChildren(axis, 'tickLblPos');
+    if (tickLabelPositions.length > 1 || tickLabelPositions.some((position)=>![
+            'nextTo',
+            'high',
+            'low',
+            'none'
+        ].includes(attribute(position, 'val') ?? ''))) return false;
+    const crosses = directChildren(axis, 'crosses');
+    const axisPosition = attribute(directChildren(axis, 'axPos')[0] ?? axis, 'val');
+    if (crosses.length > 1) return false;
+    if (crosses.some((crossing)=>{
+        const value = attribute(crossing, 'val');
+        return 'autoZero' !== value && !('max' === value && 'r' === axisPosition);
+    })) return false;
+    const crossBetween = directChildren(axis, 'crossBetween');
+    const expectedCrossBetween = hasCategoryAxes ? 'between' : 'midCat';
+    if (crossBetween.length > 1 || crossBetween.some((crossing)=>attribute(crossing, 'val') !== expectedCrossBetween)) return false;
+    const deletion = directChildren(axis, 'delete');
+    if (deletion.length > 1 || deletion.some(booleanAttributeIsTrue)) return false;
+    const numberFormats = directChildren(axis, 'numFmt');
+    if (numberFormats.length > 1) return false;
+    if (1 === numberFormats.length) {
+        const formatCode = attribute(numberFormats[0], 'formatCode');
+        const sourceLinked = attribute(numberFormats[0], 'sourceLinked');
+        if (!formatCode?.trim() || formatCode.length > 255 || !sourceLinked || ![
+            '0',
+            '1',
+            'false',
+            'true'
+        ].includes(sourceLinked)) return false;
+    }
+    return true;
+}
+function unsupportedCategoryAxisSettingsCount(document) {
+    const plotArea = firstDescendant(document, 'plotArea');
+    if (!plotArea) return 0;
+    return directChildren(plotArea, 'catAx').filter((axis)=>!isSupportedCategoryAxisSettings(axis)).length;
+}
+function isSupportedCategoryAxisSettings(axis) {
+    const scaling = directChildren(axis, 'scaling');
+    if (scaling.length > 1) return false;
+    if (1 === scaling.length) {
+        const children = directChildren(scaling[0]);
+        if (children.some((child)=>'orientation' !== child.localName)) return false;
+        const orientations = directChildren(scaling[0], 'orientation');
+        if (orientations.length > 1 || orientations.some((item)=>![
+                'minMax',
+                'maxMin'
+            ].includes(attribute(item, 'val') ?? ''))) return false;
+    }
+    const majorTicks = directChildren(axis, 'majorTickMark');
+    if (majorTicks.length > 1 || majorTicks.some((tick)=>![
+            'none',
+            'in',
+            'out',
+            'cross'
+        ].includes(attribute(tick, 'val') ?? ''))) return false;
+    const minorTicks = directChildren(axis, 'minorTickMark');
+    if (minorTicks.length > 1 || minorTicks.some((tick)=>'none' !== attribute(tick, 'val'))) return false;
+    const labelPositions = directChildren(axis, 'tickLblPos');
+    if (labelPositions.length > 1 || labelPositions.some((item)=>![
+            'nextTo',
+            'high',
+            'low',
+            'none'
+        ].includes(attribute(item, 'val') ?? ''))) return false;
+    const labelIntervals = directChildren(axis, 'tickLblSkip');
+    if (labelIntervals.length > 1 || labelIntervals.some((item)=>!validIntegerAttribute(item, 1, 31999))) return false;
+    if ([
+        'tickMarkSkip',
+        'numFmt',
+        'majorGridlines',
+        'minorGridlines',
+        'crossAt',
+        'noMultiLvlLbl',
+        'extLst'
+    ].some((name)=>directChildren(axis, name).length > 0)) return false;
+    const crosses = directChildren(axis, 'crosses');
+    const axisPosition = attribute(directChildren(axis, 'axPos')[0] ?? axis, 'val');
+    if (crosses.length > 1) return false;
+    if (crosses.some((item)=>{
+        const value = attribute(item, 'val');
+        return 'autoZero' !== value && !('max' === value && 't' === axisPosition);
+    })) return false;
+    const auto = directChildren(axis, 'auto');
+    if (auto.length > 1 || auto.some((item)=>!booleanAttributeIsTrue(item))) return false;
+    const alignments = directChildren(axis, 'lblAlgn');
+    if (alignments.length > 1 || alignments.some((item)=>'ctr' !== attribute(item, 'val'))) return false;
+    const offsets = directChildren(axis, 'lblOffset');
+    if (offsets.length > 1 || offsets.some((item)=>'100' !== attribute(item, 'val'))) return false;
+    const deletion = directChildren(axis, 'delete');
+    if (deletion.length > 1 || !deletion.every((item)=>validBooleanAttributeValue(item))) return false;
+    return !deletion.some(booleanAttributeIsTrue) || 't' === axisPosition;
+}
+function validBooleanAttributeValue(element) {
+    const value = attribute(element, 'val');
+    return null === value || [
+        '0',
+        '1',
+        'false',
+        'true'
+    ].includes(value);
+}
+function axisSettingNumber(parent, name) {
+    const elements = directChildren(parent, name);
+    if (!elements.length) return {
+        valid: true
+    };
+    if (elements.length > 1) return {
+        valid: false
+    };
+    const source = attribute(elements[0], 'val');
+    if (!source?.trim()) return {
+        valid: false
+    };
+    const value = Number(source);
+    return Number.isFinite(value) ? {
+        valid: true,
+        value
+    } : {
+        valid: false
+    };
+}
+function isSupportedAxisTitle(title) {
+    const children = directChildren(title);
+    if (children.some((child)=>![
+            'tx',
+            'layout',
+            'overlay'
+        ].includes(child.localName))) return false;
+    const text = directChildren(title, 'tx');
+    if (1 !== text.length) return false;
+    const layouts = directChildren(title, 'layout');
+    if (layouts.length > 1 || layouts.some((layout)=>descendants(layout, 'manualLayout').length > 0)) return false;
+    const overlays = directChildren(title, 'overlay');
+    if (overlays.length > 1 || overlays.some((overlay)=>booleanAttributeIsTrue(overlay))) return false;
+    const sources = directChildren(text[0]);
+    if (1 !== sources.length) return false;
+    const source = sources[0];
+    if ('strRef' === source.localName) {
+        const sourceChildren = directChildren(source);
+        if (sourceChildren.some((child)=>'f' !== child.localName && 'strCache' !== child.localName)) return false;
+        const formulas = directChildren(source, 'f');
+        return 1 === formulas.length && directChildren(source, 'strCache').length <= 1 && isSupportedChartReference(formulas[0].textContent ?? '');
+    }
+    if ('rich' !== source.localName) return false;
+    if (1 !== descendants(source, 'p').length || !descendants(source, 't').length) return false;
+    return ![
+        'br',
+        'fld',
+        'hlinkClick',
+        'hlinkMouseOver'
+    ].some((name)=>descendants(source, name).length > 0);
+}
+function booleanAttributeIsTrue(element) {
+    const value = attribute(element, 'val');
+    return null === value || '1' === value || 'true' === value;
+}
+function issue(code, message, severity = 'warning') {
+    return {
+        code,
+        severity,
+        feature: 'Workbook charts',
+        message
+    };
+}
+const SIMPLE_RULE_TYPES = new Set([
+    'containsText',
+    'duplicateValues',
+    'uniqueValues',
+    'top10',
+    'aboveAverage'
+]);
+function diagnoseXlsxConditionalFormatting(worksheet, styles) {
+    const allContainers = descendants(worksheet, 'conditionalFormatting');
+    if (!allContainers.length) return [];
+    const containers = directChildren(worksheet.documentElement, 'conditionalFormatting');
+    const dxfs = styles ? directChildren(firstDescendant(styles, 'dxfs') ?? styles, 'dxf') : [];
+    const unsupported = new Set();
+    let supported = 0;
+    let colorNormalization = false;
+    let formulaNormalization = false;
+    let optionNormalization = allContainers.length > containers.length;
+    const priorities = new Set();
+    if (allContainers.length > containers.length) unsupported.add('extension-based rules');
+    if (descendants(worksheet, 'dataBar').some(hasAdvancedDataBarVisuals)) unsupported.add('x14 data-bar direction, axis, border, gradient, or negative-color options');
+    for (const container of containers)for (const rule of directChildren(container, 'cfRule')){
+        const type = attribute(rule, 'type') ?? 'unknown';
+        const formulas = directChildren(rule, 'formula').map((formula)=>formula.textContent?.trim() ?? '');
+        if (formulas.some(isAdvancedFormula)) formulaNormalization = true;
+        const priority = positiveIntegerAttribute(rule, 'priority');
+        if (null === priority || priorities.has(priority)) optionNormalization = true;
+        else priorities.add(priority);
+        if ('cellIs' === type) {
+            const operator = attribute(rule, 'operator') ?? '';
+            const supportedOperator = isSpreadsheetConditionalComparisonOperator(operator);
+            const formulaCount = supportedOperator && spreadsheetConditionalComparisonNeedsUpperValue(operator) ? 2 : 1;
+            if (supportedOperator && formulas.length >= formulaCount) supported += 1;
+            else unsupported.add(operator ? `cellIs/${operator}` : 'cellIs');
+        } else if (SIMPLE_RULE_TYPES.has(type)) {
+            supported += 1;
+            if ('aboveAverage' === type && (null !== attribute(rule, 'equalAverage') || null !== attribute(rule, 'stdDev'))) optionNormalization = true;
+        } else if ('expression' === type) if (formulas.length) supported += 1;
+        else unsupported.add('empty formula rule');
+        else if ('colorScale' === type) {
+            const scale = directChild(rule, 'colorScale');
+            const colors = scale ? directChildren(scale, 'color') : [];
+            const thresholds = scale ? directChildren(scale, 'cfvo') : [];
+            const supportedThresholds = colors.length >= 2 && colors.length <= 3 && (0 === thresholds.length || thresholds.length === colors.length && thresholds.every(isSupportedVisualThreshold));
+            if (colors.length >= 2 && colors.length <= 3 && colors.every(hasRgbColor) && supportedThresholds) supported += 1;
+            else unsupported.add('colorScale');
+            if (colors.some(needsColorNormalization)) colorNormalization = true;
+            if (!thresholds.length) optionNormalization = true;
+        } else if ('dataBar' === type) {
+            const dataBar = directChild(rule, 'dataBar');
+            const colors = dataBar ? directChildren(dataBar, 'color') : [];
+            const thresholds = dataBar ? directChildren(dataBar, 'cfvo') : [];
+            const supportedThresholds = 0 === thresholds.length || 2 === thresholds.length && thresholds.every(isSupportedVisualThreshold);
+            const supportedOptions = Boolean(dataBar && hasSupportedDataBarOptions(dataBar));
+            if (1 === colors.length && colors.every(hasRgbColor) && supportedThresholds && supportedOptions) supported += 1;
+            else unsupported.add('dataBar');
+            if (colors.some(needsColorNormalization)) colorNormalization = true;
+            if (!thresholds.length) optionNormalization = true;
+            if (dataBar && Array.from(dataBar.attributes).some((item)=>![
+                    'showValue',
+                    'minLength',
+                    'maxLength'
+                ].includes(item.localName))) optionNormalization = true;
+        } else if ('iconSet' === type) {
+            const iconSet = directChild(rule, 'iconSet');
+            const name = iconSet ? attribute(iconSet, 'iconSet') ?? '3TrafficLights1' : '';
+            if (iconSet && (booleanAttribute(iconSet, 'custom') || directChildren(iconSet, 'cfIcon').length > 0)) unsupported.add('custom icon sets');
+            else if (iconSet && isSpreadsheetConditionalIconSetName(name)) {
+                const thresholds = directChildren(iconSet, 'cfvo');
+                const validThresholds = 0 === thresholds.length || thresholds.length === spreadsheetConditionalIconSetCount(name) && thresholds.every(isSupportedIconThreshold);
+                if (validThresholds) supported += 1;
+                else unsupported.add('iconSet thresholds');
+                if (!thresholds.length) optionNormalization = true;
+                if (Array.from(iconSet.attributes).some((item)=>![
+                        'iconSet',
+                        'showValue',
+                        'reverse',
+                        'percent'
+                    ].includes(item.localName)) || [
+                    'showValue',
+                    'reverse',
+                    'percent'
+                ].some((name)=>!validBooleanAttribute(iconSet, name))) optionNormalization = true;
+            } else unsupported.add(name ? `iconSet/${name}` : 'iconSet');
+        } else unsupported.add(type);
+        const dxfId = attribute(rule, 'dxfId');
+        if (null !== dxfId) {
+            const dxfIndex = /^\d+$/.test(dxfId) ? Number(dxfId) : -1;
+            const dxf = dxfs[dxfIndex];
+            if (dxf) {
+                const colors = [
+                    ...descendants(dxf, 'color'),
+                    ...descendants(dxf, 'fgColor')
+                ];
+                if (colors.some(needsColorNormalization)) colorNormalization = true;
+                if (hasAdvancedDifferentialStyle(dxf)) optionNormalization = true;
+            } else unsupported.add('missing differential style');
+        }
+    }
+    const diagnostics = [
+        {
+            code: 'xlsx.conditional-formatting',
+            message: supported ? `${supported} supported conditional-formatting rule(s) are preserved in editable sheet state; common cell rules can be changed in Work.` : 'Conditional formatting was detected, but no rule could be converted to editable sheet state.',
+            severity: supported ? 'info' : 'warning'
+        }
+    ];
+    if (unsupported.size) diagnostics.push({
+        code: 'xlsx.conditional-formatting.unsupported',
+        message: `Unsupported conditional-formatting features remain in the original workbook only: ${Array.from(unsupported).join(', ')}.`,
+        severity: 'warning'
+    });
+    if (colorNormalization) diagnostics.push({
+        code: 'xlsx.conditional-formatting.colors',
+        message: 'Theme, indexed, automatic, or tinted conditional-format colors are normalized to supported RGB colors.',
+        severity: 'warning'
+    });
+    if (formulaNormalization) diagnostics.push({
+        code: 'xlsx.conditional-formatting.formulas',
+        message: 'External, structured, cross-sheet, or advanced conditional formulas may be recalculated differently.',
+        severity: 'warning'
+    });
+    if (optionNormalization) diagnostics.push({
+        code: 'xlsx.conditional-formatting.options',
+        message: 'Invalid or duplicate priorities, advanced differential styles, omitted thresholds, or x14 visual extensions may be normalized.',
+        severity: 'warning'
+    });
+    return diagnostics;
+}
+function hasRgbColor(element) {
+    return /^[0-9a-f]{6,8}$/i.test(attribute(element, 'rgb') ?? '');
+}
+function needsColorNormalization(element) {
+    return !hasRgbColor(element) && [
+        'theme',
+        'indexed',
+        'auto',
+        'tint'
+    ].some((name)=>null !== attribute(element, name));
+}
+function isAdvancedFormula(value) {
+    return /(?:^|[^A-Z0-9_.])(?:INDIRECT|OFFSET|LET|LAMBDA|_XLFN\.)\s*\(/i.test(value) || /(?:\[[^\]]+\]|!|[#@])/.test(value);
+}
+function hasAdvancedDifferentialStyle(dxf) {
+    return directChildren(dxf).some((child)=>{
+        if ('font' === child.localName) return directChildren(child).some((item)=>'color' !== item.localName);
+        if ('fill' !== child.localName) return true;
+        const pattern = directChild(child, 'patternFill');
+        return !pattern || 'solid' !== attribute(pattern, 'patternType');
+    });
+}
+function booleanAttribute(element, name) {
+    const value = attribute(element, name)?.toLowerCase();
+    return '1' === value || 'true' === value;
+}
+function validBooleanAttribute(element, name) {
+    const value = attribute(element, name);
+    return null === value || [
+        '0',
+        '1',
+        'false',
+        'true'
+    ].includes(value.toLowerCase());
+}
+function isSupportedIconThreshold(element) {
+    const type = attribute(element, 'type');
+    if ('min' === type || 'max' === type) return true;
+    if (![
+        'num',
+        'percent',
+        'percentile'
+    ].includes(type ?? '')) return false;
+    const value = attribute(element, 'val');
+    return null !== value && Number.isFinite(Number(value));
+}
+function isSupportedVisualThreshold(element) {
+    const type = attribute(element, 'type');
+    if ('min' === type || 'max' === type) return true;
+    if (![
+        'num',
+        'percent',
+        'percentile'
+    ].includes(type ?? '')) return false;
+    const value = attribute(element, 'val');
+    return null !== value && Number.isFinite(Number(value));
+}
+function hasSupportedDataBarOptions(element) {
+    if (!validBooleanAttribute(element, 'showValue')) return false;
+    const minimum = percentageAttribute(element, 'minLength', 10);
+    const maximum = percentageAttribute(element, 'maxLength', 90);
+    return null !== minimum && null !== maximum && minimum <= maximum;
+}
+function percentageAttribute(element, name, defaultValue) {
+    const source = attribute(element, name);
+    if (null === source) return defaultValue;
+    const value = Number(source);
+    return Number.isFinite(value) && value >= 0 && value <= 100 ? value : null;
+}
+function positiveIntegerAttribute(element, name) {
+    const source = attribute(element, name);
+    if (!source || !/^[1-9]\d*$/.test(source)) return null;
+    const value = Number(source);
+    return Number.isSafeInteger(value) ? value : null;
+}
+function hasAdvancedDataBarVisuals(element) {
+    return [
+        'direction',
+        'axisPosition',
+        'border',
+        'gradient',
+        'negativeBarColorSameAsPositive'
+    ].some((name)=>null !== attribute(element, name)) || [
+        'borderColor',
+        'negativeFillColor',
+        'negativeBorderColor',
+        'axisColor'
+    ].some((name)=>descendants(element, name).length > 0);
+}
+async function diagnoseXlsxFormulas(archive) {
+    const features = await readXlsxFormulaFeaturesFromPackage(archive);
+    const formulas = Array.from(features.sheets.entries()).flatMap(([sheetName, sheet])=>sheet.formulas.map((formula)=>({
+                ...formula,
+                sheetName
+            })));
+    const ranges = Array.from(features.sheets.entries()).flatMap(([sheetName, sheet])=>sheet.ranges.map((range)=>({
+                ...range,
+                sheetName
+            })));
+    const sharedGroups = Array.from(features.sheets.values()).reduce((count, sheet)=>count + sheet.sharedFormulaGroups, 0);
+    const sharedCells = Array.from(features.sheets.values()).reduce((count, sheet)=>count + sheet.sharedFormulaCells, 0);
+    const arrayRanges = ranges.filter((range)=>'array' === range.type).length;
+    const dynamicRanges = ranges.filter((range)=>'dynamic-array' === range.type).length;
+    const dataTables = ranges.filter((range)=>'data-table' === range.type).length;
+    const cachedErrors = formulas.filter((formula)=>formula.cachedError).length;
+    const externalReferences = formulas.filter((formula)=>formulaHasExternalReference(formula.formula));
+    const structuredReferences = formulas.filter((formula)=>formulaHasStructuredReference(formula.formula));
+    const volatileFormulas = formulas.filter((formula)=>volatileSpreadsheetFormulaFunctions(formula.formula).length);
+    const unsupportedFunctions = new Set(formulas.flatMap((formula)=>unsupportedSpreadsheetFormulaFunctions(formula.formula)));
+    const unsupportedFormulaAttributes = new Set(Array.from(features.sheets.values()).flatMap((sheet)=>sheet.unsupportedFormulaAttributes));
+    const issues = [];
+    if (formulas.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas', `${formulas.length} formula cell(s), cached results, error values, and workbook calculation settings are preserved for XLSX round-trips.`, 'info'));
+    if (arrayRanges || dynamicRanges) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.arrays', `${arrayRanges} legacy array range(s) and ${dynamicRanges} dynamic-array range(s) are preserved as native grouped XLSX formulas; modern spill functions may require Excel or another compatible application to recalculate.`, dynamicRanges ? 'warning' : 'info'));
+    if (sharedGroups) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.shared', `${sharedGroups} shared-formula group(s) covering ${sharedCells} cell(s) are expanded to equivalent per-cell formulas so edits remain deterministic.`));
+    if (dataTables) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.data-tables', `${dataTables} what-if data table(s), input references, and cached results are preserved, but Work does not recalculate scenario tables in the browser.`));
+    if (cachedErrors) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.cached-errors', `${cachedErrors} formula cell(s) contain cached Excel error values; the error type and displayed value are preserved in editing, preview, print, and export.`));
+    if (externalReferences.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.external-references', `${externalReferences.length} formula cell(s) reference external workbooks; formulas and cached values are preserved without refreshing external files.`));
+    if (structuredReferences.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.structured-references', `${structuredReferences.length} formula cell(s) use structured table references; formulas round-trip unchanged, but the Work calculation engine does not resolve Excel table objects.`));
+    if (unsupportedFunctions.size) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.unsupported-functions', `The current browser calculation engine does not evaluate ${Array.from(unsupportedFunctions).sort().join(', ')}; source formulas and cached results are preserved for compatible desktop recalculation.`));
+    if (volatileFormulas.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.volatile', `${volatileFormulas.length} volatile formula cell(s) can change when the workbook is explicitly recalculated.`, 'info'));
+    if (unsupportedFormulaAttributes.size) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.formulas.attributes', `Advanced formula attributes are not represented by the editable model and normalize on export: ${Array.from(unsupportedFormulaAttributes).sort().join(', ')}.`));
+    if ('automatic' !== features.calculation.mode) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.calculation.mode', 'manual' === features.calculation.mode ? 'Manual workbook calculation mode is preserved; cached values remain visible until an explicit recalculation.' : 'Automatic calculation except for data tables is preserved; scenario tables require an explicit compatible recalculation.', 'info'));
+    if (features.calculation.iterativeCalculation) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.calculation.iteration', `Iterative calculation is preserved with at most ${features.calculation.maximumIterations} iterations and a ${features.calculation.maximumChange} convergence threshold.`, 'info'));
+    if (!features.calculation.fullPrecision) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.calculation.precision', 'Calculation using displayed precision is preserved and may produce results different from full-precision calculation.'));
+    if (features.unsupportedCalculationAttributes.length) issues.push(work_xlsx_formula_diagnostics_issue('xlsx.calculation.advanced', `Advanced workbook calculation attributes remain source-only: ${features.unsupportedCalculationAttributes.join(', ')}.`));
+    return issues;
+}
+function work_xlsx_formula_diagnostics_issue(code, message, severity = 'warning') {
+    return {
+        code,
+        severity,
+        feature: 'Formulas and calculation',
+        message
+    };
+}
+function diagnoseXlsxPageSetup(document) {
+    const issues = [];
+    const root = document.documentElement;
+    const pageSetup = directChild(root, 'pageSetup');
+    const headerFooter = directChild(root, 'headerFooter');
+    const hasPageSetup = Boolean(pageSetup) || Boolean(directChild(root, 'pageMargins')) || Boolean(directChild(root, 'printOptions')) || descendants(root, 'pageSetUpPr').length > 0;
+    if (hasPageSetup) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.page-setup', 'Page setup', 'Paper size, orientation, percentage or fit-to-page scaling, margins, centering, first-page numbering, and page order are preserved, editable, and honored by PDF pagination.', 'info'));
+    if (pageSetup) inspectPrinterSetup(pageSetup, issues);
+    if (headerFooter) inspectHeaderFooter(headerFooter, issues);
+    return issues;
+}
+function inspectPrinterSetup(pageSetup, issues) {
+    const paperSize = attribute(pageSetup, 'paperSize');
+    if (paperSize && !isEditableXlsxPaperSizeCode(paperSize)) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.page-setup.paper-size', 'Page setup', `Paper-size code ${paperSize} is not editable yet and falls back to A4 in Work PDF output.`));
+    const orientation = attribute(pageSetup, 'orientation')?.toLowerCase();
+    if (orientation && 'portrait' !== orientation && 'landscape' !== orientation) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.page-setup.orientation', 'Page setup', `Page orientation "${orientation}" uses a printer-specific default and falls back to landscape in Work PDF output.`));
+    const unsupportedAttributes = [
+        'blackAndWhite',
+        'cellComments',
+        'copies',
+        'draft',
+        'errors',
+        'horizontalDpi',
+        'paperHeight',
+        'paperWidth',
+        'usePrinterDefaults',
+        'verticalDpi',
+        'r:id'
+    ].filter((name)=>null !== attribute(pageSetup, name));
+    if (unsupportedAttributes.length) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.page-setup.printer-settings', 'Page setup', `Printer-specific page-setup controls remain in the original workbook only: ${unsupportedAttributes.join(', ')}.`));
+}
+function inspectHeaderFooter(headerFooter, issues) {
+    issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.header-footer', 'Print headers and footers', 'Odd-page plain-text header and footer sections, dynamic fields, page-number start, scaling, and margin alignment are preserved, editable, and rendered in PDF output.', 'info'));
+    const firstOrEvenParts = [
+        'firstHeader',
+        'firstFooter',
+        'evenHeader',
+        'evenFooter'
+    ];
+    const hasVariants = work_xlsx_page_setup_diagnostics_booleanAttribute(headerFooter, 'differentFirst') || work_xlsx_page_setup_diagnostics_booleanAttribute(headerFooter, 'differentOddEven') || firstOrEvenParts.some((name)=>Boolean(directChild(headerFooter, name)));
+    if (hasVariants) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.header-footer.variants', 'Print headers and footers', 'First-page and even-page header/footer variants remain in the original workbook only; Work edits the odd-page template.'));
+    const inspection = directChildren(headerFooter).reduce((combined, element)=>{
+        const current = inspectXlsxHeaderFooterText(element.textContent);
+        return {
+            hasFormatting: combined.hasFormatting || current.hasFormatting,
+            hasImage: combined.hasImage || current.hasImage
+        };
+    }, {
+        hasFormatting: false,
+        hasImage: false
+    });
+    if (inspection.hasFormatting) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.header-footer.formatting', 'Print headers and footers', 'Rich header/footer font formatting is normalized to editable plain text.'));
+    if (inspection.hasImage) issues.push(work_xlsx_page_setup_diagnostics_issue('xlsx.header-footer.images', 'Print headers and footers', 'Header and footer images remain in the original workbook only.'));
+}
+function work_xlsx_page_setup_diagnostics_booleanAttribute(element, name) {
+    const value = attribute(element, name)?.toLowerCase();
+    return '1' === value || 'true' === value;
+}
+function work_xlsx_page_setup_diagnostics_issue(code, feature, message, severity = 'warning') {
+    return {
+        code,
+        feature,
+        message,
+        severity
+    };
+}
+async function diagnoseXlsxPivots(archive) {
+    const inspection = await inspectXlsxPivotTables(archive);
+    const issues = [];
+    if (inspection.tables.length) issues.push({
+        code: 'xlsx.pivots',
+        feature: 'Pivot tables',
+        severity: 'info',
+        message: `${inspection.tables.length} worksheet-backed pivot table(s) are editable, refreshable in Work, and regenerated with native XLSX definitions and caches.`
+    });
+    for (const unsupported of inspection.unsupported)issues.push({
+        code: unsupported.code,
+        feature: 'Pivot tables',
+        severity: 'warning',
+        message: `${unsupported.message} Cached worksheet results remain visible, but a new Work export contains them as ordinary cells rather than an editable native pivot.`,
+        location: unsupported.location
+    });
+    return issues;
+}
+async function analyzeDocxCompatibility(file, messages) {
+    const issues = [
+        work_office_diagnostics_issue('docx.page-layout', 'Page layout', 'Per-section paper size, orientation, basic margins, one-to-six equal or custom-width columns, section breaks, and explicit page breaks are preserved; exact pagination and line wrapping may normalize.')
+    ];
+    for (const message of messages)issues.push(work_office_diagnostics_issue(`docx.converter.${message.type}`, 'Document conversion', message.message, 'error' === message.type ? 'error' : 'warning'));
+    try {
+        const archive = await OoxmlPackage.load(await file.arrayBuffer());
+        const document = archive.has('word/document.xml') ? await archive.xml('word/document.xml') : null;
+        if (archive.has('word/comments.xml')) {
+            const comments = await archive.xml('word/comments.xml');
+            const commentDefinitions = descendants(comments, 'comment');
+            if (commentDefinitions.length) {
+                issues.push(work_office_diagnostics_issue('docx.comments', 'Comments', `${commentDefinitions.length} comment or reply record(s), text anchors, authors, dates, thread relationships, and resolved state are preserved and editable.`, 'info'));
+                if ([
+                    'tbl',
+                    'drawing',
+                    'pict',
+                    'sdt',
+                    'altChunk'
+                ].some((name)=>descendants(comments, name).length) || descendants(comments, 'rPr').length) issues.push(work_office_diagnostics_issue('docx.comments.formatting', 'Comment formatting', 'Comment text is editable, but rich formatting, tables, images, and content controls inside comments are normalized to plain text.'));
+            }
+        }
+        issues.push(...await diagnoseDocxNotes(archive, document));
+        issues.push(...await diagnoseDocxPageChrome(archive));
+        if (archive.paths('word/embeddings/').length) issues.push(work_office_diagnostics_issue('docx.embedded', 'Embedded objects', 'Embedded Office and OLE objects remain in the original file only.'));
+        if (document) {
+            issues.push(...await diagnoseDocxCitations(archive, document));
+            const captionDiagnostics = diagnoseDocxCaptions(document);
+            issues.push(...captionDiagnostics.issues);
+            if (descendants(document, 'tbl').length) issues.push(work_office_diagnostics_issue('docx.tables', 'Tables', 'Table rows, non-splitting rows, repeated headers, common cell shading, vertical alignment, and uniform borders remain editable; per-edge or theme borders, exact cell widths, nested tables, and rows that split internally may be normalized.'));
+            if (descendants(document, 'drawing').length || descendants(document, 'pict').length) issues.push(work_office_diagnostics_issue('docx.images', 'Images', 'Inline images and supported square or top-and-bottom floating images remain embedded with editable size, alternative text, alignment, and wrap distance. Precise offsets, crop, contour wrapping, layering, and unsupported drawing types may be normalized.'));
+            const textRevisions = [
+                ...descendants(document, 'ins'),
+                ...descendants(document, 'del')
+            ];
+            if (textRevisions.some((revision)=>descendants(revision, 't').length || descendants(revision, 'delText').length)) issues.push(work_office_diagnostics_issue('docx.revisions', 'Tracked changes', 'Body-text insertions and deletions preserve their author and date, remain reviewable in Work, and round-trip as native DOCX revisions.', 'info'));
+            if (textRevisions.some((revision)=>!descendants(revision, 't').length && !descendants(revision, 'delText').length) || [
+                'moveFrom',
+                'moveTo',
+                'rPrChange',
+                'pPrChange',
+                'tblPrChange',
+                'trPrChange',
+                'tcPrChange',
+                'sectPrChange',
+                'numberingChange'
+            ].some((name)=>descendants(document, name).length)) issues.push(work_office_diagnostics_issue('docx.revisions.structural', 'Structural revisions', 'Moved content plus formatting, numbering, section, row, cell, and table-property revisions may be normalized; Work currently reviews body-text insertions and deletions.'));
+            if (captionDiagnostics.hasUnsupportedFields) issues.push(work_office_diagnostics_issue('docx.fields', 'Fields', 'Fields beyond supported body fields, citations, bibliographies, caption SEQ fields, and caption REF fields are converted to their current displayed value.'));
+            const sectionProperties = descendants(document, 'sectPr');
+            const columnProperties = descendants(document, 'cols');
+            if (sectionProperties.length > 1 || columnProperties.length) issues.push(work_office_diagnostics_issue('docx.sections', 'Sections and columns', `${sectionProperties.length || 1} section(s) and equal or custom-width column settings are preserved, editable, and applied to document PDF output.`, 'info'));
+            const incompleteUnequalColumns = columnProperties.some((columns)=>('0' === attribute(columns, 'equalWidth') || 'false' === attribute(columns, 'equalWidth')) && 0 === directChildren(columns, 'col').length);
+            const excessiveColumns = columnProperties.some((columns)=>Number(attribute(columns, 'num')) > 6);
+            if (incompleteUnequalColumns || excessiveColumns) issues.push(work_office_diagnostics_issue('docx.sections.unsupported', 'Sections and columns', `${[
+                incompleteUnequalColumns ? 'custom columns without explicit width definitions' : '',
+                excessiveColumns ? 'sections with more than six columns' : ''
+            ].filter(Boolean).join(' and ')} are normalized to at most six editable columns.`));
+            if (descendants(document, 'type').some((sectionType)=>sectionType.parentElement?.localName === 'sectPr' && 'nextColumn' === attribute(sectionType, 'val'))) issues.push(work_office_diagnostics_issue('docx.sections.next-column-preview', 'Sections and columns', 'Next-column section breaks survive DOCX round-trips; Work preview and PDF render them as continuous section blocks.'));
+        }
+    } catch  {
+        issues.push(work_office_diagnostics_issue('docx.inspect', 'Package inspection', 'Some DOCX features could not be inspected before conversion.'));
+    }
+    return report(file, 'DOCX', issues);
+}
+async function analyzeSpreadsheetCompatibility(file, extension, workbook) {
+    if ('csv' === extension) return null;
+    const sourceFormat = extension.toUpperCase();
+    const issues = [];
+    if ('xls' === extension) issues.push(work_office_diagnostics_issue('xls.legacy', 'Legacy workbook', 'The binary XLS workbook is converted to the modern native sheet model.'));
+    else if ('ods' === extension) issues.push(work_office_diagnostics_issue('ods.styles', 'OpenDocument formatting', 'Advanced ODS formatting and chart behavior may be normalized on export to XLSX.'));
+    const definedNames = workbook.Workbook?.Names ?? [];
+    const names = definedNames.filter((name)=>!/^_xlnm\./i.test(name.Name));
+    if (names.length) issues.push(work_office_diagnostics_issue('sheet.names', 'Named ranges', `${names.length} workbook or worksheet named range(s) are preserved and editable; external references are not refreshed.`, 'info'));
+    const printAreas = definedNames.filter((name)=>'_xlnm.print_area' === name.Name.toLowerCase());
+    if (printAreas.length) issues.push(work_office_diagnostics_issue('sheet.print-area', 'Print areas', `${printAreas.length} worksheet print area(s) are preserved and used by PDF export; disjoint regions may be combined into one bounding layout.`, 'info'));
+    const printTitles = definedNames.filter((name)=>'_xlnm.print_titles' === name.Name.toLowerCase());
+    const validPrintTitles = printTitles.filter((name)=>{
+        if ('number' != typeof name.Sheet) return false;
+        const sheetName = workbook.SheetNames[name.Sheet];
+        return Boolean(sheetName && parseSpreadsheetPrintTitles(stripSpreadsheetSheetQualifier(name.Ref, sheetName)));
+    });
+    if (validPrintTitles.length) issues.push(work_office_diagnostics_issue('sheet.print-titles', 'Print titles', `${validPrintTitles.length} worksheet print-title setting(s) are preserved, editable, and repeated in PDF output.`, 'info'));
+    if (validPrintTitles.length < printTitles.length) issues.push(work_office_diagnostics_issue('sheet.print-titles.invalid', 'Print titles', 'One or more malformed print-title definitions remain in the original workbook only.'));
+    for (const [index, name] of workbook.SheetNames.entries()){
+        const worksheet = workbook.Sheets[name];
+        inspectWorksheetModel(worksheet, name, issues, 'xlsx' === extension);
+        if ((workbook.Workbook?.Sheets?.[index]?.Hidden ?? 0) > 0) issues.push(work_office_diagnostics_issue('sheet.hidden', 'Hidden worksheets', 'Hidden worksheet state is preserved but can be changed by the editor.', 'info', name));
+    }
+    if ('xlsx' === extension) try {
+        const archive = await OoxmlPackage.load(await file.arrayBuffer());
+        await inspectXlsxPackage(archive, issues);
+    } catch  {
+        issues.push(work_office_diagnostics_issue('xlsx.inspect', 'Package inspection', 'Some XLSX features could not be inspected before conversion.'));
+    }
+    return issues.length ? report(file, sourceFormat, deduplicate(issues)) : null;
+}
+function inspectWorksheetModel(worksheet, name, issues, nativeXlsxFormulaInspection) {
+    if (!worksheet) return;
+    if (worksheet['!autofilter']) issues.push(work_office_diagnostics_issue('sheet.filter', 'Filters', 'The auto-filter range and hidden rows are preserved; advanced active criteria may be normalized.', 'info', name));
+    let hasComments = false;
+    let hasCommentThreads = false;
+    let hasLinks = false;
+    let hasArrayFormulas = false;
+    let hasRichText = false;
+    for (const [address, cell] of Object.entries(worksheet)){
+        if (address.startsWith('!') || !cell || 'object' != typeof cell) continue;
+        const source = cell;
+        if (source.c?.length) {
+            hasComments = true;
+            if (source.c.length > 1 || source.c.some((comment)=>comment.T)) hasCommentThreads = true;
+        }
+        if (source.l?.Target) hasLinks = true;
+        if (source.F) hasArrayFormulas = true;
+        if (source.r) hasRichText = true;
+    }
+    if (hasComments) issues.push(work_office_diagnostics_issue('sheet.comments', 'Cell comments', 'Plain-text cell comments and one author are preserved and editable through the spreadsheet comment tools.', 'info', name));
+    if (hasCommentThreads) issues.push(work_office_diagnostics_issue('sheet.comment-threads', 'Comment threads', 'Multiple comment blocks and threaded replies are flattened into one editable legacy comment.', 'warning', name));
+    if (hasLinks) issues.push(work_office_diagnostics_issue('sheet.links', 'Cell hyperlinks', 'Web and in-workbook hyperlinks are preserved; advanced screen tips may be normalized.', 'info', name));
+    if (hasArrayFormulas && !nativeXlsxFormulaInspection) issues.push(work_office_diagnostics_issue('sheet.array-formula', 'Array formulas', 'Array-formula ranges may be recalculated as ordinary formulas.', 'warning', name));
+    if (hasRichText) issues.push(work_office_diagnostics_issue('sheet.rich-text', 'Rich cell text', 'Rich text inside a cell is converted to uniform text.', 'warning', name));
+}
+async function inspectXlsxPackage(archive, issues) {
+    issues.push(...await diagnoseXlsxCharts(archive));
+    issues.push(...await diagnoseXlsxFormulas(archive));
+    issues.push(...await diagnoseXlsxPivots(archive));
+    const drawingParts = archive.paths('xl/drawings/').filter((path)=>/^xl\/drawings\/drawing\d+\.xml$/i.test(path));
+    let preservedImages = 0;
+    let hasUnsupportedImages = false;
+    let hasImagesBeyondBudget = false;
+    let hasNormalizedImageFormatting = false;
+    let hasUnsupportedDrawings = false;
+    let embeddedImageBytes = 0;
+    for (const part of drawingParts){
+        const drawing = await archive.xml(part);
+        const relationships = await archive.relationships(part);
+        for (const picture of descendants(drawing, 'pic')){
+            const blip = firstDescendant(picture, 'blip');
+            const relationshipId = blip ? attribute(blip, 'r:embed') ?? attribute(blip, 'embed') : null;
+            const relationship = relationshipId ? relationships.get(relationshipId) : void 0;
+            const contentType = relationship ? contentTypeForPart(relationship.target) : '';
+            if (relationship && 'External' !== relationship.targetMode && relationship.type.endsWith('/image') && archive.has(relationship.target) && isSupportedXlsxWorksheetImageContentType(contentType)) {
+                const bytes = await archive.bytes(relationship.target);
+                if (embeddedImageBytes + bytes.byteLength <= MAX_XLSX_WORKSHEET_IMAGE_BYTES) {
+                    embeddedImageBytes += bytes.byteLength;
+                    preservedImages += 1;
+                } else hasImagesBeyondBudget = true;
+            } else hasUnsupportedImages = true;
+            const sourceRectangle = firstDescendant(picture, 'srcRect');
+            const transform = firstDescendant(directChild(picture, 'spPr'), 'xfrm');
+            if (sourceRectangle && Array.from(sourceRectangle.attributes).some((item)=>0 !== Number(item.value)) || transform && (attribute(transform, 'rot') || '1' === attribute(transform, 'flipH') || '1' === attribute(transform, 'flipV'))) hasNormalizedImageFormatting = true;
+        }
+        hasUnsupportedDrawings ||= [
+            'sp',
+            'cxnSp',
+            'grpSp',
+            'contentPart'
+        ].some((name)=>descendants(drawing, name).length > 0);
+        hasUnsupportedDrawings ||= descendants(drawing, 'graphicFrame').some((frame)=>!firstDescendant(frame, 'chart'));
+    }
+    if (preservedImages) issues.push(work_office_diagnostics_issue('xlsx.images', 'Worksheet images', `${preservedImages} embedded raster worksheet image(s), positions, sizes, names, and alternative text are preserved and editable.`, 'info'));
+    if (hasUnsupportedImages) issues.push(work_office_diagnostics_issue('xlsx.images.unsupported', 'Worksheet images', 'Linked, missing, or browser-incompatible worksheet images remain in the original XLSX only.'));
+    if (hasImagesBeyondBudget) issues.push(work_office_diagnostics_issue('xlsx.images.limit', 'Large worksheet images', 'Worksheet images beyond the 10 MiB editable image budget remain in the original XLSX only.'));
+    if (hasNormalizedImageFormatting) issues.push(work_office_diagnostics_issue('xlsx.images.format', 'Worksheet image formatting', 'Worksheet image crop, rotation, or flip settings are normalized to an editable unrotated image.'));
+    if (hasUnsupportedDrawings || archive.paths('xl/drawings/').length > 0 && 0 === drawingParts.length) issues.push(work_office_diagnostics_issue('xlsx.drawings.unsupported', 'Worksheet drawings', 'Worksheet shapes, connectors, SmartArt, and non-chart drawing objects remain in the original XLSX only.'));
+    if (archive.paths('xl/comments').length || archive.paths('xl/threadedComments/').length) issues.push(work_office_diagnostics_issue('xlsx.comments', 'Comments', 'Legacy cell comments are imported and editable; rich formatting and threaded conversations may normalize.', 'info'));
+    if (archive.paths('xl/tables/').length) issues.push(work_office_diagnostics_issue('xlsx.tables', 'Structured tables', 'Table values are preserved, but table names, styles, and totals are normalized.'));
+    if (archive.paths('xl/externalLinks/').length) issues.push(work_office_diagnostics_issue('xlsx.external-links', 'External links', 'External workbook links are not refreshed by Work.'));
+    if (archive.has('xl/vbaProject.bin')) issues.push(work_office_diagnostics_issue('xlsx.macros', 'Macros', 'VBA macros remain in the original workbook and are never executed.'));
+    let styles = null;
+    if (archive.has('xl/styles.xml')) {
+        styles = await archive.xml('xl/styles.xml');
+        const cellFormats = firstDescendant(styles, 'cellXfs');
+        if (cellFormats && directChildren(cellFormats, 'xf').length > 1) issues.push(work_office_diagnostics_issue('xlsx.styles', 'Cell formatting', 'Common cell formatting is imported; advanced borders and number formats may be normalized.'));
+    }
+    for (const part of archive.paths('xl/worksheets/')){
+        if (!part.endsWith('.xml')) continue;
+        const worksheet = await archive.xml(part);
+        if (descendants(worksheet, 'conditionalFormatting').length) for (const diagnostic of diagnoseXlsxConditionalFormatting(worksheet, styles))issues.push(work_office_diagnostics_issue(diagnostic.code, 'Conditional formatting', diagnostic.message, diagnostic.severity));
+        if (descendants(worksheet, 'dataValidation').length) issues.push(work_office_diagnostics_issue('xlsx.validation', 'Data validation', 'Common list, numeric, date, and text-length rules are editable; custom formulas and very large ranges may be normalized.', 'info'));
+        if (descendants(worksheet, 'sheetProtection').length || descendants(worksheet, 'protectedRange').length) for (const diagnostic of diagnoseXlsxProtection(worksheet, styles))issues.push(work_office_diagnostics_issue(diagnostic.code, 'Sheet protection', diagnostic.message, diagnostic.severity));
+        issues.push(...diagnoseXlsxPageSetup(worksheet));
+        if (descendants(worksheet, 'brk').some((pageBreak)=>{
+            const manual = attribute(pageBreak, 'man')?.toLowerCase();
+            return '1' === manual || 'true' === manual;
+        })) issues.push(work_office_diagnostics_issue('xlsx.manual-page-breaks', 'Manual page breaks', 'Manual row and column page breaks are preserved, editable, and honored by PDF pagination.', 'info'));
+    }
+}
+function report(file, sourceFormat, issues) {
+    return {
+        sourceFormat,
+        sourceName: file.name,
+        assessedAt: Date.now(),
+        issues: deduplicate(issues)
+    };
+}
+function work_office_diagnostics_issue(code, feature, message, severity = 'warning', location) {
+    return {
+        code,
+        feature,
+        message,
+        severity,
+        location
+    };
+}
+function deduplicate(issues) {
+    const seen = new Set();
+    return issues.filter((item)=>{
+        const key = `${item.code}:${item.location ?? ''}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+export { analyzeDocxCompatibility, analyzeSpreadsheetCompatibility };