@rowsncolumns/toolkit 24.4.1

package/dist/esm/exporter/xlsx/future-functions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Strip the `_xlfn.` / `_xlws.` / `_xludf.` prefixes and re-add the correct
+ * one to every future-function call in `formula`. Quoted spans are copied
+ * verbatim so string literals (`"…"`) and quoted sheet names (`'…'`) keep
+ * their original text; a doubled quote inside a span is an escaped quote.
+ * Because the strip pass runs first, already-qualified input comes out
+ * qualified exactly once.
+ */
+export declare function qualifyFutureFunctions(formula: string): string;
+//# sourceMappingURL=future-functions.d.ts.map

package/dist/esm/exporter/xlsx/future-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"future-functions.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/future-functions.ts"],"names":[],"mappings":"AAkPA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA6B9D"}

package/dist/esm/exporter/xlsx/future-functions.js

@@ -0,0 +1,264 @@
+/**
+ * Excel "future functions" — functions added after the Excel 2007 (.xlsx)
+ * file format was frozen. [MS-XLSX] requires them to be written into sheet
+ * XML behind a `_xlfn.` namespace prefix (`_xlfn._xlws.` for the
+ * worksheet-scoped dynamic-array functions); the UI never shows the prefix.
+ * Written bare, Excel does not resolve the name: it renders the call behind
+ * the implicit-intersection operator (`=@DAYS(...)`) and evaluates `#NAME?`.
+ *
+ * The list follows Microsoft's documentation of `_xlfn.`-prefixed functions
+ * ("Issue: An _xlfn. prefix is displayed in front of a function in a
+ * formula", support.microsoft.com) plus the dynamic-array / LAMBDA-era and
+ * 2024 additions that ship with the same prefix convention.
+ */
+const FUTURE_FUNCTION_NAMES = [
+    "ACOT",
+    "ACOTH",
+    "AGGREGATE",
+    "ANCHORARRAY",
+    "ARABIC",
+    "ARRAYTOTEXT",
+    "BASE",
+    "BETA.DIST",
+    "BETA.INV",
+    "BINOM.DIST",
+    "BINOM.DIST.RANGE",
+    "BINOM.INV",
+    "BITAND",
+    "BITLSHIFT",
+    "BITOR",
+    "BITRSHIFT",
+    "BITXOR",
+    "BYCOL",
+    "BYROW",
+    "CEILING.MATH",
+    "CEILING.PRECISE",
+    "CHISQ.DIST",
+    "CHISQ.DIST.RT",
+    "CHISQ.INV",
+    "CHISQ.INV.RT",
+    "CHISQ.TEST",
+    "CHOOSECOLS",
+    "CHOOSEROWS",
+    "COMBINA",
+    "CONCAT",
+    "CONFIDENCE.NORM",
+    "CONFIDENCE.T",
+    "COT",
+    "COTH",
+    "COVARIANCE.P",
+    "COVARIANCE.S",
+    "CSC",
+    "CSCH",
+    "DAYS",
+    "DECIMAL",
+    "DETECTLANGUAGE",
+    "DROP",
+    "ENCODEURL",
+    "ERF.PRECISE",
+    "ERFC.PRECISE",
+    "EXPAND",
+    "EXPON.DIST",
+    "F.DIST",
+    "F.DIST.RT",
+    "F.INV",
+    "F.INV.RT",
+    "F.TEST",
+    "FIELDVALUE",
+    "FILTER",
+    "FILTERXML",
+    "FLOOR.MATH",
+    "FLOOR.PRECISE",
+    "FORECAST.ETS",
+    "FORECAST.ETS.CONFINT",
+    "FORECAST.ETS.SEASONALITY",
+    "FORECAST.ETS.STAT",
+    "FORECAST.LINEAR",
+    "FORMULATEXT",
+    "GAMMA",
+    "GAMMA.DIST",
+    "GAMMA.INV",
+    "GAMMALN.PRECISE",
+    "GAUSS",
+    "GROUPBY",
+    "HSTACK",
+    "HYPGEOM.DIST",
+    "IFNA",
+    "IFS",
+    "IMAGE",
+    "IMCOSH",
+    "IMCOT",
+    "IMCSC",
+    "IMCSCH",
+    "IMSEC",
+    "IMSECH",
+    "IMSINH",
+    "IMTAN",
+    "ISFORMULA",
+    "ISOMITTED",
+    "ISOWEEKNUM",
+    "LAMBDA",
+    "LET",
+    "LOGNORM.DIST",
+    "LOGNORM.INV",
+    "MAKEARRAY",
+    "MAP",
+    "MAXIFS",
+    "MINIFS",
+    "MODE.MULT",
+    "MODE.SNGL",
+    "MUNIT",
+    "NEGBINOM.DIST",
+    "NETWORKDAYS.INTL",
+    "NORM.DIST",
+    "NORM.INV",
+    "NORM.S.DIST",
+    "NORM.S.INV",
+    "NUMBERVALUE",
+    "PDURATION",
+    "PERCENTILE.EXC",
+    "PERCENTILE.INC",
+    "PERCENTOF",
+    "PERCENTRANK.EXC",
+    "PERCENTRANK.INC",
+    "PERMUTATIONA",
+    "PHI",
+    "PIVOTBY",
+    "POISSON.DIST",
+    "QUARTILE.EXC",
+    "QUARTILE.INC",
+    "QUERYSTRING",
+    "RANDARRAY",
+    "RANK.AVG",
+    "RANK.EQ",
+    "REDUCE",
+    "REGEXEXTRACT",
+    "REGEXREPLACE",
+    "REGEXTEST",
+    "RRI",
+    "SCAN",
+    "SEC",
+    "SECH",
+    "SEQUENCE",
+    "SHEET",
+    "SHEETS",
+    "SINGLE",
+    "SKEW.P",
+    "SORT",
+    "SORTBY",
+    "STDEV.P",
+    "STDEV.S",
+    "STOCKHISTORY",
+    "SWITCH",
+    "T.DIST",
+    "T.DIST.2T",
+    "T.DIST.RT",
+    "T.INV",
+    "T.INV.2T",
+    "T.TEST",
+    "TAKE",
+    "TEXTAFTER",
+    "TEXTBEFORE",
+    "TEXTJOIN",
+    "TEXTSPLIT",
+    "TOCOL",
+    "TOROW",
+    "TRANSLATE",
+    "TRIMRANGE",
+    "UNICHAR",
+    "UNICODE",
+    "UNIQUE",
+    "VALUETOTEXT",
+    "VAR.P",
+    "VAR.S",
+    "VSTACK",
+    "WEBSERVICE",
+    "WEIBULL.DIST",
+    "WORKDAY.INTL",
+    "WRAPCOLS",
+    "WRAPROWS",
+    "XLOOKUP",
+    "XMATCH",
+    "XOR",
+    "Z.TEST",
+];
+/**
+ * Future functions that Excel writes behind the worksheet-scope prefix
+ * (`_xlfn._xlws.`) rather than plain `_xlfn.` — the dynamic-array functions
+ * that also exist as worksheet-only names.
+ */
+const WORKSHEET_SCOPED_FUTURE_FUNCTIONS = new Set([
+    "FILTER",
+    "SORT",
+]);
+const QUALIFIED_BY_NAME = new Map(FUTURE_FUNCTION_NAMES.map((name) => [
+    name,
+    WORKSHEET_SCOPED_FUTURE_FUNCTIONS.has(name)
+        ? `_xlfn._xlws.${name}`
+        : `_xlfn.${name}`,
+]));
+// Longest names first so `T.DIST.2T` wins over `T.DIST`. The match must be
+// followed by `(` — a bare name (e.g. the defined name `DAYS`) is not a call.
+const FUTURE_FUNCTION_REGEX = new RegExp("(" +
+    [...FUTURE_FUNCTION_NAMES]
+        .sort((a, b) => b.length - a.length)
+        .map((name) => name.replace(/\./g, "\\."))
+        .join("|") +
+    ")(\\s*\\()", "gi");
+// `\b` is not enough of a left boundary: it would match the `DAYS` in
+// `_xlfn.DAYS` and in `MYDAYS`. The preceding character is checked by offset
+// instead of being consumed by the pattern, so nested calls
+// (`SORT(FILTER(...))`) still match after the enclosing one.
+const FUTURE_FUNCTION_LEFT_BOUNDARY = /[A-Za-z0-9_.$]/;
+function qualifySegment(segment) {
+    const stripped = segment
+        .replace(/_xlfn\./gi, "")
+        .replace(/_xlws\./gi, "")
+        .replace(/_xludf\./gi, "");
+    return stripped.replace(FUTURE_FUNCTION_REGEX, (match, name, open, offset) => {
+        if (offset > 0 &&
+            FUTURE_FUNCTION_LEFT_BOUNDARY.test(stripped[offset - 1])) {
+            return match;
+        }
+        const qualified = QUALIFIED_BY_NAME.get(name.toUpperCase());
+        return qualified ? qualified + open : match;
+    });
+}
+/**
+ * Strip the `_xlfn.` / `_xlws.` / `_xludf.` prefixes and re-add the correct
+ * one to every future-function call in `formula`. Quoted spans are copied
+ * verbatim so string literals (`"…"`) and quoted sheet names (`'…'`) keep
+ * their original text; a doubled quote inside a span is an escaped quote.
+ * Because the strip pass runs first, already-qualified input comes out
+ * qualified exactly once.
+ */
+export function qualifyFutureFunctions(formula) {
+    let result = "";
+    let segmentStart = 0;
+    let index = 0;
+    while (index < formula.length) {
+        const char = formula[index];
+        if (char !== '"' && char !== "'") {
+            index++;
+            continue;
+        }
+        result += qualifySegment(formula.slice(segmentStart, index));
+        let end = index + 1;
+        while (end < formula.length) {
+            if (formula[end] === char) {
+                if (formula[end + 1] === char) {
+                    end += 2;
+                    continue;
+                }
+                break;
+            }
+            end++;
+        }
+        // An unterminated literal consumes the rest of the formula.
+        const literalEnd = end < formula.length ? end + 1 : formula.length;
+        result += formula.slice(index, literalEnd);
+        index = literalEnd;
+        segmentStart = literalEnd;
+    }
+    return result + qualifySegment(formula.slice(segmentStart));
+}

package/dist/esm/exporter/xlsx/pivot-builder.d.ts

@@ -0,0 +1,58 @@
+/**
+ * XLSX pivot table XML builders — Phase D2.
+ *
+ * Emits two XML families:
+ *   1. xl/pivotTables/pivotTable<N>.xml         — layout
+ *   2. xl/pivotCache/pivotCacheDefinition<N>.xml — field definitions
+ *
+ * `xl/pivotCache/pivotCacheRecords<N>.xml` is intentionally omitted.
+ * We set `refreshOnLoad="1"` so Excel recomputes the cache from the
+ * live source range on open — avoids the "cache stale vs. source"
+ * desync that records would cause.
+ *
+ * INTEGRATION POINTS (need wiring in xlsx-export.ts):
+ *   - Add `pivotTables: PivotTable[]` to ExportExcelProps
+ *   - Group pivots by sheetId, similar to charts/slicers
+ *   - For each pivot:
+ *     • Generate pivotTable XML + pivotCacheDefinition XML
+ *     • Add to zip at xl/pivotTables/pivotTable<N>.xml + xl/pivotCache/pivotCacheDefinition<N>.xml
+ *     • Add pivotTable → pivotCacheDefinition relationship file
+ *     • Add worksheet → pivotTable relationship
+ *     • Add workbook → pivotCacheDefinition relationship (in workbook.xml.rels)
+ *     • Add <pivotCaches> ref in workbook.xml
+ *     • Add ContentTypes overrides for both pivotTable and pivotCacheDefinition
+ *
+ * The slicer-builder integration (lines 1-128 of slicer-builder.ts
+ * + ~100 lines in xlsx-export.ts) is the closest reference template.
+ */
+import type { PivotTable } from "@rowsncolumns/spreadsheet";
+/**
+ * Build pivotCacheDefinition XML for a pivot. The cacheSource
+ * points at the live worksheet range; `refreshOnLoad="1"` makes
+ * Excel rebuild the cache when the user opens the file.
+ *
+ * @param pivot       The PivotTable record
+ * @param sheetName   Name of the sheet containing the source range
+ * @param fieldNames  All source column headers (becomes <cacheFields>)
+ */
+export declare const buildPivotCacheDefinitionXml: (pivot: PivotTable, sheetName: string, fieldNames: string[]) => string | null;
+/**
+ * Build the pivotTable layout XML. Excel determines whether a cell
+ * is a "row label", "column label", or "data" by the field axes
+ * declared here.
+ *
+ * @param pivot         The PivotTable record
+ * @param cacheId       Numeric cache ID (matches workbook.xml's <pivotCaches>)
+ * @param fieldIndices  Maps row/col/value field names → cacheField indices
+ */
+export declare const buildPivotTableXml: (pivot: PivotTable, cacheId: number, fieldIndices: Map<string, number>) => string | null;
+/**
+ * Build the pivotTable.xml.rels file (links the pivot to its
+ * cache definition).
+ *
+ * @param cacheRid  Relationship id (e.g. "rId1")
+ * @param cacheTarget  Path relative to pivotTable, e.g.
+ *                     "../pivotCache/pivotCacheDefinition1.xml"
+ */
+export declare const buildPivotTableRelsXml: (cacheRid: string, cacheTarget: string) => string;
+//# sourceMappingURL=pivot-builder.d.ts.map

package/dist/esm/exporter/xlsx/pivot-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/pivot-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AA4D5D;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACvC,OAAO,UAAU,EACjB,WAAW,MAAM,EACjB,YAAY,MAAM,EAAE,KACnB,MAAM,GAAG,IAgCX,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,UAAU,EACjB,SAAS,MAAM,EACf,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAChC,MAAM,GAAG,IAkHX,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,UAAU,MAAM,EAChB,aAAa,MAAM,KAClB,MAcF,CAAC"}

package/dist/esm/exporter/xlsx/pivot-builder.js

@@ -0,0 +1,230 @@
+import { XMLBuilder } from "fast-xml-parser";
+const xmlBuilder = new XMLBuilder({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    format: true,
+    indentBy: "  ",
+});
+/**
+ * Convert numeric col/row to A1 notation. 1-indexed.
+ * e.g. (1, 1) → "A1", (28, 5) → "AB5".
+ */
+const a1 = (col, row) => {
+    let s = "";
+    let c = col;
+    while (c > 0) {
+        const rem = (c - 1) % 26;
+        s = String.fromCharCode(65 + rem) + s;
+        c = Math.floor((c - 1) / 26);
+    }
+    return `${s}${row}`;
+};
+const rangeRef = (range) => `${a1(range.startColumnIndex, range.startRowIndex)}:${a1(range.endColumnIndex, range.endRowIndex)}`;
+/**
+ * Map our aggFunc → XLSX subtotal attribute.
+ */
+const aggToSubtotal = (agg) => {
+    const map = {
+        sum: "sum",
+        count: "countNums",
+        counta: "count",
+        avg: "average",
+        min: "min",
+        max: "max",
+        product: "product",
+        stddev: "stdDev",
+        stddevp: "stdDevp",
+        var: "var",
+        varp: "varp",
+        median: "average", // No native MEDIAN; fall back so Excel doesn't error.
+        countunique: "count",
+    };
+    return map[agg] ?? "sum";
+};
+/**
+ * Build pivotCacheDefinition XML for a pivot. The cacheSource
+ * points at the live worksheet range; `refreshOnLoad="1"` makes
+ * Excel rebuild the cache when the user opens the file.
+ *
+ * @param pivot       The PivotTable record
+ * @param sheetName   Name of the sheet containing the source range
+ * @param fieldNames  All source column headers (becomes <cacheFields>)
+ */
+export const buildPivotCacheDefinitionXml = (pivot, sheetName, fieldNames) => {
+    if (!pivot.source)
+        return null;
+    const sourceRef = rangeRef(pivot.source);
+    const cacheFields = fieldNames.map((name) => ({
+        "@_name": name,
+        sharedItems: { "@_count": "0" },
+    }));
+    const doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        pivotCacheDefinition: {
+            "@_xmlns": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+            "@_xmlns:r": "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
+            "@_invalid": "1",
+            "@_refreshOnLoad": "1",
+            "@_refreshedBy": "Rows n Columns",
+            "@_recordCount": "0",
+            cacheSource: {
+                "@_type": "worksheet",
+                worksheetSource: {
+                    "@_ref": sourceRef,
+                    "@_sheet": sheetName,
+                },
+            },
+            cacheFields: {
+                "@_count": String(cacheFields.length),
+                cacheField: cacheFields,
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};
+/**
+ * Build the pivotTable layout XML. Excel determines whether a cell
+ * is a "row label", "column label", or "data" by the field axes
+ * declared here.
+ *
+ * @param pivot         The PivotTable record
+ * @param cacheId       Numeric cache ID (matches workbook.xml's <pivotCaches>)
+ * @param fieldIndices  Maps row/col/value field names → cacheField indices
+ */
+export const buildPivotTableXml = (pivot, cacheId, fieldIndices) => {
+    if (!pivot.pivotRange)
+        return null;
+    const ref = rangeRef(pivot.pivotRange);
+    // pivotFields: one entry per cacheField, with axis attribute
+    // (axisRow / axisCol / dataField). Order = cacheField order.
+    const pivotFields = [];
+    // We don't know the full field universe here without the source
+    // schema. Best-effort: declare entries for the union of row/col/
+    // value fields and tag with the appropriate axis.
+    const fieldAxis = new Map();
+    for (const r of pivot.rows ?? []) {
+        const idx = fieldIndices.get(r.field);
+        if (idx != null)
+            fieldAxis.set(idx, "axisRow");
+    }
+    for (const c of pivot.columns ?? []) {
+        const idx = fieldIndices.get(c.field);
+        if (idx != null)
+            fieldAxis.set(idx, "axisCol");
+    }
+    for (const v of pivot.values ?? []) {
+        const idx = fieldIndices.get(v.field);
+        if (idx != null)
+            fieldAxis.set(idx, "dataField");
+    }
+    // Need to emit one <pivotField> per cacheField in order, even
+    // for unused fields (Excel requires the array shapes match).
+    // Caller passes us the full field set via fieldIndices.
+    const sortedFieldIndices = [...fieldIndices.entries()].sort((a, b) => a[1] - b[1]);
+    for (const [, idx] of sortedFieldIndices) {
+        const axis = fieldAxis.get(idx);
+        if (axis) {
+            pivotFields.push({ "@_axis": axis, "@_compact": "0", items: {} });
+        }
+        else {
+            pivotFields.push({ "@_compact": "0" });
+        }
+    }
+    const rowFields = (pivot.rows ?? [])
+        .map((r) => fieldIndices.get(r.field))
+        .filter((i) => i != null)
+        .map((i) => ({ "@_x": String(i) }));
+    const colFields = (pivot.columns ?? [])
+        .map((c) => fieldIndices.get(c.field))
+        .filter((i) => i != null)
+        .map((i) => ({ "@_x": String(i) }));
+    const dataFields = (pivot.values ?? [])
+        .map((v) => {
+        const idx = fieldIndices.get(v.field);
+        if (idx == null)
+            return null;
+        return {
+            "@_name": v.displayName ?? `${v.aggFunc} of ${v.field}`,
+            "@_fld": String(idx),
+            "@_subtotal": aggToSubtotal(v.aggFunc),
+        };
+    })
+        .filter((d) => d !== null);
+    const doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        pivotTableDefinition: {
+            "@_xmlns": "http://schemas.openxmlformats.org/spreadsheetml/2006/main",
+            "@_name": pivot.name ?? `PivotTable${pivot.pivotId}`,
+            "@_cacheId": String(cacheId),
+            "@_dataOnRows": "0",
+            "@_applyNumberFormats": "0",
+            "@_applyBorderFormats": "0",
+            "@_applyFontFormats": "0",
+            "@_applyPatternFormats": "0",
+            "@_applyAlignmentFormats": "0",
+            "@_applyWidthHeightFormats": "1",
+            "@_dataCaption": "Values",
+            "@_updatedVersion": "8",
+            "@_minRefreshableVersion": "3",
+            "@_showCalcMbrs": "0",
+            "@_useAutoFormatting": "1",
+            "@_itemPrintTitles": "1",
+            "@_createdVersion": "8",
+            "@_indent": "0",
+            "@_outline": "1",
+            "@_outlineData": "1",
+            "@_multipleFieldFilters": "0",
+            "@_rowGrandTotals": pivot.showRowGrandTotals === false ? "0" : "1",
+            "@_colGrandTotals": pivot.showColumnGrandTotals === false ? "0" : "1",
+            location: {
+                "@_ref": ref,
+                "@_firstHeaderRow": "1",
+                "@_firstDataRow": "1",
+                "@_firstDataCol": "1",
+            },
+            pivotFields: pivotFields.length
+                ? { "@_count": String(pivotFields.length), pivotField: pivotFields }
+                : undefined,
+            rowFields: rowFields.length
+                ? { "@_count": String(rowFields.length), field: rowFields }
+                : undefined,
+            colFields: colFields.length
+                ? { "@_count": String(colFields.length), field: colFields }
+                : undefined,
+            dataFields: dataFields.length
+                ? { "@_count": String(dataFields.length), dataField: dataFields }
+                : undefined,
+            pivotTableStyleInfo: {
+                "@_name": "PivotStyleLight16",
+                "@_showRowHeaders": "1",
+                "@_showColHeaders": "1",
+                "@_showRowStripes": "0",
+                "@_showColStripes": "0",
+                "@_showLastColumn": "1",
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};
+/**
+ * Build the pivotTable.xml.rels file (links the pivot to its
+ * cache definition).
+ *
+ * @param cacheRid  Relationship id (e.g. "rId1")
+ * @param cacheTarget  Path relative to pivotTable, e.g.
+ *                     "../pivotCache/pivotCacheDefinition1.xml"
+ */
+export const buildPivotTableRelsXml = (cacheRid, cacheTarget) => {
+    const doc = {
+        "?xml": { "@_version": "1.0", "@_encoding": "UTF-8", "@_standalone": "yes" },
+        Relationships: {
+            "@_xmlns": "http://schemas.openxmlformats.org/package/2006/relationships",
+            Relationship: {
+                "@_Id": cacheRid,
+                "@_Type": "http://schemas.openxmlformats.org/officeDocument/2006/relationships/pivotCacheDefinition",
+                "@_Target": cacheTarget,
+            },
+        },
+    };
+    return xmlBuilder.build(doc);
+};

package/dist/esm/exporter/xlsx/power-query-builder.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Power Query part re-emission — the export half of the parser's `getPowerQuery()` preservation,
+ * and the JS mirror of the Rust engine's `rnc-export` `inject_power_query` pass (same rules, same
+ * envelope shape).
+ *
+ * Runs as a post-pass over the exporter's assembled `files` map (just before zipping):
+ *
+ * - `customXml/item{N}.xml` (the `<DataMashup>` blob) + `customXml/itemProps{N}.xml` + the item's
+ *   rels, related from `xl/workbook.xml`.
+ * - `xl/connections.xml`, verbatim.
+ * - `xl/queryTables/queryTable{N}.xml`, re-attached to the regenerated table part when the exported
+ *   table still matches the imported one (same `displayName`, same ordered column names): the table
+ *   part gains `tableType="queryTable"`, its `<tableColumn>`s get their ORIGINAL ids back (the
+ *   verbatim queryTable part references them) plus their `queryTableFieldId`s, and a
+ *   table→queryTable rel is written. A table that was renamed or had columns
+ *   added/removed/reordered degrades to a plain table (its queryTable part is dropped) while the
+ *   query itself (DataMashup + connection) still round-trips — Excel's own
+ *   connection-without-load-target state.
+ */
+import { type PowerQueryParts } from "../../power-query";
+/**
+ * Apply the preserved Power Query parts onto the exporter's `files` map (part name → bytes).
+ * No-op when the envelope is empty, keeping every other export byte-for-byte unchanged.
+ */
+export declare const applyPowerQueryParts: (files: Record<string, Uint8Array>, powerQuery: PowerQueryParts | null | undefined) => void;
+//# sourceMappingURL=power-query-builder.d.ts.map

package/dist/esm/exporter/xlsx/power-query-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-query-builder.d.ts","sourceRoot":"","sources":["../../../../exporter/xlsx/power-query-builder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,mBAAmB,CAAC;AAuB3B;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAC/B,OAAO,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EACjC,YAAY,eAAe,GAAG,IAAI,GAAG,SAAS,KAC7C,IAqHF,CAAC"}