documents.js 1.63.0 → 1.65.0

package/dist/odb/formula/parser.cjs

@@ -0,0 +1,198 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_formula_errors = require("./errors.cjs");
+//#region src/odb/formula/parser.ts
+const AGGREGATE_FUNCTIONS = /* @__PURE__ */ new Set([
+	"COUNT",
+	"SUM",
+	"AVG",
+	"MIN",
+	"MAX"
+]);
+function isAggregateFunction(name) {
+	return AGGREGATE_FUNCTIONS.has(name);
+}
+const FIELD_PREFIX = "field:";
+const RPT_PREFIX = "rpt:";
+function isNameCharacter(character) {
+	return character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character >= "0" && character <= "9" || character === "_";
+}
+var FormulaScanner = class {
+	formula;
+	offset = 0;
+	constructor(formula) {
+		this.formula = formula;
+	}
+	get position() {
+		return this.offset;
+	}
+	fail(message) {
+		throw new require_odb_formula_errors.RptFormulaParseError(message, this.formula, this.offset);
+	}
+	skipWhitespace() {
+		while (this.offset < this.formula.length && /\s/.test(this.formula.charAt(this.offset))) this.offset += 1;
+	}
+	atEnd() {
+		this.skipWhitespace();
+		return this.offset >= this.formula.length;
+	}
+	peek() {
+		this.skipWhitespace();
+		return this.formula.charAt(this.offset);
+	}
+	tryConsume(text) {
+		this.skipWhitespace();
+		if (!this.formula.startsWith(text, this.offset)) return false;
+		this.offset += text.length;
+		return true;
+	}
+	expect(character, what) {
+		this.skipWhitespace();
+		if (this.formula.charAt(this.offset) !== character) this.fail(`expected ${what} ("${character}") but found ${this.offset >= this.formula.length ? "the end of the formula" : `"${this.formula.charAt(this.offset)}"`}`);
+		this.offset += 1;
+	}
+	readName(what) {
+		this.skipWhitespace();
+		const start = this.offset;
+		while (this.offset < this.formula.length && isNameCharacter(this.formula.charAt(this.offset))) this.offset += 1;
+		if (this.offset === start) this.fail(`expected ${what}`);
+		return this.formula.slice(start, this.offset);
+	}
+	readBracketReference() {
+		this.expect("[", "the opening bracket of a column reference");
+		const start = this.offset;
+		const close = this.formula.indexOf("]", this.offset);
+		if (close < 0) {
+			this.offset = this.formula.length;
+			this.fail("unterminated column reference -- no closing \"]\"");
+		}
+		this.offset = close + 1;
+		return {
+			name: this.formula.slice(start, close),
+			spelling: "bracket"
+		};
+	}
+	readQuotedReference() {
+		this.expect("\"", "the opening quote of a name reference");
+		let name = "";
+		for (;;) {
+			if (this.offset >= this.formula.length) this.fail("unterminated name reference -- no closing double quote");
+			const character = this.formula.charAt(this.offset);
+			this.offset += 1;
+			if (character !== "\"") {
+				name += character;
+				continue;
+			}
+			if (this.formula.charAt(this.offset) === "\"") {
+				name += "\"";
+				this.offset += 1;
+				continue;
+			}
+			return {
+				name,
+				spelling: "quote"
+			};
+		}
+	}
+	readNumber() {
+		this.skipWhitespace();
+		const start = this.offset;
+		if (this.formula.charAt(this.offset) === "-") this.offset += 1;
+		while (this.offset < this.formula.length && this.formula.charAt(this.offset) >= "0" && this.formula.charAt(this.offset) <= "9") this.offset += 1;
+		if (this.formula.charAt(this.offset) === ".") {
+			this.offset += 1;
+			while (this.offset < this.formula.length && this.formula.charAt(this.offset) >= "0" && this.formula.charAt(this.offset) <= "9") this.offset += 1;
+		}
+		const text = this.formula.slice(start, this.offset);
+		const value = Number(text);
+		if (text === "" || text === "-" || !Number.isFinite(value)) {
+			this.offset = start;
+			this.fail("expected a number");
+		}
+		return value;
+	}
+	readArgument() {
+		const next = this.peek();
+		if (next === "") this.fail("expected an argument but found the end of the formula");
+		if (next === "[") return {
+			kind: "reference",
+			reference: this.readBracketReference()
+		};
+		if (next === "\"") return {
+			kind: "reference",
+			reference: this.readQuotedReference()
+		};
+		return {
+			kind: "number",
+			value: this.readNumber()
+		};
+	}
+};
+function referenceArgument(argument, functionName, ordinal, scanner) {
+	if (argument?.kind !== "reference") scanner.fail(`rpt:${functionName}'s ${ordinal} argument must be a column or function reference ([NAME] or "NAME")`);
+	return argument.reference;
+}
+function expectArgumentCount(argumentValues, expected, functionName, scanner) {
+	if (argumentValues.length !== expected) scanner.fail(`rpt:${functionName} takes exactly ${String(expected)} argument${expected === 1 ? "" : "s"}, but ${String(argumentValues.length)} ${argumentValues.length === 1 ? "was" : "were"} given`);
+}
+function buildCall(functionName, argumentValues, formula, scanner) {
+	const canonical = functionName.toUpperCase();
+	if (canonical === "HASCHANGED") {
+		expectArgumentCount(argumentValues, 1, functionName, scanner);
+		return {
+			kind: "hasChanged",
+			reference: referenceArgument(argumentValues[0], functionName, "first", scanner),
+			text: formula
+		};
+	}
+	if (canonical === "LEFT") {
+		expectArgumentCount(argumentValues, 2, functionName, scanner);
+		const reference = referenceArgument(argumentValues[0], functionName, "first", scanner);
+		const lengthArgument = argumentValues[1];
+		if (lengthArgument?.kind !== "number") scanner.fail(`rpt:${functionName}'s second argument must be a number of characters`);
+		if (!Number.isInteger(lengthArgument.value) || lengthArgument.value < 0) scanner.fail(`rpt:${functionName}'s second argument must be a non-negative whole number of characters, but was ${String(lengthArgument.value)}`);
+		return {
+			kind: "left",
+			reference,
+			length: lengthArgument.value,
+			text: formula
+		};
+	}
+	if (isAggregateFunction(canonical)) {
+		expectArgumentCount(argumentValues, 1, functionName, scanner);
+		return {
+			kind: "aggregate",
+			aggregate: canonical,
+			reference: referenceArgument(argumentValues[0], functionName, "first", scanner),
+			text: formula
+		};
+	}
+	throw new require_odb_formula_errors.RptFormulaUnsupportedError(functionName, formula);
+}
+function parseRptFormula(formula) {
+	const scanner = new FormulaScanner(formula);
+	if (scanner.tryConsume(FIELD_PREFIX)) {
+		const reference = scanner.readBracketReference();
+		if (!scanner.atEnd()) scanner.fail("unexpected trailing text after a field: reference");
+		return {
+			kind: "field",
+			reference,
+			text: formula
+		};
+	}
+	if (!scanner.tryConsume(RPT_PREFIX)) scanner.fail(`expected a formula beginning "${FIELD_PREFIX}" or "${RPT_PREFIX}"`);
+	const functionName = scanner.readName("an rpt: function name");
+	scanner.expect("(", "the opening parenthesis of a function's argument list");
+	const argumentValues = [];
+	if (scanner.peek() !== ")") {
+		argumentValues.push(scanner.readArgument());
+		while (scanner.peek() === ";") {
+			scanner.expect(";", "an argument separator");
+			argumentValues.push(scanner.readArgument());
+		}
+	}
+	scanner.expect(")", "the closing parenthesis of a function's argument list");
+	if (!scanner.atEnd()) scanner.fail("unexpected trailing text after a function call");
+	return buildCall(functionName, argumentValues, formula, scanner);
+}
+//#endregion
+exports.parseRptFormula = parseRptFormula;

package/dist/odb/formula/parser.d.cts

@@ -0,0 +1,29 @@
+import { n as CellAggregateFunction } from "../../values-BetetbaH.cjs";
+//#region src/odb/formula/parser.d.ts
+type RptAggregateFunction = CellAggregateFunction;
+interface RptReference {
+  readonly name: string;
+  readonly spelling: 'bracket' | 'quote';
+}
+type RptFormula = {
+  readonly kind: 'field';
+  readonly reference: RptReference;
+  readonly text: string;
+} | {
+  readonly kind: 'hasChanged';
+  readonly reference: RptReference;
+  readonly text: string;
+} | {
+  readonly kind: 'left';
+  readonly reference: RptReference;
+  readonly length: number;
+  readonly text: string;
+} | {
+  readonly kind: 'aggregate';
+  readonly aggregate: RptAggregateFunction;
+  readonly reference: RptReference;
+  readonly text: string;
+};
+declare function parseRptFormula(formula: string): RptFormula;
+//#endregion
+export { RptAggregateFunction, RptFormula, RptReference, parseRptFormula };

package/dist/odb/formula/parser.d.ts

@@ -0,0 +1,29 @@
+import { n as CellAggregateFunction } from "../../values-BetetbaH.js";
+//#region src/odb/formula/parser.d.ts
+type RptAggregateFunction = CellAggregateFunction;
+interface RptReference {
+  readonly name: string;
+  readonly spelling: 'bracket' | 'quote';
+}
+type RptFormula = {
+  readonly kind: 'field';
+  readonly reference: RptReference;
+  readonly text: string;
+} | {
+  readonly kind: 'hasChanged';
+  readonly reference: RptReference;
+  readonly text: string;
+} | {
+  readonly kind: 'left';
+  readonly reference: RptReference;
+  readonly length: number;
+  readonly text: string;
+} | {
+  readonly kind: 'aggregate';
+  readonly aggregate: RptAggregateFunction;
+  readonly reference: RptReference;
+  readonly text: string;
+};
+declare function parseRptFormula(formula: string): RptFormula;
+//#endregion
+export { RptAggregateFunction, RptFormula, RptReference, parseRptFormula };

package/dist/odb/formula/parser.js

@@ -0,0 +1,197 @@
+import { RptFormulaParseError, RptFormulaUnsupportedError } from "./errors.js";
+//#region src/odb/formula/parser.ts
+const AGGREGATE_FUNCTIONS = /* @__PURE__ */ new Set([
+	"COUNT",
+	"SUM",
+	"AVG",
+	"MIN",
+	"MAX"
+]);
+function isAggregateFunction(name) {
+	return AGGREGATE_FUNCTIONS.has(name);
+}
+const FIELD_PREFIX = "field:";
+const RPT_PREFIX = "rpt:";
+function isNameCharacter(character) {
+	return character >= "A" && character <= "Z" || character >= "a" && character <= "z" || character >= "0" && character <= "9" || character === "_";
+}
+var FormulaScanner = class {
+	formula;
+	offset = 0;
+	constructor(formula) {
+		this.formula = formula;
+	}
+	get position() {
+		return this.offset;
+	}
+	fail(message) {
+		throw new RptFormulaParseError(message, this.formula, this.offset);
+	}
+	skipWhitespace() {
+		while (this.offset < this.formula.length && /\s/.test(this.formula.charAt(this.offset))) this.offset += 1;
+	}
+	atEnd() {
+		this.skipWhitespace();
+		return this.offset >= this.formula.length;
+	}
+	peek() {
+		this.skipWhitespace();
+		return this.formula.charAt(this.offset);
+	}
+	tryConsume(text) {
+		this.skipWhitespace();
+		if (!this.formula.startsWith(text, this.offset)) return false;
+		this.offset += text.length;
+		return true;
+	}
+	expect(character, what) {
+		this.skipWhitespace();
+		if (this.formula.charAt(this.offset) !== character) this.fail(`expected ${what} ("${character}") but found ${this.offset >= this.formula.length ? "the end of the formula" : `"${this.formula.charAt(this.offset)}"`}`);
+		this.offset += 1;
+	}
+	readName(what) {
+		this.skipWhitespace();
+		const start = this.offset;
+		while (this.offset < this.formula.length && isNameCharacter(this.formula.charAt(this.offset))) this.offset += 1;
+		if (this.offset === start) this.fail(`expected ${what}`);
+		return this.formula.slice(start, this.offset);
+	}
+	readBracketReference() {
+		this.expect("[", "the opening bracket of a column reference");
+		const start = this.offset;
+		const close = this.formula.indexOf("]", this.offset);
+		if (close < 0) {
+			this.offset = this.formula.length;
+			this.fail("unterminated column reference -- no closing \"]\"");
+		}
+		this.offset = close + 1;
+		return {
+			name: this.formula.slice(start, close),
+			spelling: "bracket"
+		};
+	}
+	readQuotedReference() {
+		this.expect("\"", "the opening quote of a name reference");
+		let name = "";
+		for (;;) {
+			if (this.offset >= this.formula.length) this.fail("unterminated name reference -- no closing double quote");
+			const character = this.formula.charAt(this.offset);
+			this.offset += 1;
+			if (character !== "\"") {
+				name += character;
+				continue;
+			}
+			if (this.formula.charAt(this.offset) === "\"") {
+				name += "\"";
+				this.offset += 1;
+				continue;
+			}
+			return {
+				name,
+				spelling: "quote"
+			};
+		}
+	}
+	readNumber() {
+		this.skipWhitespace();
+		const start = this.offset;
+		if (this.formula.charAt(this.offset) === "-") this.offset += 1;
+		while (this.offset < this.formula.length && this.formula.charAt(this.offset) >= "0" && this.formula.charAt(this.offset) <= "9") this.offset += 1;
+		if (this.formula.charAt(this.offset) === ".") {
+			this.offset += 1;
+			while (this.offset < this.formula.length && this.formula.charAt(this.offset) >= "0" && this.formula.charAt(this.offset) <= "9") this.offset += 1;
+		}
+		const text = this.formula.slice(start, this.offset);
+		const value = Number(text);
+		if (text === "" || text === "-" || !Number.isFinite(value)) {
+			this.offset = start;
+			this.fail("expected a number");
+		}
+		return value;
+	}
+	readArgument() {
+		const next = this.peek();
+		if (next === "") this.fail("expected an argument but found the end of the formula");
+		if (next === "[") return {
+			kind: "reference",
+			reference: this.readBracketReference()
+		};
+		if (next === "\"") return {
+			kind: "reference",
+			reference: this.readQuotedReference()
+		};
+		return {
+			kind: "number",
+			value: this.readNumber()
+		};
+	}
+};
+function referenceArgument(argument, functionName, ordinal, scanner) {
+	if (argument?.kind !== "reference") scanner.fail(`rpt:${functionName}'s ${ordinal} argument must be a column or function reference ([NAME] or "NAME")`);
+	return argument.reference;
+}
+function expectArgumentCount(argumentValues, expected, functionName, scanner) {
+	if (argumentValues.length !== expected) scanner.fail(`rpt:${functionName} takes exactly ${String(expected)} argument${expected === 1 ? "" : "s"}, but ${String(argumentValues.length)} ${argumentValues.length === 1 ? "was" : "were"} given`);
+}
+function buildCall(functionName, argumentValues, formula, scanner) {
+	const canonical = functionName.toUpperCase();
+	if (canonical === "HASCHANGED") {
+		expectArgumentCount(argumentValues, 1, functionName, scanner);
+		return {
+			kind: "hasChanged",
+			reference: referenceArgument(argumentValues[0], functionName, "first", scanner),
+			text: formula
+		};
+	}
+	if (canonical === "LEFT") {
+		expectArgumentCount(argumentValues, 2, functionName, scanner);
+		const reference = referenceArgument(argumentValues[0], functionName, "first", scanner);
+		const lengthArgument = argumentValues[1];
+		if (lengthArgument?.kind !== "number") scanner.fail(`rpt:${functionName}'s second argument must be a number of characters`);
+		if (!Number.isInteger(lengthArgument.value) || lengthArgument.value < 0) scanner.fail(`rpt:${functionName}'s second argument must be a non-negative whole number of characters, but was ${String(lengthArgument.value)}`);
+		return {
+			kind: "left",
+			reference,
+			length: lengthArgument.value,
+			text: formula
+		};
+	}
+	if (isAggregateFunction(canonical)) {
+		expectArgumentCount(argumentValues, 1, functionName, scanner);
+		return {
+			kind: "aggregate",
+			aggregate: canonical,
+			reference: referenceArgument(argumentValues[0], functionName, "first", scanner),
+			text: formula
+		};
+	}
+	throw new RptFormulaUnsupportedError(functionName, formula);
+}
+function parseRptFormula(formula) {
+	const scanner = new FormulaScanner(formula);
+	if (scanner.tryConsume(FIELD_PREFIX)) {
+		const reference = scanner.readBracketReference();
+		if (!scanner.atEnd()) scanner.fail("unexpected trailing text after a field: reference");
+		return {
+			kind: "field",
+			reference,
+			text: formula
+		};
+	}
+	if (!scanner.tryConsume(RPT_PREFIX)) scanner.fail(`expected a formula beginning "${FIELD_PREFIX}" or "${RPT_PREFIX}"`);
+	const functionName = scanner.readName("an rpt: function name");
+	scanner.expect("(", "the opening parenthesis of a function's argument list");
+	const argumentValues = [];
+	if (scanner.peek() !== ")") {
+		argumentValues.push(scanner.readArgument());
+		while (scanner.peek() === ";") {
+			scanner.expect(";", "an argument separator");
+			argumentValues.push(scanner.readArgument());
+		}
+	}
+	scanner.expect(")", "the closing parenthesis of a function's argument list");
+	if (!scanner.atEnd()) scanner.fail("unexpected trailing text after a function call");
+	return buildCall(functionName, argumentValues, formula, scanner);
+}
+//#endregion
+export { parseRptFormula };

package/dist/odb/read.d.cts

@@ -1,5 +1,5 @@
 import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
-import { HsqldbTable } from "../hsqldb/script.cjs";
+import { r as HsqldbTable } from "../script-DsGGIzGU.cjs";
 import { Package } from "odf.js";
 //#region src/odb/read.d.ts
 declare class OdbNoEmbeddedDataSourceError extends Error {

package/dist/odb/read.d.ts

@@ -1,5 +1,5 @@
 import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
-import { HsqldbTable } from "../hsqldb/script.js";
+import { r as HsqldbTable } from "../script-DsGGIzGU.js";
 import { Package } from "odf.js";
 //#region src/odb/read.d.ts
 declare class OdbNoEmbeddedDataSourceError extends Error {

package/dist/odb/report/content.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_report_render = require("./render.cjs");
+const require_odb_report_source = require("./source.cjs");
+let odf_js = require("odf.js");
+//#region src/odb/report/content.ts
+var OdbReportNotSpecifiedError = class extends Error {
+	availableReports;
+	constructor(availableReports) {
+		super(availableReports.length === 0 ? "readOdbReportContent: this .odb declares no reports at all" : `readOdbReportContent: this .odb declares more than one report (${availableReports.join(", ")}) -- pass { report: '<name>' } to select one`);
+		this.name = "OdbReportNotSpecifiedError";
+		this.availableReports = availableReports;
+	}
+};
+function selectReport(pkg, reportName) {
+	if (reportName !== void 0) return (0, odf_js.readOdbReport)(pkg, reportName);
+	const declared = (0, odf_js.readOdbInventory)(pkg).reports;
+	const only = declared.length === 1 ? declared[0] : void 0;
+	if (only === void 0) throw new OdbReportNotSpecifiedError(declared.map((component) => component.name));
+	return (0, odf_js.readOdbReport)(pkg, only.name);
+}
+function readOdbReportContent(pkg, options) {
+	const report = selectReport(pkg, options?.report);
+	return require_odb_report_render.renderOdbReportContent(report, require_odb_report_source.resolveOdbReportRows(pkg, report, options));
+}
+//#endregion
+exports.OdbReportNotSpecifiedError = OdbReportNotSpecifiedError;
+exports.readOdbReportContent = readOdbReportContent;

package/dist/odb/report/content.d.cts

@@ -0,0 +1,14 @@
+import { n as HsqldbDecodeOptions } from "../../rowformat-Cl2exlEh.cjs";
+import { ContentDocument } from "document-schema.js";
+import { Package } from "odf.js";
+//#region src/odb/report/content.d.ts
+declare class OdbReportNotSpecifiedError extends Error {
+  readonly availableReports: readonly string[];
+  constructor(availableReports: readonly string[]);
+}
+interface OdbReportContentOptions extends HsqldbDecodeOptions {
+  readonly report?: string;
+}
+declare function readOdbReportContent(pkg: Package, options?: OdbReportContentOptions): ContentDocument;
+//#endregion
+export { OdbReportContentOptions, OdbReportNotSpecifiedError, readOdbReportContent };

package/dist/odb/report/content.d.ts

@@ -0,0 +1,14 @@
+import { n as HsqldbDecodeOptions } from "../../rowformat-Cl2exlEh.js";
+import { ContentDocument } from "document-schema.js";
+import { Package } from "odf.js";
+//#region src/odb/report/content.d.ts
+declare class OdbReportNotSpecifiedError extends Error {
+  readonly availableReports: readonly string[];
+  constructor(availableReports: readonly string[]);
+}
+interface OdbReportContentOptions extends HsqldbDecodeOptions {
+  readonly report?: string;
+}
+declare function readOdbReportContent(pkg: Package, options?: OdbReportContentOptions): ContentDocument;
+//#endregion
+export { OdbReportContentOptions, OdbReportNotSpecifiedError, readOdbReportContent };

package/dist/odb/report/content.js

@@ -0,0 +1,25 @@
+import { renderOdbReportContent } from "./render.js";
+import { resolveOdbReportRows } from "./source.js";
+import { readOdbInventory, readOdbReport } from "odf.js";
+//#region src/odb/report/content.ts
+var OdbReportNotSpecifiedError = class extends Error {
+	availableReports;
+	constructor(availableReports) {
+		super(availableReports.length === 0 ? "readOdbReportContent: this .odb declares no reports at all" : `readOdbReportContent: this .odb declares more than one report (${availableReports.join(", ")}) -- pass { report: '<name>' } to select one`);
+		this.name = "OdbReportNotSpecifiedError";
+		this.availableReports = availableReports;
+	}
+};
+function selectReport(pkg, reportName) {
+	if (reportName !== void 0) return readOdbReport(pkg, reportName);
+	const declared = readOdbInventory(pkg).reports;
+	const only = declared.length === 1 ? declared[0] : void 0;
+	if (only === void 0) throw new OdbReportNotSpecifiedError(declared.map((component) => component.name));
+	return readOdbReport(pkg, only.name);
+}
+function readOdbReportContent(pkg, options) {
+	const report = selectReport(pkg, options?.report);
+	return renderOdbReportContent(report, resolveOdbReportRows(pkg, report, options));
+}
+//#endregion
+export { OdbReportNotSpecifiedError, readOdbReportContent };

package/dist/odb/report/render.cjs

@@ -0,0 +1,106 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hsqldb_script = require("../../hsqldb/script.cjs");
+const require_odb_formula_evaluate = require("../formula/evaluate.cjs");
+const require_odb_formula_definition = require("../formula/definition.cjs");
+let document_schema_js = require("document-schema.js");
+//#region src/odb/report/render.ts
+const MARGIN_PT = 56.69291338582677;
+const CONTENT_WIDTH_PT = document_schema_js.PAGE_SIZE_A4.widthPt - 2 * MARGIN_PT;
+const REPORT_HEADER_STYLE = "Report Header";
+const PAGE_HEADER_STYLE = "Page Header";
+const DETAIL_STYLE = "Detail";
+const PAGE_FOOTER_STYLE = "Page Footer";
+const REPORT_FOOTER_STYLE = "Report Footer";
+function groupBandStyle(kind, level) {
+	return `${kind === "group-header" ? "Group Header" : "Group Footer"} ${String(level + 1)}`;
+}
+function printedBand(band, styleId, values) {
+	if (band === void 0) throw new Error(`rpt report render: a "${styleId}" band instance was emitted for a band this report does not declare`);
+	return {
+		styleId,
+		elements: band.elements,
+		values
+	};
+}
+function bandOfInstance(report, groups, instance) {
+	switch (instance.kind) {
+		case "report-header": return printedBand(report.reportHeader, REPORT_HEADER_STYLE, instance.values);
+		case "detail": return printedBand(report.detail, DETAIL_STYLE, instance.values);
+		case "report-footer": return printedBand(report.reportFooter, REPORT_FOOTER_STYLE, instance.values);
+		case "group-header":
+		case "group-footer": {
+			const level = instance.groupLevel;
+			if (level === void 0) throw new Error(`rpt report render: a ${instance.kind} band instance carries no group level`);
+			const group = groups[level];
+			if (group === void 0) throw new Error(`rpt report render: a ${instance.kind} band instance names group level ${String(level)}, which this report's own chain of ${String(groups.length)} group(s) does not reach`);
+			return printedBand(instance.kind === "group-header" ? group.header : group.footer, groupBandStyle(instance.kind, level), instance.values);
+		}
+	}
+}
+function elementText(element, value) {
+	if (element.formula === void 0) return element.text ?? "";
+	if (value === void 0) throw new Error(`rpt report render: control "${element.formula}" carries a formula but the run produced no value for it`);
+	return require_hsqldb_script.displayTextFor(value);
+}
+function cellParagraph(element, value, styleId) {
+	const text = elementText(element, value);
+	return {
+		kind: "paragraph",
+		styleId,
+		runs: text === "" ? [] : [{ text }]
+	};
+}
+function bandTable(band) {
+	if (band.elements.length === 0) return;
+	if (band.values.length !== band.elements.length) throw new Error(`rpt report render: the "${band.styleId}" band printed ${String(band.values.length)} values for ${String(band.elements.length)} control(s)`);
+	const columnWidthPt = CONTENT_WIDTH_PT / band.elements.length;
+	return {
+		kind: "table",
+		columnWidthsPt: band.elements.map(() => columnWidthPt),
+		rows: [{ cells: band.elements.map((element, index) => ({ blocks: [cellParagraph(element, band.values[index], band.styleId)] })) }]
+	};
+}
+function bandBlocks(bands) {
+	return bands.flatMap((band) => {
+		const table = bandTable(band);
+		return table === void 0 ? [] : [table];
+	});
+}
+function pageBands(definition, band, styleId, resultSet) {
+	if (band === void 0) return [];
+	return [{
+		styleId,
+		elements: band.elements,
+		values: require_odb_formula_evaluate.evaluateRptBandOutsideData(definition, require_odb_formula_definition.rptBandDefinition(band), resultSet)
+	}];
+}
+function renderOdbReportContent(report, resultSet) {
+	const definition = require_odb_formula_definition.rptDefinitionFromReport(report);
+	const groups = require_odb_formula_definition.odbReportGroupChain(report);
+	const instances = require_odb_formula_evaluate.runRptReport(definition, resultSet).bands;
+	const printed = (matches) => instances.filter((instance) => matches(instance.kind)).map((instance) => bandOfInstance(report, groups, instance));
+	const section = {
+		pageSize: document_schema_js.PAGE_SIZE_A4,
+		margins: {
+			topPt: MARGIN_PT,
+			rightPt: MARGIN_PT,
+			bottomPt: MARGIN_PT,
+			leftPt: MARGIN_PT
+		},
+		blocks: [
+			...bandBlocks(printed((kind) => kind === "report-header")),
+			...bandBlocks(pageBands(definition, report.pageHeader, PAGE_HEADER_STYLE, resultSet)),
+			...bandBlocks(printed((kind) => kind !== "report-header" && kind !== "report-footer")),
+			...bandBlocks(pageBands(definition, report.pageFooter, PAGE_FOOTER_STYLE, resultSet)),
+			...bandBlocks(printed((kind) => kind === "report-footer"))
+		]
+	};
+	return {
+		kind: "wordprocessing",
+		formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
+		metadata: { title: report.caption ?? report.name },
+		sections: [section]
+	};
+}
+//#endregion
+exports.renderOdbReportContent = renderOdbReportContent;

package/dist/odb/report/render.d.cts

@@ -0,0 +1,7 @@
+import { t as SqlResultSet } from "../../evaluate-BhMXY6DM.cjs";
+import { ContentDocument } from "document-schema.js";
+import { OdbReport } from "odf.js";
+//#region src/odb/report/render.d.ts
+declare function renderOdbReportContent(report: OdbReport, resultSet: SqlResultSet): ContentDocument;
+//#endregion
+export { renderOdbReportContent };

package/dist/odb/report/render.d.ts

@@ -0,0 +1,7 @@
+import { t as SqlResultSet } from "../../evaluate-BU5N1Jk1.js";
+import { ContentDocument } from "document-schema.js";
+import { OdbReport } from "odf.js";
+//#region src/odb/report/render.d.ts
+declare function renderOdbReportContent(report: OdbReport, resultSet: SqlResultSet): ContentDocument;
+//#endregion
+export { renderOdbReportContent };