@cj-tech-master/excelts 9.4.2 → 9.5.0

package/dist/esm/modules/excel/utils/ooxml-validator/check-relationships.js

@@ -0,0 +1,184 @@
+/**
+ * Relationships check.
+ *
+ * For every `.rels` file in the package we verify:
+ *   - The root element is `<Relationships>` and children are `<Relationship>`.
+ *   - Each rel has `Id`, `Type`, and `Target` attributes.
+ *   - Relationship `Id` values are unique within the same rels file.
+ *   - Non-external targets resolve to files that exist inside the package.
+ *   - Resolved targets stay inside the package root (no `..` escape).
+ *   - For well-known rel types, the resolved target matches the expected
+ *     part-name pattern (e.g. a `Type=...relationships/chart` rel must
+ *     point at `xl/charts/chartN.xml`).
+ *   - Every non-root rels file has a corresponding source part in the zip.
+ *   - The package root rels include an officeDocument rel to `xl/workbook.xml`.
+ */
+import { getRelsSourceDir, isSafeResolvedPath, posixBasename, resolveRelTarget, sourcePartForRels } from "./path-utils.js";
+const REL_TYPE_TARGET_RULES = [
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+        pattern: /^xl\/workbook\.xml$/,
+        label: "workbook"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet",
+        pattern: /^xl\/worksheets\/sheet\d+\.xml$/,
+        label: "worksheet"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chartsheet",
+        pattern: /^xl\/chartsheets\/sheet\d+\.xml$/,
+        label: "chartsheet"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
+        pattern: /^xl\/charts\/chart\d+\.xml$/,
+        label: "chart"
+    },
+    {
+        type: "http://schemas.microsoft.com/office/2014/relationships/chartEx",
+        pattern: /^xl\/charts\/chartEx\d+\.xml$/,
+        label: "chartEx"
+    },
+    {
+        type: "http://schemas.microsoft.com/office/2011/relationships/chartStyle",
+        pattern: /^xl\/charts\/style(?:Ex)?\d+\.xml$/,
+        label: "chart style"
+    },
+    {
+        type: "http://schemas.microsoft.com/office/2011/relationships/chartColorStyle",
+        pattern: /^xl\/charts\/colors(?:Ex)?\d+\.xml$/,
+        label: "chart colors"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing",
+        pattern: /^xl\/drawings\/drawing\d+\.xml$/,
+        label: "drawing"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles",
+        pattern: /^xl\/styles\.xml$/,
+        label: "styles"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings",
+        pattern: /^xl\/sharedStrings\.xml$/,
+        label: "shared strings"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
+        pattern: /^xl\/theme\/[^/]+\.xml$/,
+        label: "theme"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotTable",
+        pattern: /^xl\/pivotTables\/pivotTable\d+\.xml$/,
+        label: "pivot table"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
+        pattern: /^xl\/pivotCache\/pivotCacheDefinition\d+\.xml$/,
+        label: "pivot cache definition"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheRecords",
+        pattern: /^xl\/pivotCache\/pivotCacheRecords\d+\.xml$/,
+        label: "pivot cache records"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table",
+        pattern: /^xl\/tables\/table\d+\.xml$/,
+        label: "table"
+    },
+    {
+        type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/externalLink",
+        pattern: /^xl\/externalLinks\/externalLink\d+\.xml$/,
+        label: "external link"
+    }
+];
+const REL_TYPE_TARGET_BY_TYPE = new Map(REL_TYPE_TARGET_RULES.map(r => [r.type, r]));
+// -----------------------------------------------------------------------------
+// Checker
+// -----------------------------------------------------------------------------
+export function checkRootRelationships(ctx) {
+    if (!ctx.has("_rels/.rels")) {
+        return; // missing-part already reported.
+    }
+    const rels = ctx.readRels("_rels/.rels").rels;
+    const hasOfficeDocument = rels.some(r => r.type.includes("/relationships/officeDocument") && r.target === "xl/workbook.xml");
+    if (!hasOfficeDocument) {
+        ctx.reporter.error("root-rels-missing-officeDocument", "Missing officeDocument relationship to xl/workbook.xml", "_rels/.rels");
+    }
+}
+export function checkRelationships(ctx) {
+    for (const [path, entry] of ctx.files()) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        if (entry.type === "directory" || !path.endsWith(".rels")) {
+            continue;
+        }
+        checkSingleRelsFile(ctx, path);
+    }
+}
+function checkSingleRelsFile(ctx, relsPath) {
+    const data = ctx.readRels(relsPath);
+    // Missing attributes.
+    for (const m of data.malformedEntries) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        if (m.missingId) {
+            ctx.reporter.error("rels-missing-id-attr", `Relationship missing Id attribute`, relsPath);
+        }
+        if (m.missingType) {
+            ctx.reporter.error("rels-missing-type-attr", `Relationship ${m.id ?? "<no-id>"} missing Type attribute`, relsPath);
+        }
+        if (m.missingTarget) {
+            ctx.reporter.error("rels-missing-target", `Relationship ${m.id ?? "<no-id>"} missing Target attribute`, relsPath);
+        }
+    }
+    // Duplicate IDs — scan raw array (parsed keeps first).
+    const seen = new Set();
+    for (const rel of data.rels) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        if (seen.has(rel.id)) {
+            ctx.reporter.error("rels-duplicate-id", `Duplicate relationship Id: ${rel.id}`, relsPath);
+        }
+        else {
+            seen.add(rel.id);
+        }
+        if (rel.targetMode === "External") {
+            continue;
+        }
+        if (rel.target === "") {
+            ctx.reporter.error("rels-empty-target", `Relationship ${rel.id} (${rel.type}) has empty Target`, relsPath);
+            continue;
+        }
+        const resolved = resolveRelTarget(relsPath, rel.target);
+        if (!isSafeResolvedPath(resolved)) {
+            ctx.reporter.error("rels-invalid-target-path", `Rel ${rel.id} (${rel.type}) target escapes package root: ${rel.target} -> ${resolved}`, relsPath);
+            continue;
+        }
+        if (!ctx.has(resolved)) {
+            ctx.reporter.error("rels-missing-target", `Rel ${rel.id} (${rel.type}) target missing: ${rel.target} -> ${resolved}`, relsPath);
+            continue;
+        }
+        // Rel type -> target pattern.
+        const rule = REL_TYPE_TARGET_BY_TYPE.get(rel.type);
+        if (rule && !rule.pattern.test(resolved)) {
+            ctx.reporter.error("rels-type-target-mismatch", `Rel ${rel.id} (${rule.label}) points at unexpected target: ${resolved}`, relsPath);
+        }
+    }
+    // Source part must exist.
+    if (relsPath !== "_rels/.rels") {
+        const srcDir = getRelsSourceDir(relsPath);
+        const srcName = posixBasename(relsPath).replace(/\.rels$/, "");
+        const sourcePath = sourcePartForRels(relsPath) ?? (srcDir ? `${srcDir}/${srcName}` : srcName);
+        if (!ctx.has(sourcePath)) {
+            ctx.reporter.error("rels-source-missing", `Relationships part has no corresponding source part: ${sourcePath}`, relsPath);
+        }
+    }
+}

package/dist/esm/modules/excel/utils/ooxml-validator/check-structure.js

@@ -0,0 +1,56 @@
+/**
+ * Package structure check.
+ *
+ * Verifies the package contains the four OPC-mandatory parts (every xlsx
+ * must have these to be considered an Open Packaging Convention file) and
+ * that every XML-like part is syntactically well-formed.
+ *
+ * XML well-formedness is the broadest reachable check — it catches
+ * unclosed tags, bad escapes, and invalid entities that would cause Excel
+ * to repair-or-reject the whole package. We parse via DOM (which
+ * internally delegates to SAX) so that subsequent DOM-based checkers hit
+ * the same cached result.
+ */
+import { isXmlLike } from "./path-utils.js";
+const REQUIRED_PARTS = [
+    "[Content_Types].xml",
+    "_rels/.rels",
+    "xl/workbook.xml",
+    "xl/_rels/workbook.xml.rels"
+];
+export function checkStructure(ctx) {
+    for (const p of REQUIRED_PARTS) {
+        if (!ctx.has(p)) {
+            ctx.reporter.error("missing-part", `Missing required part: ${p}`, p);
+        }
+    }
+}
+/**
+ * Walk every XML-like entry and parse it to surface malformed-XML
+ * problems. Leverages the context cache so DOM-based checkers that run
+ * afterwards do not re-parse.
+ */
+export function checkXmlWellFormed(ctx) {
+    for (const [path, entry] of ctx.files()) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        if (entry.type === "directory" || !isXmlLike(path)) {
+            continue;
+        }
+        // Relationships malformed errors are reported by readRels; content
+        // types malformed errors are reported by readContentTypes. Prefer
+        // those specific kinds.
+        if (path.endsWith(".rels")) {
+            ctx.readRels(path);
+            continue;
+        }
+        if (path === "[Content_Types].xml") {
+            ctx.readContentTypes();
+            continue;
+        }
+        ctx.readDom(path, err => {
+            ctx.reporter.error("xml-malformed", `Malformed XML: ${err.message}`, path);
+        });
+    }
+}

package/dist/esm/modules/excel/utils/ooxml-validator/check-styles.js

@@ -0,0 +1,89 @@
+/**
+ * Styles table integrity.
+ *
+ * Every xf in `cellXfs` references indices into `numFmts`, `fonts`,
+ * `fills`, `borders`. Out-of-bounds references produce style corruption
+ * on load (Excel falls back to the default style silently, so this is a
+ * warning-severity check — it's a strong signal of a broken writer but
+ * not a hard "Excel cannot open" issue).
+ *
+ * `numFmts` uses numeric IDs, including ~100 built-in IDs < 164 that are
+ * never declared. We only flag ids >= 164 that have no matching numFmt
+ * entry.
+ */
+import { attrByLocalName, findChildLocal, findChildrenLocal } from "./xml-utils.js";
+const STYLES_PATH = "xl/styles.xml";
+/** IDs < 164 are built-in. Custom numFmts must declare IDs >= 164. */
+const CUSTOM_NUMFMT_FIRST_ID = 164;
+export function checkStyles(ctx) {
+    if (!ctx.has(STYLES_PATH)) {
+        return;
+    }
+    const dom = ctx.readDom(STYLES_PATH);
+    if (!dom) {
+        return;
+    }
+    const root = dom.root;
+    // Collect declared indices.
+    const numFmtIds = new Set();
+    const numFmtsEl = findChildLocal(root, "numFmts");
+    if (numFmtsEl) {
+        for (const nf of findChildrenLocal(numFmtsEl, "numFmt")) {
+            const idAttr = attrByLocalName(nf, "numFmtId");
+            const id = idAttr !== undefined ? parseInt(idAttr, 10) : NaN;
+            if (Number.isFinite(id)) {
+                numFmtIds.add(id);
+            }
+        }
+    }
+    const fontCount = countChildren(root, "fonts", "font");
+    const fillCount = countChildren(root, "fills", "fill");
+    const borderCount = countChildren(root, "borders", "border");
+    const cellXfs = findChildLocal(root, "cellXfs");
+    if (!cellXfs) {
+        return;
+    }
+    let xfIdx = -1;
+    for (const xf of findChildrenLocal(cellXfs, "xf")) {
+        xfIdx++;
+        if (ctx.reporter.capped) {
+            return;
+        }
+        const numFmtId = intAttr(xf, "numFmtId");
+        if (numFmtId !== undefined && numFmtId >= CUSTOM_NUMFMT_FIRST_ID && !numFmtIds.has(numFmtId)) {
+            ctx.reporter.warning("styles-numFmt-missing-for-xf", `cellXfs[${xfIdx}] references numFmtId=${numFmtId} which is not declared in <numFmts>`, STYLES_PATH);
+        }
+        const fontId = intAttr(xf, "fontId");
+        if (fontId !== undefined && (fontId < 0 || fontId >= fontCount)) {
+            ctx.reporter.warning("styles-font-index-oob", `cellXfs[${xfIdx}] fontId=${fontId} is outside [0, ${fontCount})`, STYLES_PATH);
+        }
+        const fillId = intAttr(xf, "fillId");
+        if (fillId !== undefined && (fillId < 0 || fillId >= fillCount)) {
+            ctx.reporter.warning("styles-fill-index-oob", `cellXfs[${xfIdx}] fillId=${fillId} is outside [0, ${fillCount})`, STYLES_PATH);
+        }
+        const borderId = intAttr(xf, "borderId");
+        if (borderId !== undefined && (borderId < 0 || borderId >= borderCount)) {
+            ctx.reporter.warning("styles-border-index-oob", `cellXfs[${xfIdx}] borderId=${borderId} is outside [0, ${borderCount})`, STYLES_PATH);
+        }
+    }
+}
+function countChildren(root, containerName, childName) {
+    const container = findChildLocal(root, containerName);
+    if (!container) {
+        return 0;
+    }
+    const countAttr = attrByLocalName(container, "count");
+    const n = countAttr !== undefined ? parseInt(countAttr, 10) : NaN;
+    if (Number.isFinite(n) && n >= 0) {
+        return n;
+    }
+    return findChildrenLocal(container, childName).length;
+}
+function intAttr(el, localName) {
+    const raw = attrByLocalName(el, localName);
+    if (raw === undefined) {
+        return undefined;
+    }
+    const n = parseInt(raw, 10);
+    return Number.isFinite(n) ? n : undefined;
+}

package/dist/esm/modules/excel/utils/ooxml-validator/check-table.js

@@ -0,0 +1,177 @@
+/**
+ * Table part check.
+ *
+ * Three real-world "Removed Records: Table from /xl/tables/tableN.xml"
+ * patterns that cause Excel to drop the entire table on open:
+ *
+ *   1. **Redundant per-column `<filterColumn>`.** The writer used to
+ *      emit a bare `<filterColumn colId="N" hiddenButton="1"/>` for
+ *      every column in the table. The schema accepts it, but Excel's
+ *      loader interprets a fully-hidden autoFilter on a live table as
+ *      inconsistent and drops the table to recover.
+ *
+ *   2. **`<totalsRowFormula>` paired with a built-in
+ *      `totalsRowFunction`.** The schema allows the child only when
+ *      the function is `"custom"` (or absent). For any of `sum`,
+ *      `average`, `count`, `countNums`, `max`, `min`, `stdDev`,
+ *      `var` Excel generates the SUBTOTAL formula itself and rejects
+ *      the table if we pre-emit one.
+ *
+ *   3. **autoFilter range covering the totals row.** When
+ *      `totalsRowCount="1"` is set on the `<table>`, the autoFilter
+ *      range must stop one row above the totals row. Filtering the
+ *      totals row itself is semantically invalid and Excel rejects
+ *      the table.
+ *
+ * These are some of the most common "Excel cannot open" symptoms in
+ * production xlsx from other tooling too — catching them up front is a
+ * high-value check.
+ */
+import { attrByLocalName, findChildLocal, findChildrenLocal } from "./xml-utils.js";
+const TABLE_PATH_RE = /^xl\/tables\/table\d+\.xml$/;
+/** Built-in totals-row functions that Excel synthesises its own formula for. */
+const BUILTIN_TOTALS_FUNCTIONS = new Set([
+    "sum",
+    "average",
+    "count",
+    "countNums",
+    "max",
+    "min",
+    "stdDev",
+    "var"
+]);
+export function checkTables(ctx) {
+    for (const [path, entry] of ctx.files()) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        if (entry.type === "directory" || !TABLE_PATH_RE.test(path)) {
+            continue;
+        }
+        checkSingleTable(ctx, path);
+    }
+}
+function checkSingleTable(ctx, path) {
+    const dom = ctx.readDom(path);
+    if (!dom) {
+        return;
+    }
+    const root = dom.root;
+    checkRedundantFilterColumns(ctx, path, root);
+    checkTotalsRowFormula(ctx, path, root);
+    checkAutoFilterRange(ctx, path, root);
+}
+// -----------------------------------------------------------------------------
+// 1. Redundant per-column <filterColumn>
+// -----------------------------------------------------------------------------
+function checkRedundantFilterColumns(ctx, path, root) {
+    const autoFilter = findChildLocal(root, "autoFilter");
+    if (!autoFilter) {
+        return;
+    }
+    const tableColumnsEl = findChildLocal(root, "tableColumns");
+    if (!tableColumnsEl) {
+        return;
+    }
+    const tableColumnCount = findChildrenLocal(tableColumnsEl, "tableColumn").length;
+    if (tableColumnCount === 0) {
+        return;
+    }
+    const filterColumns = findChildrenLocal(autoFilter, "filterColumn");
+    if (filterColumns.length !== tableColumnCount) {
+        return; // only the "one per column" writer bug pattern is flagged
+    }
+    // All filterColumn entries must be bare `hiddenButton="1"` with no
+    // filter-state children. Authored filterColumns that legitimately
+    // hide the button for a single column will have fewer entries (not
+    // one per column) so the guard above already lets them through.
+    const allEmpty = filterColumns.every(fc => {
+        const hidden = attrByLocalName(fc, "hiddenButton");
+        const hasChildren = fc.children.some(c => c.type === "element");
+        return hidden === "1" && !hasChildren;
+    });
+    if (allEmpty) {
+        ctx.reporter.error("table-filterColumn-redundant-per-column", `${path}: every column has a bare <filterColumn hiddenButton="1"/> ` +
+            `(total ${filterColumns.length}). Excel drops tables with a ` +
+            `fully-hidden autoFilter on load. Only emit <filterColumn> for ` +
+            `columns that have active filter state or an explicit ` +
+            `filterButton=false.`, path);
+    }
+}
+// -----------------------------------------------------------------------------
+// 2. totalsRowFormula paired with built-in totalsRowFunction
+// -----------------------------------------------------------------------------
+function checkTotalsRowFormula(ctx, path, root) {
+    const tableColumnsEl = findChildLocal(root, "tableColumns");
+    if (!tableColumnsEl) {
+        return;
+    }
+    for (const col of findChildrenLocal(tableColumnsEl, "tableColumn")) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        const totalsFn = attrByLocalName(col, "totalsRowFunction");
+        if (!totalsFn || !BUILTIN_TOTALS_FUNCTIONS.has(totalsFn)) {
+            continue;
+        }
+        const formulaEl = findChildLocal(col, "totalsRowFormula");
+        if (formulaEl) {
+            const name = attrByLocalName(col, "name") ?? attrByLocalName(col, "id") ?? "?";
+            ctx.reporter.error("table-totalsRowFormula-with-builtin-function", `${path}: tableColumn "${name}" has totalsRowFunction="${totalsFn}" ` +
+                `alongside a <totalsRowFormula>. The schema accepts the formula ` +
+                `child only when totalsRowFunction is "custom" or absent.`, path);
+        }
+    }
+}
+// -----------------------------------------------------------------------------
+// 3. autoFilter range covering the totals row
+// -----------------------------------------------------------------------------
+/**
+ * Parse an A1-style range ref into `{ top, bottom }` (1-based, inclusive)
+ * for the row dimension only. Returns `undefined` when the ref is not a
+ * legal rectangle.
+ */
+function parseRangeRowRange(ref) {
+    // Match "A1:C10" or "A1:A1" (degenerate).
+    const m = /^[A-Za-z]+(\d+)(?::[A-Za-z]+(\d+))?$/.exec(ref);
+    if (!m) {
+        return undefined;
+    }
+    const a = parseInt(m[1], 10);
+    const b = m[2] !== undefined ? parseInt(m[2], 10) : a;
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        return undefined;
+    }
+    return { top: Math.min(a, b), bottom: Math.max(a, b) };
+}
+function checkAutoFilterRange(ctx, path, root) {
+    const tableRef = attrByLocalName(root, "ref");
+    const totalsRowCountAttr = attrByLocalName(root, "totalsRowCount");
+    if (!tableRef || !totalsRowCountAttr) {
+        return;
+    }
+    const totalsRowCount = parseInt(totalsRowCountAttr, 10);
+    if (!Number.isFinite(totalsRowCount) || totalsRowCount <= 0) {
+        return;
+    }
+    const autoFilterEl = findChildLocal(root, "autoFilter");
+    if (!autoFilterEl) {
+        return;
+    }
+    const autoRef = attrByLocalName(autoFilterEl, "ref");
+    if (!autoRef) {
+        return;
+    }
+    const tableRange = parseRangeRowRange(tableRef);
+    const autoRange = parseRangeRowRange(autoRef);
+    if (!tableRange || !autoRange) {
+        return;
+    }
+    const tableBottom = tableRange.bottom;
+    const expectedAutoBottom = tableBottom - totalsRowCount;
+    if (autoRange.bottom !== expectedAutoBottom) {
+        ctx.reporter.error("table-autoFilter-covers-totalsRow", `${path}: autoFilter ref ends at row ${autoRange.bottom} but table ref ends ` +
+            `at row ${tableBottom} with totalsRowCount=${totalsRowCount}; ` +
+            `autoFilter must end at row ${expectedAutoBottom} (one row above the totals row).`, path);
+    }
+}

package/dist/esm/modules/excel/utils/ooxml-validator/check-workbook.js

@@ -0,0 +1,163 @@
+/**
+ * Workbook-level check.
+ *
+ * Reads `xl/workbook.xml` as DOM (replacing the previous regex-based
+ * approach, which missed namespaced elements like `<x:sheet>`) and walks
+ * every `<sheet>` declaration to verify:
+ *
+ *   - `sheetId` uniqueness (OOXML requires globally unique sheet IDs).
+ *   - `r:id` uniqueness and pointing to a worksheet-type relationship.
+ *   - `name` attribute presence and Excel's name constraints:
+ *       · 1–31 characters
+ *       · No characters in `\ / ? * [ ] :`
+ *       · Not repeated case-insensitively
+ *   - CT_Workbook child element ordering (ECMA-376 Part 1 §18.2.27).
+ *     Excel rejects files whose direct children of `<workbook>` violate
+ *     the XSD sequence order.
+ */
+import { attrByLocalName, findChildLocal, findChildrenLocal, localName } from "./xml-utils.js";
+const WORKBOOK_PATH = "xl/workbook.xml";
+const WORKBOOK_RELS_PATH = "xl/_rels/workbook.xml.rels";
+// Excel rejects sheet names that contain any of these characters. Source:
+// https://support.microsoft.com/office/rename-a-worksheet-3f1f7148-ee83-404d-8ef0-9ff99fbad1f9
+const INVALID_SHEET_NAME_CHARS = /[\\/?*[\]:]/;
+const SHEET_NAME_MAX_LEN = 31;
+/**
+ * CT_Workbook child element sequence per ECMA-376 Part 1 §18.2.27.
+ *
+ * Excel strictly enforces this order: any child appearing AFTER another
+ * that should precede it causes the file to be rejected as corrupt
+ * (no repair offered). The list below covers every element in the
+ * standard sequence. Unknown / extension elements (mc:AlternateContent,
+ * extLst, etc.) are ignored — they can appear anywhere without breaking
+ * conformance.
+ */
+const WORKBOOK_CHILD_ORDER = [
+    "fileVersion",
+    "fileSharing",
+    "workbookPr",
+    "workbookProtection",
+    "bookViews",
+    "sheets",
+    "functionGroups",
+    "externalReferences",
+    "definedNames",
+    "calcPr",
+    "oleSize",
+    "customWorkbookViews",
+    "pivotCaches",
+    "smartTagPr",
+    "smartTagTypes",
+    "webPublishing",
+    "fileRecoveryPr",
+    "webPublishObjects",
+    "extLst"
+];
+export function checkWorkbook(ctx) {
+    if (!ctx.has(WORKBOOK_PATH) || !ctx.has(WORKBOOK_RELS_PATH)) {
+        return; // missing-part already reported.
+    }
+    const dom = ctx.readDom(WORKBOOK_PATH, err => {
+        ctx.reporter.error("xml-malformed", `Malformed XML: ${err.message}`, WORKBOOK_PATH);
+    });
+    if (!dom) {
+        return;
+    }
+    const rels = ctx.readRels(WORKBOOK_RELS_PATH);
+    // --- Element order check ---
+    checkWorkbookChildOrder(ctx, dom.root);
+    // --- Sheet checks ---
+    const sheets = findChildLocal(dom.root, "sheets");
+    if (!sheets) {
+        // workbook with zero sheets is handled elsewhere as a structural issue
+        // — here we only care about sheet wiring.
+        return;
+    }
+    const seenSheetId = new Set();
+    const seenSheetRid = new Set();
+    const seenNamesLower = new Set();
+    for (const sheet of findChildrenLocal(sheets, "sheet")) {
+        if (ctx.reporter.capped) {
+            return;
+        }
+        const sheetId = attrByLocalName(sheet, "sheetId");
+        const rid = attrByLocalName(sheet, "id"); // r:id — local name "id"
+        const name = attrByLocalName(sheet, "name");
+        if (sheetId !== undefined) {
+            if (seenSheetId.has(sheetId)) {
+                ctx.reporter.error("workbook-duplicate-sheetId", `Duplicate sheetId in workbook: ${sheetId}`, WORKBOOK_PATH);
+            }
+            else {
+                seenSheetId.add(sheetId);
+            }
+        }
+        if (rid !== undefined) {
+            if (seenSheetRid.has(rid)) {
+                ctx.reporter.error("workbook-duplicate-sheet-rid", `Duplicate sheet r:id in workbook: ${rid}`, WORKBOOK_PATH);
+            }
+            else {
+                seenSheetRid.add(rid);
+            }
+            const rel = rels.byId.get(rid);
+            if (!rel) {
+                ctx.reporter.error("workbook-sheet-missing-rel", `Workbook <sheet> references missing relationship: ${rid} (in ${WORKBOOK_RELS_PATH})`, WORKBOOK_PATH);
+            }
+            else if (!rel.type.includes("/relationships/worksheet") &&
+                !rel.type.includes("/relationships/chartsheet")) {
+                ctx.reporter.error("workbook-sheet-wrong-rel-type", `Workbook <sheet> ${rid} relationship is neither worksheet nor chartsheet: ${rel.type}`, WORKBOOK_PATH);
+            }
+        }
+        if (name === undefined) {
+            ctx.reporter.error("workbook-sheet-missing-name", `Workbook <sheet> (sheetId=${sheetId ?? "?"}) missing name attribute`, WORKBOOK_PATH);
+            continue;
+        }
+        if (name.length === 0 || name.length > SHEET_NAME_MAX_LEN) {
+            ctx.reporter.error("workbook-sheet-name-too-long", `Sheet name "${name}" has ${name.length} characters; Excel limit is ${SHEET_NAME_MAX_LEN}`, WORKBOOK_PATH);
+        }
+        if (INVALID_SHEET_NAME_CHARS.test(name)) {
+            ctx.reporter.error("workbook-sheet-name-invalid-chars", `Sheet name "${name}" contains characters disallowed by Excel (\\ / ? * [ ] :)`, WORKBOOK_PATH);
+        }
+        const lower = name.toLowerCase();
+        if (seenNamesLower.has(lower)) {
+            ctx.reporter.error("workbook-sheet-name-duplicate", `Duplicate sheet name (case-insensitive): "${name}"`, WORKBOOK_PATH);
+        }
+        else {
+            seenNamesLower.add(lower);
+        }
+    }
+}
+/**
+ * Verify that the direct children of `<workbook>` follow the CT_Workbook
+ * XSD sequence. Excel is strict about this and rejects files with
+ * out-of-order elements as unrecoverable corruption.
+ */
+function checkWorkbookChildOrder(ctx, root) {
+    const orderIndex = new Map();
+    for (let i = 0; i < WORKBOOK_CHILD_ORDER.length; i++) {
+        orderIndex.set(WORKBOOK_CHILD_ORDER[i], i);
+    }
+    let maxSeenIdx = -1;
+    let maxSeenName = "";
+    for (const child of root.children) {
+        if (child.type !== "element") {
+            continue;
+        }
+        const local = localName(child.name);
+        const idx = orderIndex.get(local);
+        if (idx === undefined) {
+            // Unknown / extension element — skip (mc:AlternateContent etc.)
+            continue;
+        }
+        if (idx < maxSeenIdx) {
+            ctx.reporter.error("workbook-child-order", `Workbook child element <${local}> appears after <${maxSeenName}>, ` +
+                `violating CT_Workbook sequence order (ECMA-376 §18.2.27). ` +
+                `Excel will reject this file as corrupt.`, WORKBOOK_PATH);
+            // Report only the first violation to avoid noise
+            return;
+        }
+        if (idx > maxSeenIdx) {
+            maxSeenIdx = idx;
+            maxSeenName = local;
+        }
+    }
+}