js.documents 14.4.56 → 14.4.57

package/dist/edit/odt/table.js

@@ -1,647 +1,2 @@
-import { el } from "../../xml/fragment.js";
-import { removeAttr, removeChild, setAttr } from "../../xml/edit.js";
-import { resolveLiveTableGrid } from "../table-grid.js";
-import { ensureAutomaticStyles, nextStyleName } from "./automatic-styles.js";
-import { OdtParagraph, buildParagraph } from "./paragraph.js";
-import { COLUMN_REPEAT_ATTR, collectRunMembers, isCellOrCoveredCell, readRunRepeatCount, replaceRun } from "../odf-repeated-runs.js";
-import { attr } from "ooxml.js";
-import { tableCellColumnSpan, tableCellRowSpan } from "document-schema.js";
-import { findStyleElement, formatOdfColor, formatOdfLength, parseOdfColor, parseOdfLength } from "odf.js";
-//#region src/edit/odt/table.ts
-const DEFAULT_TABLE_WIDTH_PT = 468;
-const TABLE_COLUMN_STYLE_PREFIX = "OdtCol";
-const TABLE_CELL_STYLE_PREFIX = "OdtCell";
-const TABLE_ROW_STYLE_PREFIX = "OdtRow";
-const BORDER_EDGE_ATTRS = {
-	top: "fo:border-top",
-	right: "fo:border-right",
-	bottom: "fo:border-bottom",
-	left: "fo:border-left"
-};
-function formatBorderShorthand(color, widthPt, style) {
-	return `${formatOdfLength(widthPt)} ${style ?? "solid"} ${formatOdfColor(color)}`;
-}
-function findCellPropertiesReadOnly(pkg, element) {
-	const styleName = attr(element, "table:style-name");
-	if (styleName === void 0) return;
-	const part = pkg.parts["content.xml"];
-	const root = part?.kind === "xml" ? part.nodes.find((n) => n.type === "element") : void 0;
-	if (root === void 0) return;
-	for (const child of root.children) if (child.type === "element" && child.tag === "office:automatic-styles") {
-		for (const style of child.children) if (style.type === "element" && style.tag === "style:style" && attr(style, "style:name") === styleName && attr(style, "style:family") === "table-cell") {
-			for (const props of style.children) if (props.type === "element" && props.tag === "style:table-cell-properties") return props;
-		}
-	}
-}
-function readCellDecoration(pkg, element) {
-	const props = findCellPropertiesReadOnly(pkg, element);
-	if (props === void 0) return {};
-	let background;
-	const backgroundValue = attr(props, "fo:background-color");
-	if (backgroundValue !== void 0) background = parseOdfColor(backgroundValue);
-	const borders = {};
-	[
-		"top",
-		"right",
-		"bottom",
-		"left"
-	].forEach((edge) => {
-		const raw = attr(props, BORDER_EDGE_ATTRS[edge]);
-		if (raw === void 0) return;
-		const tokens = raw.trim().split(/\s+/);
-		const widthToken = tokens[0];
-		const styleToken = tokens[1];
-		const colorToken = tokens[2];
-		if (widthToken === void 0 || styleToken === void 0 || colorToken === void 0 || styleToken === "none" || styleToken === "hidden") return;
-		const widthPt = parseOdfLength(widthToken);
-		const color = parseOdfColor(colorToken);
-		if (widthPt === void 0 || widthPt <= 0 || color === void 0) return;
-		const style = styleToken === "solid" || styleToken === "dashed" || styleToken === "dotted" || styleToken === "double" ? styleToken : void 0;
-		borders[edge] = style === void 0 ? {
-			color,
-			widthPt
-		} : {
-			color,
-			widthPt,
-			style
-		};
-	});
-	return {
-		background,
-		borders: Object.keys(borders).length === 0 ? void 0 : borders
-	};
-}
-function buildCellStyle(pkg, decoration) {
-	const automaticStyles = ensureAutomaticStyles(pkg);
-	const name = nextStyleName(automaticStyles, "style:style", TABLE_CELL_STYLE_PREFIX);
-	const propsAttrs = {};
-	if (decoration.background !== void 0) propsAttrs["fo:background-color"] = formatOdfColor(decoration.background);
-	if (decoration.borders !== void 0) [
-		"top",
-		"right",
-		"bottom",
-		"left"
-	].forEach((edge) => {
-		const border = decoration.borders[edge];
-		if (border !== void 0) propsAttrs[BORDER_EDGE_ATTRS[edge]] = formatBorderShorthand(border.color, border.widthPt, border.style);
-	});
-	const properties = Object.keys(propsAttrs).length === 0 ? [] : [el("style:table-cell-properties", propsAttrs)];
-	automaticStyles.children.push(el("style:style", {
-		"style:name": name,
-		"style:family": "table-cell"
-	}, properties));
-	return name;
-}
-function internTableColumnWidth(pkg, widthPt) {
-	const automaticStyles = ensureAutomaticStyles(pkg);
-	const formatted = formatOdfLength(widthPt, "pt");
-	for (const child of automaticStyles.children) {
-		if (child.type !== "element" || child.tag !== "style:style" || attr(child, "style:family") !== "table-column") continue;
-		const props = child.children.find((c) => c.type === "element" && c.tag === "style:table-column-properties");
-		if (props !== void 0 && attr(props, "style:column-width") === formatted) {
-			const existingName = attr(child, "style:name");
-			if (existingName !== void 0) return existingName;
-		}
-	}
-	const name = nextStyleName(automaticStyles, "style:style", TABLE_COLUMN_STYLE_PREFIX);
-	automaticStyles.children.push(el("style:style", {
-		"style:name": name,
-		"style:family": "table-column"
-	}, [el("style:table-column-properties", { "style:column-width": formatted })]));
-	return name;
-}
-function currentRowPropertiesElement(pkg, rowElement) {
-	const styleName = attr(rowElement, "table:style-name");
-	const styleElement = styleName === void 0 ? void 0 : findStyleElement(styleName, "table-row", pkg);
-	return styleElement === void 0 ? void 0 : styleElement.children.find((c) => c.type === "element" && c.tag === "style:table-row-properties");
-}
-function cloneCurrentRowProperties(pkg, rowElement) {
-	const props = currentRowPropertiesElement(pkg, rowElement);
-	return props === void 0 ? el("style:table-row-properties") : structuredClone(props);
-}
-function xmlNodesEqual(a, b) {
-	if (a.type === "element" && b.type === "element") return xmlElementsEqual(a, b);
-	if (a.type === "text" && b.type === "text") return a.value === b.value;
-	if (a.type === "cdata" && b.type === "cdata") return a.value === b.value;
-	if (a.type === "comment" && b.type === "comment") return a.value === b.value;
-	return false;
-}
-function xmlElementsEqual(a, b) {
-	if (a.tag !== b.tag || a.attributes.length !== b.attributes.length) return false;
-	if (!a.attributes.every((candidate) => attr(b, candidate.name) === candidate.value)) return false;
-	if (a.children.length !== b.children.length) return false;
-	for (let index = 0; index < a.children.length; index++) {
-		const childA = a.children[index];
-		const childB = b.children[index];
-		if (childA === void 0 || childB === void 0) return false;
-		if (!xmlNodesEqual(childA, childB)) return false;
-	}
-	return true;
-}
-function internTableRowProperties(pkg, properties) {
-	const automaticStyles = ensureAutomaticStyles(pkg);
-	for (const child of automaticStyles.children) {
-		if (child.type !== "element" || child.tag !== "style:style" || attr(child, "style:family") !== "table-row") continue;
-		const props = child.children.find((c) => c.type === "element" && c.tag === "style:table-row-properties");
-		if (props !== void 0 && xmlElementsEqual(props, properties)) {
-			const existingName = attr(child, "style:name");
-			if (existingName !== void 0) return existingName;
-		}
-	}
-	const name = nextStyleName(automaticStyles, "style:style", TABLE_ROW_STYLE_PREFIX);
-	automaticStyles.children.push(el("style:style", {
-		"style:name": name,
-		"style:family": "table-row"
-	}, [properties]));
-	return name;
-}
-var OdtTableCell = class {
-	node;
-	pkg;
-	constructor(node, pkg) {
-		this.node = node;
-		this.pkg = pkg;
-	}
-	paragraphs() {
-		const out = [];
-		for (const child of this.node.children) if (child.type === "element" && (child.tag === "text:p" || child.tag === "text:h")) out.push(new OdtParagraph(this.node.children, child, this.pkg));
-		return out;
-	}
-	appendParagraph(init) {
-		const paragraphElement = buildParagraph(this.pkg, init);
-		this.node.children.push(paragraphElement);
-		return new OdtParagraph(this.node.children, paragraphElement, this.pkg);
-	}
-	get text() {
-		return this.paragraphs().map((p) => p.text).join("\n");
-	}
-	get colSpan() {
-		const raw = attr(this.node, "table:number-columns-spanned");
-		return raw === void 0 ? void 0 : Number(raw);
-	}
-	set colSpan(value) {
-		if (value === void 0) {
-			removeAttr(this.node, "table:number-columns-spanned");
-			return;
-		}
-		setAttr(this.node, "table:number-columns-spanned", String(value));
-	}
-	get rowSpan() {
-		const raw = attr(this.node, "table:number-rows-spanned");
-		return raw === void 0 ? void 0 : Number(raw);
-	}
-	set rowSpan(value) {
-		if (value === void 0) {
-			removeAttr(this.node, "table:number-rows-spanned");
-			return;
-		}
-		setAttr(this.node, "table:number-rows-spanned", String(value));
-	}
-	get background() {
-		return readCellDecoration(this.pkg, this.node).background;
-	}
-	set background(value) {
-		writeCellBackground(this.pkg, this.node, value);
-	}
-	get borders() {
-		return readCellDecoration(this.pkg, this.node).borders;
-	}
-	set borders(value) {
-		writeCellBorders(this.pkg, this.node, value);
-	}
-};
-function writeCellBackground(pkg, node, value) {
-	const name = buildCellStyle(pkg, {
-		background: value,
-		borders: readCellDecoration(pkg, node).borders
-	});
-	setAttr(node, "table:style-name", name);
-}
-function writeCellBorders(pkg, node, value) {
-	const name = buildCellStyle(pkg, {
-		background: readCellDecoration(pkg, node).background,
-		borders: value
-	});
-	setAttr(node, "table:style-name", name);
-}
-var OdtCoveredTableCell = class {
-	node;
-	pkg;
-	constructor(node, pkg) {
-		this.node = node;
-		this.pkg = pkg;
-	}
-	get background() {
-		return readCellDecoration(this.pkg, this.node).background;
-	}
-	set background(value) {
-		writeCellBackground(this.pkg, this.node, value);
-	}
-	get borders() {
-		return readCellDecoration(this.pkg, this.node).borders;
-	}
-	set borders(value) {
-		writeCellBorders(this.pkg, this.node, value);
-	}
-};
-const COVERED_CELL_KEPT_ATTRIBUTE = "table:style-name";
-function retagAsCovered(element) {
-	element.tag = "table:covered-table-cell";
-	element.attributes = element.attributes.filter((attribute) => attribute.name === COVERED_CELL_KEPT_ATTRIBUTE);
-	element.children = [];
-}
-function gridColumnElements(row) {
-	const out = [];
-	let columnIndex = 0;
-	for (const member of collectRunMembers(row.children, isCellOrCoveredCell, void 0)) {
-		const repeat = readRunRepeatCount(member.node, COLUMN_REPEAT_ATTR);
-		for (let offset = 0; offset < repeat; offset++) out.push({
-			columnIndex: columnIndex + offset,
-			element: member.node
-		});
-		columnIndex += repeat;
-	}
-	return out;
-}
-function rowGridColumnCount(row) {
-	return collectRunMembers(row.children, isCellOrCoveredCell, void 0).reduce((sum, member) => sum + readRunRepeatCount(member.node, COLUMN_REPEAT_ATTR), 0);
-}
-function locateGridColumnElement(row, columnIndex) {
-	if (columnIndex < 0) return;
-	let cursor = 0;
-	for (const member of collectRunMembers(row.children, isCellOrCoveredCell, void 0)) {
-		const count = readRunRepeatCount(member.node, COLUMN_REPEAT_ATTR);
-		if (columnIndex < cursor + count) return member.node;
-		cursor += count;
-	}
-}
-function individuateGridColumn(row, columnIndex) {
-	return replaceRun(row.children, isCellOrCoveredCell, columnIndex, COLUMN_REPEAT_ATTR, () => {
-		throw new Error(`individuateGridColumn: column ${columnIndex} has no existing element to individuate in this row — callers must bounds-check against rowGridColumnCount first`);
-	});
-}
-function tableRowElements(table) {
-	return tableRowEntries(table).map((entry) => entry.element);
-}
-function placedCells(row, pkg) {
-	return gridColumnElements(row).flatMap(({ columnIndex, element }) => {
-		if (element.tag !== "table:table-cell") return [];
-		const cell = new OdtTableCell(element, pkg);
-		return [{
-			columnIndex,
-			cell,
-			colSpan: cell.colSpan,
-			rowSpan: cell.rowSpan
-		}];
-	});
-}
-function resolveOdtGrid(table, pkg) {
-	const placedRows = [];
-	let declaredColumns = 0;
-	for (const column of tableColumnElements(table)) declaredColumns += readRunRepeatCount(column, COLUMN_REPEAT_ATTR);
-	for (const row of tableRowElements(table)) placedRows.push(placedCells(row, pkg));
-	return resolveLiveTableGrid(placedRows, declaredColumns);
-}
-function regionCovers(region, rowIndex, columnIndex) {
-	return region.row <= rowIndex && rowIndex < region.row + region.rowSpan && region.column <= columnIndex && columnIndex < region.column + region.columnSpan;
-}
-function regionsIntersect(a, b) {
-	return a.row < b.row + b.rowSpan && b.row < a.row + a.rowSpan && a.column < b.column + b.columnSpan && b.column < a.column + a.columnSpan;
-}
-function regionContains(outer, inner) {
-	return outer.row <= inner.row && outer.column <= inner.column && inner.row + inner.rowSpan <= outer.row + outer.rowSpan && inner.column + inner.columnSpan <= outer.column + outer.columnSpan;
-}
-function anchorRegions(grid) {
-	return grid.rows.flatMap((positions, row) => positions.flatMap((position, column) => {
-		if (position?.isAnchor !== true) return [];
-		const spans = {
-			blocks: [],
-			colSpan: position.cell.colSpan,
-			rowSpan: position.cell.rowSpan
-		};
-		return [{
-			row,
-			column,
-			rowSpan: tableCellRowSpan(spans),
-			columnSpan: tableCellColumnSpan(spans)
-		}];
-	}));
-}
-function isUnchangedAnchor(region, target) {
-	return target.rowSpan === 1 && region.column === target.column && region.columnSpan === target.columnSpan;
-}
-function describeRegionAnchor(region) {
-	return `the merge anchored at row ${region.row}, column ${region.column}`;
-}
-function refuseMerge(rowIndex, reason) {
-	return { refusal: {
-		rowIndex,
-		reason
-	} };
-}
-function planMerge(table, pkg, target, rows) {
-	const [anchorRow, ...coveredRows] = rows;
-	const anchorElement = locateGridColumnElement(anchorRow, target.column);
-	if (anchorElement === void 0) return refuseMerge(target.row, `column ${target.column} does not exist in this row`);
-	const endColumn = target.column + target.columnSpan;
-	for (const [offset, row] of rows.entries()) {
-		const totalColumns = rowGridColumnCount(row);
-		if (endColumn > totalColumns) return refuseMerge(target.row + offset, `colSpan ${target.columnSpan} starting at column ${target.column} exceeds this row's own ${totalColumns} grid columns`);
-	}
-	const regions = anchorRegions(resolveOdtGrid(table, pkg));
-	if (anchorElement.tag === "table:covered-table-cell") {
-		const covering = regions.find((region) => regionCovers(region, target.row, target.column));
-		return refuseMerge(target.row, covering === void 0 ? `column ${target.column} is a covered position that no merge anchors` : `column ${target.column} is covered by ${describeRegionAnchor(covering)}`);
-	}
-	const cutting = regions.find((region) => regionsIntersect(region, target) && !regionContains(target, region) && !isUnchangedAnchor(region, target));
-	if (cutting !== void 0) {
-		const column = Math.max(cutting.column, target.column);
-		return refuseMerge(Math.max(cutting.row, target.row), `column ${column} belongs to ${describeRegionAnchor(cutting)}, which reaches outside the region being merged and cannot be merged over`);
-	}
-	const consumed = [];
-	for (let column = target.column + 1; column < endColumn; column++) consumed.push({
-		row: anchorRow,
-		column
-	});
-	for (const row of coveredRows) for (let column = target.column; column < endColumn; column++) consumed.push({
-		row,
-		column
-	});
-	return {
-		anchor: {
-			row: anchorRow,
-			column: target.column
-		},
-		consumed
-	};
-}
-function applyMerge(plan, target, pkg) {
-	for (const position of plan.consumed) retagAsCovered(individuateGridColumn(position.row, position.column));
-	const anchor = new OdtTableCell(individuateGridColumn(plan.anchor.row, plan.anchor.column), pkg);
-	anchor.colSpan = target.columnSpan;
-	if (target.rowSpan > 1) anchor.rowSpan = target.rowSpan;
-	return anchor;
-}
-const ROW_WRAPPER_TAGS = /* @__PURE__ */ new Set([
-	"table:table-rows",
-	"table:table-header-rows",
-	"table:table-row-group"
-]);
-function tableRowEntries(parent, insideHeader = false) {
-	const entries = [];
-	for (const child of parent.children) {
-		if (child.type !== "element") continue;
-		if (child.tag === "table:table-row") entries.push({
-			element: child,
-			insideHeader
-		});
-		else if (ROW_WRAPPER_TAGS.has(child.tag)) entries.push(...tableRowEntries(child, insideHeader || child.tag === "table:table-header-rows"));
-	}
-	return entries;
-}
-const COLUMN_WRAPPER_TAGS = /* @__PURE__ */ new Set([
-	"table:table-columns",
-	"table:table-header-columns",
-	"table:table-column-group"
-]);
-function tableColumnEntries(parent, insideHeader = false) {
-	const entries = [];
-	for (const child of parent.children) {
-		if (child.type !== "element") continue;
-		if (child.tag === "table:table-column") entries.push({
-			element: child,
-			insideHeader
-		});
-		else if (COLUMN_WRAPPER_TAGS.has(child.tag)) entries.push(...tableColumnEntries(child, insideHeader || child.tag === "table:table-header-columns"));
-	}
-	return entries;
-}
-function tableColumnElements(table) {
-	return tableColumnEntries(table).map((entry) => entry.element);
-}
-var OdtTableRow = class {
-	node;
-	pkg;
-	table;
-	constructor(node, pkg, table) {
-		this.node = node;
-		this.pkg = pkg;
-		this.table = table;
-	}
-	cells() {
-		const out = [];
-		for (const child of this.node.children) if (child.type === "element" && child.tag === "table:table-cell") out.push(new OdtTableCell(child, this.pkg));
-		return out;
-	}
-	get heightPt() {
-		const props = currentRowPropertiesElement(this.pkg, this.node);
-		const raw = props === void 0 ? void 0 : attr(props, "style:row-height");
-		return raw === void 0 ? void 0 : parseOdfLength(raw);
-	}
-	set heightPt(value) {
-		const props = cloneCurrentRowProperties(this.pkg, this.node);
-		if (value === void 0) removeAttr(props, "style:row-height");
-		else {
-			setAttr(props, "style:row-height", formatOdfLength(value, "pt"));
-			if (attr(props, "style:use-optimal-row-height") === "true") setAttr(props, "style:use-optimal-row-height", "false");
-		}
-		if (props.attributes.length === 0 && props.children.length === 0) {
-			removeAttr(this.node, "table:style-name");
-			return;
-		}
-		setAttr(this.node, "table:style-name", internTableRowProperties(this.pkg, props));
-	}
-	appendCell() {
-		const cellElement = buildCell(this.pkg);
-		this.node.children.push(cellElement);
-		return new OdtTableCell(cellElement, this.pkg);
-	}
-	appendCoveredCell() {
-		const coveredElement = el("table:covered-table-cell");
-		this.node.children.push(coveredElement);
-		return new OdtCoveredTableCell(coveredElement, this.pkg);
-	}
-	mergeCellsHorizontally(startColumnIndex, colSpan) {
-		if (!Number.isInteger(colSpan) || colSpan < 1) throw new Error(`mergeCellsHorizontally: colSpan must be a positive integer, got ${colSpan}`);
-		const target = {
-			row: tableRowElements(this.table).indexOf(this.node),
-			column: startColumnIndex,
-			rowSpan: 1,
-			columnSpan: colSpan
-		};
-		const plan = planMerge(this.table, this.pkg, target, [this.node]);
-		if (plan.refusal !== void 0) throw new Error(`mergeCellsHorizontally: ${plan.refusal.reason}`);
-		return applyMerge(plan, target, this.pkg);
-	}
-	markCellCovered(columnIndex) {
-		const totalColumns = rowGridColumnCount(this.node);
-		if (columnIndex < 0 || columnIndex >= totalColumns) throw new Error(`markCellCovered: column ${columnIndex} does not exist in this row`);
-		const rowIndex = tableRowElements(this.table).indexOf(this.node);
-		const anchored = anchorRegions(resolveOdtGrid(this.table, this.pkg)).find((region) => region.row === rowIndex && region.column === columnIndex && (region.rowSpan > 1 || region.columnSpan > 1));
-		if (anchored !== void 0) throw new Error(`markCellCovered: column ${columnIndex} anchors a merge with rowSpan ${anchored.rowSpan} and colSpan ${anchored.columnSpan}, so covering it would leave the rest of that merge without an anchor`);
-		retagAsCovered(individuateGridColumn(this.node, columnIndex));
-	}
-};
-function buildCell(pkg) {
-	return el("table:table-cell", {}, [buildParagraph(pkg)]);
-}
-function buildRow(pkg, columnCount) {
-	const cells = [];
-	for (let i = 0; i < columnCount; i++) cells.push(buildCell(pkg));
-	return el("table:table-row", {}, cells);
-}
-var OdtTable = class {
-	container;
-	node;
-	pkg;
-	removed = false;
-	constructor(container, node, pkg) {
-		this.container = container;
-		this.node = node;
-		this.pkg = pkg;
-	}
-	live() {
-		if (this.removed) throw new Error("this OdtTable has been removed and can no longer be used");
-		return this.node;
-	}
-	rows() {
-		return tableRowElements(this.live()).map((row) => new OdtTableRow(row, this.pkg, this.node));
-	}
-	headerRows() {
-		return tableRowEntries(this.live()).map((entry) => entry.insideHeader);
-	}
-	setHeaderRows(flags) {
-		const table = this.live();
-		const rows = tableRowElements(table);
-		const regrouped = [];
-		let run = [];
-		const closeRun = () => {
-			if (run.length > 0) {
-				regrouped.push(el("table:table-header-rows", {}, run));
-				run = [];
-			}
-		};
-		rows.forEach((row, index) => {
-			if (flags[index] === true) {
-				run.push(row);
-				return;
-			}
-			closeRun();
-			regrouped.push(row);
-		});
-		closeRun();
-		const rest = [];
-		let placed = false;
-		for (const child of table.children) {
-			if (!(child.type === "element" && (child.tag === "table:table-row" || ROW_WRAPPER_TAGS.has(child.tag)))) {
-				rest.push(child);
-				continue;
-			}
-			if (!placed) {
-				rest.push(...regrouped);
-				placed = true;
-			}
-		}
-		if (!placed) rest.push(...regrouped);
-		table.children = rest;
-	}
-	headerColumns() {
-		return tableColumnEntries(this.live()).map((entry) => entry.insideHeader);
-	}
-	setHeaderColumns(flags) {
-		const table = this.live();
-		const columns = tableColumnElements(table);
-		const regrouped = [];
-		let run = [];
-		const closeRun = () => {
-			if (run.length > 0) {
-				regrouped.push(el("table:table-header-columns", {}, run));
-				run = [];
-			}
-		};
-		columns.forEach((column, index) => {
-			if (flags[index] === true) {
-				run.push(column);
-				return;
-			}
-			closeRun();
-			regrouped.push(column);
-		});
-		closeRun();
-		const rest = [];
-		let placed = false;
-		for (const child of table.children) {
-			if (!(child.type === "element" && (child.tag === "table:table-column" || COLUMN_WRAPPER_TAGS.has(child.tag)))) {
-				rest.push(child);
-				continue;
-			}
-			if (!placed) {
-				rest.push(...regrouped);
-				placed = true;
-			}
-		}
-		if (!placed) rest.push(...regrouped);
-		table.children = rest;
-	}
-	gridRows() {
-		return this.grid().rows;
-	}
-	gridColumnCount() {
-		return this.grid().columnCount;
-	}
-	grid() {
-		return resolveOdtGrid(this.live(), this.pkg);
-	}
-	cell(rowIndex, columnIndex) {
-		const row = this.rows()[rowIndex];
-		if (row === void 0) throw new Error(`row ${rowIndex} does not exist in this table`);
-		const cell = row.cells()[columnIndex];
-		if (cell === void 0) throw new Error(`column ${columnIndex} does not exist in row ${rowIndex}`);
-		return cell;
-	}
-	appendRow(columnCount) {
-		const node = this.live();
-		const row = buildRow(this.pkg, columnCount);
-		node.children.push(row);
-		return new OdtTableRow(row, this.pkg, node);
-	}
-	appendEmptyRow() {
-		const node = this.live();
-		const row = el("table:table-row");
-		node.children.push(row);
-		return new OdtTableRow(row, this.pkg, node);
-	}
-	mergeCells(startRow, startColumn, rowSpan, colSpan) {
-		if (!Number.isInteger(rowSpan) || rowSpan < 1 || !Number.isInteger(colSpan) || colSpan < 1) throw new Error(`mergeCells: rowSpan and colSpan must be positive integers, got rowSpan=${rowSpan}, colSpan=${colSpan}`);
-		const rows = tableRowElements(this.live());
-		const anchorRow = rows[startRow];
-		if (anchorRow === void 0) throw new Error(`mergeCells: row ${startRow} does not exist in this table`);
-		if (startRow + rowSpan > rows.length) throw new Error(`mergeCells: rowSpan ${rowSpan} starting at row ${startRow} exceeds this table's own ${rows.length} rows`);
-		const target = {
-			row: startRow,
-			column: startColumn,
-			rowSpan,
-			columnSpan: colSpan
-		};
-		const plan = planMerge(this.live(), this.pkg, target, [anchorRow, ...rows.slice(startRow + 1, startRow + rowSpan)]);
-		if (plan.refusal !== void 0) throw new Error(`mergeCells: row ${plan.refusal.rowIndex}: ${plan.refusal.reason}`);
-		return applyMerge(plan, target, this.pkg);
-	}
-	remove() {
-		removeChild(this.container, this.live());
-		this.removed = true;
-	}
-};
-function buildTable(pkg, init) {
-	const defaultWidth = DEFAULT_TABLE_WIDTH_PT / init.columns;
-	const columns = [];
-	for (let i = 0; i < init.columns; i++) {
-		const widthPt = init.columnWidthsPt?.[i] ?? defaultWidth;
-		columns.push(el("table:table-column", { "table:style-name": internTableColumnWidth(pkg, widthPt) }));
-	}
-	const rows = [];
-	for (let r = 0; r < init.rows; r++) rows.push(buildRow(pkg, init.columns));
-	return el("table:table", {}, [...columns, ...rows]);
-}
-//#endregion
-export { OdtCoveredTableCell, OdtTable, OdtTableCell, OdtTableRow, buildCellStyle, buildTable, readCellDecoration };
+import { a as TABLE_ROW_STYLE_PREFIX, c as readCellDecoration, d as tableRowEntries, i as OdtTableRow, l as retagAsCovered, n as OdtTable, o as buildCellStyle, r as OdtTableCell, s as buildTable, t as OdtCoveredTableCell, u as tableColumnElements } from "../../table-B5gSMY7w.js";
+export { OdtCoveredTableCell, OdtTable, OdtTableCell, OdtTableRow, TABLE_ROW_STYLE_PREFIX, buildCellStyle, buildTable, readCellDecoration, retagAsCovered, tableColumnElements, tableRowEntries };

package/dist/{evaluate-BbOsgdmN.d.cts → evaluate-BSEUxiUK.d.cts}

@@ -1,5 +1,6 @@
 import { r as HsqldbTable } from "./script-pkZ2Kor4.cjs";
 import { h as SqlSelectStatement } from "./parser-BTA1wXPd.cjs";
+import { n as OuterScope } from "./evaluate-columns-CyqKHkIW.cjs";
 import { ContentCellValue } from "document-schema.js";
 //#region src/odb/sql/evaluate.d.ts
 interface SqlResultSet {
@@ -7,9 +8,10 @@ interface SqlResultSet {
   readonly rows: readonly (readonly ContentCellValue[])[];
 }
 declare function evaluateSelect(statement: SqlSelectStatement, tables: readonly HsqldbTable[]): SqlResultSet;
+declare function evaluateSelectInScope(statement: SqlSelectStatement, tables: readonly HsqldbTable[], outer: OuterScope | undefined): SqlResultSet;
 declare function assertNeverOperator(value: never): never;
 declare function assertNeverLiteralKind(value: never): never;
 declare function assertNeverPredicateKind(value: never): never;
 declare function assertNeverValueKind(value: never): never;
 //#endregion
-export { assertNeverValueKind as a, assertNeverPredicateKind as i, assertNeverLiteralKind as n, evaluateSelect as o, assertNeverOperator as r, SqlResultSet as t };
+export { assertNeverValueKind as a, assertNeverPredicateKind as i, assertNeverLiteralKind as n, evaluateSelect as o, assertNeverOperator as r, evaluateSelectInScope as s, SqlResultSet as t };