@rivet-health/design-system 40.9.0 → 40.9.1

package/esm2020/lib/table/table/clipboard.mjs

@@ -0,0 +1,182 @@
+import { sumBy } from 'lodash';
+/**
+ * Clipboard serialization for `riv-table`.
+ *
+ * Rows that have a link render as `<a class="row-link">` rather than `<tr>`, and
+ * the browser's clipboard serializer does not treat those as table rows — the
+ * copied content pastes into a spreadsheet as one lateral run instead of a grid.
+ * These helpers rebuild the rendered grid so that copied content pastes as rows
+ * and columns.
+ */
+export var RivTableClipboard;
+(function (RivTableClipboard) {
+    /** Cells that hold controls rather than data. */
+    const controlCellSelector = 'th.selection-head, th.menu-head, td.selection-body, td.menu-body';
+    /** The column name within a header cell; the rest of the cell is controls. */
+    const headerLabelSelector = '.header-wrapper';
+    /** Elements whose text exists for assistive technology only. */
+    const assistiveTextSelector = 'riv-sr-only';
+    /** Rows that stand in for data rather than carrying it. */
+    const fillerRowSelector = 'riv-zero-state';
+    /** Elements that own their own clipboard behavior. */
+    const editableSelector = 'input, textarea, select, [contenteditable=""], [contenteditable="true"]';
+    /** Whether the copy came from a control that serializes its own value. */
+    function isEditable(target) {
+        return (target instanceof Element && target.closest(editableSelector) !== null);
+    }
+    RivTableClipboard.isEditable = isEditable;
+    /**
+     * Whether `host` is the first element of its kind that the selection touches.
+     * A selection can span several tables; deferring to the first keeps instances
+     * from overwriting each other's clipboard data.
+     */
+    function ownsSelection(host, isSelected) {
+        return (Array.from(document.querySelectorAll(host.localName)).find(element => isSelected(element)) === host);
+    }
+    RivTableClipboard.ownsSelection = ownsSelection;
+    /**
+     * Serializes the selected region of `tables` (one per row group), or null when
+     * the selection covers at most one cell — those are left to the browser so
+     * that copying part of a cell's text keeps working.
+     *
+     * `endpoints` are where the selection starts and ends, which narrow the copied
+     * columns to that span. A selection is a linear range in reading order, so
+     * dragging down one column touches every column in between; the endpoints are
+     * what distinguish "this column" from "these rows".
+     */
+    function extract(tables, isSelected, endpoints = []) {
+        const layouts = tables.map(layout);
+        const columns = selectedColumns(layouts, isSelected, endpoints);
+        const headers = layouts.flatMap(l => l.header);
+        const rows = layouts
+            .flatMap(l => l.body)
+            .filter(row => selectedCount(row, isSelected) > 0);
+        // Header cells own the pointer for column reordering, so a drag cannot
+        // reach them; the header comes along with any copied data instead.
+        const header = headers.find(row => selectedCount(row, isSelected) > 0) ??
+            (rows.length > 0 ? headers[0] : undefined);
+        if (columns.length === 0 ||
+            sumBy([...(header ? [header] : []), ...rows], row => selectedCount(row, isSelected)) < 2)
+            return null;
+        return {
+            text: toText(header, rows, columns),
+            html: toHtml(header, rows, columns),
+        };
+    }
+    RivTableClipboard.extract = extract;
+    function toText(header, rows, columns) {
+        return [
+            ...(header ? [columns.map(column => headerText(header[column]))] : []),
+            ...rows.map(row => columns.map(column => text(row[column]))),
+        ]
+            .map(cells => cells.join('\t'))
+            .join('\n');
+    }
+    function toHtml(header, rows, columns) {
+        const cells = (values, tag) => values.map(value => `<${tag}>${escapeHtml(value)}</${tag}>`).join('');
+        return [
+            '<table>',
+            header
+                ? `<thead><tr>${cells(columns.map(column => headerText(header[column])), 'th')}</tr></thead>`
+                : '',
+            `<tbody>${rows
+                .map(row => `<tr>${cells(columns.map(column => text(row[column])), 'td')}</tr>`)
+                .join('')}</tbody>`,
+            '</table>',
+        ].join('');
+    }
+    function layout(table) {
+        return {
+            header: grid(Array.from(table.querySelectorAll(':scope > thead > tr')).filter(isDataRow)),
+            body: grid(Array.from(table.querySelectorAll(':scope > tbody > tr, :scope > tbody > a.row-link')).filter(isDataRow)),
+        };
+    }
+    /**
+     * Maps rows onto a column grid. Cells covered by a rowspan repeat the spanning
+     * cell so that every line has one value per column, matching how CSV export
+     * flattens spans.
+     */
+    function grid(rows) {
+        const cells = rows.map(() => []);
+        rows.forEach((row, rowIndex) => {
+            let column = 0;
+            for (const cell of dataCells(row)) {
+                while (cells[rowIndex][column] !== undefined)
+                    column++;
+                const rowSpan = Math.max(1, cell.rowSpan);
+                const colSpan = Math.max(1, cell.colSpan);
+                for (let r = rowIndex; r <= Math.min(rows.length - 1, rowIndex + rowSpan - 1); r++)
+                    for (let c = column; c < column + colSpan; c++)
+                        cells[r][c] = cell;
+                column += colSpan;
+            }
+        });
+        return cells;
+    }
+    function dataCells(row) {
+        return Array.from(row.querySelectorAll(':scope > td, :scope > th')).filter(cell => !cell.matches(controlCellSelector));
+    }
+    /** Excludes the zero-state row, which spans every column. */
+    function isDataRow(row) {
+        return (row.querySelector(fillerRowSelector) === null &&
+            dataCells(row).every(cell => cell.colSpan <= 1));
+    }
+    function selectedColumns(layouts, isSelected, endpoints) {
+        const columns = new Set();
+        for (const { header, body } of layouts)
+            for (const row of [...header, ...body])
+                row.forEach((cell, column) => {
+                    if (cell !== undefined && isSelected(cell))
+                        columns.add(column);
+                });
+        const touched = [...columns].sort((a, b) => a - b);
+        // Both ends have to land in a cell to describe a span; anything else (a
+        // select-all, an endpoint on a row rather than a cell) keeps every column.
+        const span = endpoints
+            .map(node => (node ? columnOf(layouts, node) : undefined))
+            .filter((column) => column !== undefined);
+        return span.length === endpoints.length && span.length > 1
+            ? touched.filter(column => column >= Math.min(...span) && column <= Math.max(...span))
+            : touched;
+    }
+    function columnOf(layouts, node) {
+        for (const { header, body } of layouts)
+            for (const row of [...header, ...body]) {
+                const column = row.findIndex(cell => cell?.contains(node) === true);
+                if (column >= 0)
+                    return column;
+            }
+        return undefined;
+    }
+    function selectedCount(row, isSelected) {
+        return row.filter(cell => cell !== undefined && isSelected(cell)).length;
+    }
+    function headerText(cell) {
+        return text(cell?.querySelector(headerLabelSelector) ?? cell);
+    }
+    function text(cell) {
+        return cell ? visibleText(cell).replace(/\s+/g, ' ').trim() : '';
+    }
+    /**
+     * Template indentation lands in the DOM as newlines and runs of spaces, which
+     * split a single row across several spreadsheet rows unless collapsed by the
+     * caller. Comment anchors and screen-reader-only content are dropped, and
+     * sibling nodes are separated so that adjacent elements do not run together.
+     */
+    function visibleText(node) {
+        if (node instanceof Text)
+            return node.nodeValue ?? '';
+        if (node instanceof Element)
+            return node.matches(assistiveTextSelector)
+                ? ''
+                : Array.from(node.childNodes).map(visibleText).join(' ');
+        return '';
+    }
+    function escapeHtml(value) {
+        return value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;');
+    }
+})(RivTableClipboard || (RivTableClipboard = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"clipboard.js","sourceRoot":"","sources":["../../../../../../projects/riv/src/lib/table/table/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B;;;;;;;;GAQG;AACH,MAAM,KAAW,iBAAiB,CA2QjC;AA3QD,WAAiB,iBAAiB;IAChC,iDAAiD;IACjD,MAAM,mBAAmB,GACvB,kEAAkE,CAAC;IAErE,8EAA8E;IAC9E,MAAM,mBAAmB,GAAG,iBAAiB,CAAC;IAE9C,gEAAgE;IAChE,MAAM,qBAAqB,GAAG,aAAa,CAAC;IAE5C,2DAA2D;IAC3D,MAAM,iBAAiB,GAAG,gBAAgB,CAAC;IAE3C,sDAAsD;IACtD,MAAM,gBAAgB,GACpB,yEAAyE,CAAC;IAoB5E,0EAA0E;IAC1E,SAAgB,UAAU,CAAC,MAA0B;QACnD,OAAO,CACL,MAAM,YAAY,OAAO,IAAI,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CACvE,CAAC;IACJ,CAAC;IAJe,4BAAU,aAIzB,CAAA;IAED;;;;OAIG;IACH,SAAgB,aAAa,CAC3B,IAAa,EACb,UAAyB;QAEzB,OAAO,CACL,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CACnE,UAAU,CAAC,OAAO,CAAC,CACpB,KAAK,IAAI,CACX,CAAC;IACJ,CAAC;IATe,+BAAa,gBAS5B,CAAA;IAED;;;;;;;;;OASG;IACH,SAAgB,OAAO,CACrB,MAAmC,EACnC,UAAyB,EACzB,YAAkD,EAAE;QAEpD,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnC,MAAM,OAAO,GAAG,eAAe,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;QAChE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAC/C,MAAM,IAAI,GAAG,OAAO;aACjB,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;aACpB,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;QACrD,uEAAuE;QACvE,mEAAmE;QACnE,MAAM,MAAM,GACV,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;YACvD,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QAE7C,IACE,OAAO,CAAC,MAAM,KAAK,CAAC;YACpB,KAAK,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,CAClD,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,CAC/B,GAAG,CAAC;YAEL,OAAO,IAAI,CAAC;QAEd,OAAO;YACL,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;YACnC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;SACpC,CAAC;IACJ,CAAC;IA7Be,yBAAO,UA6BtB,CAAA;IAED,SAAS,MAAM,CACb,MAAuB,EACvB,IAAoB,EACpB,OAA0B;QAE1B,OAAO;YACL,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YACtE,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;SAC7D;aACE,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAC9B,IAAI,CAAC,IAAI,CAAC,CAAC;IAChB,CAAC;IAED,SAAS,MAAM,CACb,MAAuB,EACvB,IAAoB,EACpB,OAA0B;QAE1B,MAAM,KAAK,GAAG,CAAC,MAAyB,EAAE,GAAgB,EAAE,EAAE,CAC5D,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACxE,OAAO;YACL,SAAS;YACT,MAAM;gBACJ,CAAC,CAAC,cAAc,KAAK,CACjB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EACjD,IAAI,CACL,eAAe;gBAClB,CAAC,CAAC,EAAE;YACN,UAAU,IAAI;iBACX,GAAG,CACF,GAAG,CAAC,EAAE,CACJ,OAAO,KAAK,CACV,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EACxC,IAAI,CACL,OAAO,CACX;iBACA,IAAI,CAAC,EAAE,CAAC,UAAU;YACrB,UAAU;SACX,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IACb,CAAC;IAED,SAAS,MAAM,CAAC,KAAuB;QACrC,OAAO;YACL,MAAM,EAAE,IAAI,CACV,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,qBAAqB,CAAC,CAAC,CAAC,MAAM,CAC9D,SAAS,CACV,CACF;YACD,IAAI,EAAE,IAAI,CACR,KAAK,CAAC,IAAI,CACR,KAAK,CAAC,gBAAgB,CACpB,kDAAkD,CACnD,CACF,CAAC,MAAM,CAAC,SAAS,CAAC,CACpB;SACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,SAAS,IAAI,CAAC,IAAwB;QACpC,MAAM,KAAK,GAA8B,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,QAAQ,EAAE,EAAE;YAC7B,IAAI,MAAM,GAAG,CAAC,CAAC;YACf,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,GAAG,CAAC,EAAE;gBACjC,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,SAAS;oBAAE,MAAM,EAAE,CAAC;gBACvD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;gBAC1C,KACE,IAAI,CAAC,GAAG,QAAQ,EAChB,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,CAAC,CAAC,EACtD,CAAC,EAAE;oBAEH,KAAK,IAAI,CAAC,GAAG,MAAM,EAAE,CAAC,GAAG,MAAM,GAAG,OAAO,EAAE,CAAC,EAAE;wBAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;gBACrE,MAAM,IAAI,OAAO,CAAC;aACnB;QACH,CAAC,CAAC,CAAC;QACH,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,SAAS,CAAC,GAAY;QAC7B,OAAO,KAAK,CAAC,IAAI,CACf,GAAG,CAAC,gBAAgB,CAAuB,0BAA0B,CAAC,CACvE,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC;IACvD,CAAC;IAED,6DAA6D;IAC7D,SAAS,SAAS,CAAC,GAAY;QAC7B,OAAO,CACL,GAAG,CAAC,aAAa,CAAC,iBAAiB,CAAC,KAAK,IAAI;YAC7C,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,CAChD,CAAC;IACJ,CAAC;IAED,SAAS,eAAe,CACtB,OAA0B,EAC1B,UAAyB,EACzB,SAA+C;QAE/C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAClC,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,OAAO;YACpC,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC;gBACpC,GAAG,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;oBAC3B,IAAI,IAAI,KAAK,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC;wBAAE,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBAClE,CAAC,CAAC,CAAC;QACP,MAAM,OAAO,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAEnD,wEAAwE;QACxE,2EAA2E;QAC3E,MAAM,IAAI,GAAG,SAAS;aACnB,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;aACzD,MAAM,CAAC,CAAC,MAAM,EAAoB,EAAE,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC;QAC9D,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;YACxD,CAAC,CAAC,OAAO,CAAC,MAAM,CACZ,MAAM,CAAC,EAAE,CAAC,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,MAAM,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,CACrE;YACH,CAAC,CAAC,OAAO,CAAC;IACd,CAAC;IAED,SAAS,QAAQ,CACf,OAA0B,EAC1B,IAAU;QAEV,KAAK,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,OAAO;YACpC,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE;gBACtC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;gBACpE,IAAI,MAAM,IAAI,CAAC;oBAAE,OAAO,MAAM,CAAC;aAChC;QACH,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,SAAS,aAAa,CAAC,GAAQ,EAAE,UAAyB;QACxD,OAAO,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC;IAC3E,CAAC;IAED,SAAS,UAAU,CAAC,IAAyB;QAC3C,OAAO,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,mBAAmB,CAAC,IAAI,IAAI,CAAC,CAAC;IAChE,CAAC;IAED,SAAS,IAAI,CAAC,IAAgC;QAC5C,OAAO,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IACnE,CAAC;IAED;;;;;OAKG;IACH,SAAS,WAAW,CAAC,IAAU;QAC7B,IAAI,IAAI,YAAY,IAAI;YAAE,OAAO,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;QACtD,IAAI,IAAI,YAAY,OAAO;YACzB,OAAO,IAAI,CAAC,OAAO,CAAC,qBAAqB,CAAC;gBACxC,CAAC,CAAC,EAAE;gBACJ,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,SAAS,UAAU,CAAC,KAAa;QAC/B,OAAO,KAAK;aACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;aACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;aACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC3B,CAAC;AACH,CAAC,EA3QgB,iBAAiB,KAAjB,iBAAiB,QA2QjC","sourcesContent":["import { sumBy } from 'lodash';\n\n/**\n * Clipboard serialization for `riv-table`.\n *\n * Rows that have a link render as `<a class=\"row-link\">` rather than `<tr>`, and\n * the browser's clipboard serializer does not treat those as table rows — the\n * copied content pastes into a spreadsheet as one lateral run instead of a grid.\n * These helpers rebuild the rendered grid so that copied content pastes as rows\n * and columns.\n */\nexport namespace RivTableClipboard {\n  /** Cells that hold controls rather than data. */\n  const controlCellSelector =\n    'th.selection-head, th.menu-head, td.selection-body, td.menu-body';\n\n  /** The column name within a header cell; the rest of the cell is controls. */\n  const headerLabelSelector = '.header-wrapper';\n\n  /** Elements whose text exists for assistive technology only. */\n  const assistiveTextSelector = 'riv-sr-only';\n\n  /** Rows that stand in for data rather than carrying it. */\n  const fillerRowSelector = 'riv-zero-state';\n\n  /** Elements that own their own clipboard behavior. */\n  const editableSelector =\n    'input, textarea, select, [contenteditable=\"\"], [contenteditable=\"true\"]';\n\n  export type Payload = {\n    /** Tab-delimited rows, one line per row. */\n    text: string;\n    /** Equivalent table markup, for targets that prefer rich content. */\n    html: string;\n  };\n\n  /** Predicate for whether a node falls within the user's selection. */\n  export type SelectionTest = (node: Node) => boolean;\n\n  /** A rendered row, holding the cell occupying each data column. */\n  type Row = readonly (Element | undefined)[];\n\n  type Layout = {\n    header: readonly Row[];\n    body: readonly Row[];\n  };\n\n  /** Whether the copy came from a control that serializes its own value. */\n  export function isEditable(target: EventTarget | null): boolean {\n    return (\n      target instanceof Element && target.closest(editableSelector) !== null\n    );\n  }\n\n  /**\n   * Whether `host` is the first element of its kind that the selection touches.\n   * A selection can span several tables; deferring to the first keeps instances\n   * from overwriting each other's clipboard data.\n   */\n  export function ownsSelection(\n    host: Element,\n    isSelected: SelectionTest,\n  ): boolean {\n    return (\n      Array.from(document.querySelectorAll(host.localName)).find(element =>\n        isSelected(element),\n      ) === host\n    );\n  }\n\n  /**\n   * Serializes the selected region of `tables` (one per row group), or null when\n   * the selection covers at most one cell — those are left to the browser so\n   * that copying part of a cell's text keeps working.\n   *\n   * `endpoints` are where the selection starts and ends, which narrow the copied\n   * columns to that span. A selection is a linear range in reading order, so\n   * dragging down one column touches every column in between; the endpoints are\n   * what distinguish \"this column\" from \"these rows\".\n   */\n  export function extract(\n    tables: readonly HTMLTableElement[],\n    isSelected: SelectionTest,\n    endpoints: readonly (Node | null | undefined)[] = [],\n  ): Payload | null {\n    const layouts = tables.map(layout);\n    const columns = selectedColumns(layouts, isSelected, endpoints);\n    const headers = layouts.flatMap(l => l.header);\n    const rows = layouts\n      .flatMap(l => l.body)\n      .filter(row => selectedCount(row, isSelected) > 0);\n    // Header cells own the pointer for column reordering, so a drag cannot\n    // reach them; the header comes along with any copied data instead.\n    const header =\n      headers.find(row => selectedCount(row, isSelected) > 0) ??\n      (rows.length > 0 ? headers[0] : undefined);\n\n    if (\n      columns.length === 0 ||\n      sumBy([...(header ? [header] : []), ...rows], row =>\n        selectedCount(row, isSelected),\n      ) < 2\n    )\n      return null;\n\n    return {\n      text: toText(header, rows, columns),\n      html: toHtml(header, rows, columns),\n    };\n  }\n\n  function toText(\n    header: Row | undefined,\n    rows: readonly Row[],\n    columns: readonly number[],\n  ): string {\n    return [\n      ...(header ? [columns.map(column => headerText(header[column]))] : []),\n      ...rows.map(row => columns.map(column => text(row[column]))),\n    ]\n      .map(cells => cells.join('\\t'))\n      .join('\\n');\n  }\n\n  function toHtml(\n    header: Row | undefined,\n    rows: readonly Row[],\n    columns: readonly number[],\n  ): string {\n    const cells = (values: readonly string[], tag: 'th' | 'td') =>\n      values.map(value => `<${tag}>${escapeHtml(value)}</${tag}>`).join('');\n    return [\n      '<table>',\n      header\n        ? `<thead><tr>${cells(\n            columns.map(column => headerText(header[column])),\n            'th',\n          )}</tr></thead>`\n        : '',\n      `<tbody>${rows\n        .map(\n          row =>\n            `<tr>${cells(\n              columns.map(column => text(row[column])),\n              'td',\n            )}</tr>`,\n        )\n        .join('')}</tbody>`,\n      '</table>',\n    ].join('');\n  }\n\n  function layout(table: HTMLTableElement): Layout {\n    return {\n      header: grid(\n        Array.from(table.querySelectorAll(':scope > thead > tr')).filter(\n          isDataRow,\n        ),\n      ),\n      body: grid(\n        Array.from(\n          table.querySelectorAll(\n            ':scope > tbody > tr, :scope > tbody > a.row-link',\n          ),\n        ).filter(isDataRow),\n      ),\n    };\n  }\n\n  /**\n   * Maps rows onto a column grid. Cells covered by a rowspan repeat the spanning\n   * cell so that every line has one value per column, matching how CSV export\n   * flattens spans.\n   */\n  function grid(rows: readonly Element[]): Row[] {\n    const cells: (Element | undefined)[][] = rows.map(() => []);\n    rows.forEach((row, rowIndex) => {\n      let column = 0;\n      for (const cell of dataCells(row)) {\n        while (cells[rowIndex][column] !== undefined) column++;\n        const rowSpan = Math.max(1, cell.rowSpan);\n        const colSpan = Math.max(1, cell.colSpan);\n        for (\n          let r = rowIndex;\n          r <= Math.min(rows.length - 1, rowIndex + rowSpan - 1);\n          r++\n        )\n          for (let c = column; c < column + colSpan; c++) cells[r][c] = cell;\n        column += colSpan;\n      }\n    });\n    return cells;\n  }\n\n  function dataCells(row: Element): HTMLTableCellElement[] {\n    return Array.from(\n      row.querySelectorAll<HTMLTableCellElement>(':scope > td, :scope > th'),\n    ).filter(cell => !cell.matches(controlCellSelector));\n  }\n\n  /** Excludes the zero-state row, which spans every column. */\n  function isDataRow(row: Element): boolean {\n    return (\n      row.querySelector(fillerRowSelector) === null &&\n      dataCells(row).every(cell => cell.colSpan <= 1)\n    );\n  }\n\n  function selectedColumns(\n    layouts: readonly Layout[],\n    isSelected: SelectionTest,\n    endpoints: readonly (Node | null | undefined)[],\n  ): number[] {\n    const columns = new Set<number>();\n    for (const { header, body } of layouts)\n      for (const row of [...header, ...body])\n        row.forEach((cell, column) => {\n          if (cell !== undefined && isSelected(cell)) columns.add(column);\n        });\n    const touched = [...columns].sort((a, b) => a - b);\n\n    // Both ends have to land in a cell to describe a span; anything else (a\n    // select-all, an endpoint on a row rather than a cell) keeps every column.\n    const span = endpoints\n      .map(node => (node ? columnOf(layouts, node) : undefined))\n      .filter((column): column is number => column !== undefined);\n    return span.length === endpoints.length && span.length > 1\n      ? touched.filter(\n          column => column >= Math.min(...span) && column <= Math.max(...span),\n        )\n      : touched;\n  }\n\n  function columnOf(\n    layouts: readonly Layout[],\n    node: Node,\n  ): number | undefined {\n    for (const { header, body } of layouts)\n      for (const row of [...header, ...body]) {\n        const column = row.findIndex(cell => cell?.contains(node) === true);\n        if (column >= 0) return column;\n      }\n    return undefined;\n  }\n\n  function selectedCount(row: Row, isSelected: SelectionTest): number {\n    return row.filter(cell => cell !== undefined && isSelected(cell)).length;\n  }\n\n  function headerText(cell: Element | undefined): string {\n    return text(cell?.querySelector(headerLabelSelector) ?? cell);\n  }\n\n  function text(cell: Element | undefined | null): string {\n    return cell ? visibleText(cell).replace(/\\s+/g, ' ').trim() : '';\n  }\n\n  /**\n   * Template indentation lands in the DOM as newlines and runs of spaces, which\n   * split a single row across several spreadsheet rows unless collapsed by the\n   * caller. Comment anchors and screen-reader-only content are dropped, and\n   * sibling nodes are separated so that adjacent elements do not run together.\n   */\n  function visibleText(node: Node): string {\n    if (node instanceof Text) return node.nodeValue ?? '';\n    if (node instanceof Element)\n      return node.matches(assistiveTextSelector)\n        ? ''\n        : Array.from(node.childNodes).map(visibleText).join(' ');\n    return '';\n  }\n\n  function escapeHtml(value: string): string {\n    return value\n      .replace(/&/g, '&amp;')\n      .replace(/</g, '&lt;')\n      .replace(/>/g, '&gt;');\n  }\n}\n"]}