documents.js 1.63.0 → 1.65.0

package/dist/odb/formula/evaluate.cjs

@@ -0,0 +1,283 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_odb_values = require("../values.cjs");
+const require_odb_formula_errors = require("./errors.cjs");
+const require_odb_formula_parser = require("./parser.cjs");
+//#region src/odb/formula/evaluate.ts
+function fail(message, formula) {
+	throw new require_odb_formula_errors.RptFormulaEvaluationError(message, formula);
+}
+function matchNamed(candidates, nameOf, name) {
+	const exact = candidates.filter((candidate) => nameOf(candidate) === name);
+	return exact.length > 0 ? exact : candidates.filter((candidate) => nameOf(candidate).toUpperCase() === name.toUpperCase());
+}
+function identity(name) {
+	return name;
+}
+function prepareBandFormulas(band) {
+	return band.formulas.map((formula) => formula === void 0 ? void 0 : require_odb_formula_parser.parseRptFormula(formula));
+}
+function prepareBand(band) {
+	return band === void 0 ? void 0 : prepareBandFormulas(band);
+}
+var PreparedReport = class {
+	resultSet;
+	namedFunctions;
+	groupExpressions;
+	bands;
+	columnNames;
+	resolutions = /* @__PURE__ */ new Map();
+	constructor(definition, resultSet) {
+		this.resultSet = resultSet;
+		this.columnNames = resultSet.columns;
+		const named = /* @__PURE__ */ new Map();
+		const declare = (functions, scope) => {
+			for (const declaration of functions) {
+				if (named.has(declaration.name)) fail(`rpt:function "${declaration.name}" is declared more than once in this report`, declaration.formula);
+				named.set(declaration.name, {
+					name: declaration.name,
+					formula: require_odb_formula_parser.parseRptFormula(declaration.formula),
+					scope
+				});
+			}
+		};
+		declare(definition.functions, { kind: "report" });
+		for (const [level, group] of definition.groups.entries()) declare(group.functions, {
+			kind: "group",
+			level
+		});
+		this.namedFunctions = named;
+		this.groupExpressions = definition.groups.map((group) => require_odb_formula_parser.parseRptFormula(group.groupExpression));
+		this.bands = {
+			reportHeader: prepareBand(definition.reportHeader),
+			detail: prepareBand(definition.detail),
+			reportFooter: prepareBand(definition.reportFooter),
+			groups: definition.groups.map((group) => ({
+				header: prepareBand(group.header),
+				footer: prepareBand(group.footer)
+			}))
+		};
+		for (const expression of this.groupExpressions) this.rejectAggregateDependency(expression, expression, /* @__PURE__ */ new Set());
+	}
+	rejectAggregateDependency(formula, expression, visiting) {
+		if (formula.kind === "aggregate") fail(`a group expression cannot depend on the aggregate rpt:${formula.aggregate}(${formula.reference.name}) -- an aggregate's own rows are defined by the very group boundaries this expression decides`, expression.text);
+		const resolved = matchNamed([...this.namedFunctions.values()], (candidate) => candidate.name, formula.reference.name)[0];
+		if (resolved === void 0) return;
+		if (visiting.has(resolved.name)) fail(`rpt:function "${resolved.name}" refers to itself, directly or through another function`, expression.text);
+		this.rejectAggregateDependency(resolved.formula, expression, /* @__PURE__ */ new Set([...visiting, resolved.name]));
+	}
+	resolveReference(reference, formula) {
+		const cached = this.resolutions.get(reference);
+		if (cached !== void 0) return cached;
+		const functionMatches = matchNamed([...this.namedFunctions.values()], (candidate) => candidate.name, reference.name);
+		const columnMatches = matchNamed(this.columnNames, identity, reference.name);
+		if (functionMatches.length + columnMatches.length > 1) fail(`reference "${reference.name}" is ambiguous -- it matches ${[...functionMatches.map((match) => `rpt:function ${match.name}`), ...columnMatches.map((match) => `column ${match}`)].join(", ")}`, formula);
+		const resolved = this.resolveSingleMatch(reference, functionMatches[0], columnMatches[0], formula);
+		this.resolutions.set(reference, resolved);
+		return resolved;
+	}
+	resolveSingleMatch(reference, named, columnName, formula) {
+		if (named !== void 0) return {
+			kind: "function",
+			resolved: named
+		};
+		if (columnName === void 0) fail(`reference "${reference.name}" names neither a declared rpt:function nor a column of the report's own data -- functions: ${this.namedFunctions.size === 0 ? "(none)" : [...this.namedFunctions.keys()].join(", ")}; columns: ${this.columnNames.length === 0 ? "(none)" : this.columnNames.join(", ")}`, formula);
+		return {
+			kind: "column",
+			index: this.columnNames.indexOf(columnName)
+		};
+	}
+	valueAt(columnIndex, rowIndex, formula) {
+		const value = this.resultSet.rows[rowIndex]?.[columnIndex];
+		if (value === void 0) fail(`the report's own data has no value at row ${String(rowIndex)}, column ${String(columnIndex)}`, formula);
+		return value;
+	}
+};
+var RunState = class {
+	rowCount;
+	openInstances;
+	constructor(levels, rowCount) {
+		this.rowCount = rowCount;
+		this.openInstances = Array.from({ length: levels }, () => void 0);
+	}
+	open(level, range) {
+		this.openInstances[level] = range;
+	}
+	openAt(level) {
+		return this.openInstances[level];
+	}
+	close(level) {
+		this.openInstances[level] = void 0;
+	}
+	rangeFor(scope, formula) {
+		if (scope.kind === "report") return {
+			startRow: 0,
+			endRowExclusive: this.rowCount
+		};
+		const open = this.openInstances[scope.level];
+		if (open === void 0) fail(`an aggregate scoped to group level ${String(scope.level)} was evaluated while no instance of that group was open`, formula);
+		return open;
+	}
+};
+function textOf(value, formula, what) {
+	if (value.kind === "empty") return;
+	const key = require_odb_values.cellComparisonKey(value);
+	if (key?.valueClass !== "text") fail(`${what} requires a text value, but found a ${value.kind} value -- this engine does not format a number or a boolean into text, since a report's own number format lives in its band styles rather than in the formula`, formula);
+	return key.text;
+}
+var FormulaEvaluator = class {
+	prepared;
+	state;
+	constructor(prepared, state) {
+		this.prepared = prepared;
+		this.state = state;
+	}
+	evaluate(formula, rowIndex, scope, visiting = /* @__PURE__ */ new Set()) {
+		switch (formula.kind) {
+			case "field": return this.referenceValue(formula.reference, this.requireRow(rowIndex, formula.text, "a field: reference"), formula.text, visiting);
+			case "hasChanged": {
+				const rowOfChange = this.requireRow(rowIndex, formula.text, "rpt:HASCHANGED");
+				const current = this.referenceValue(formula.reference, rowOfChange, formula.text, visiting);
+				if (rowOfChange === 0) return {
+					kind: "boolean",
+					value: true
+				};
+				const previous = this.referenceValue(formula.reference, rowOfChange - 1, formula.text, visiting);
+				return {
+					kind: "boolean",
+					value: !require_odb_values.cellValuesEqual(current, previous)
+				};
+			}
+			case "left": {
+				const text = textOf(this.referenceValue(formula.reference, this.requireRow(rowIndex, formula.text, "rpt:LEFT"), formula.text, visiting), formula.text, "rpt:LEFT");
+				return text === void 0 ? require_odb_values.CELL_NULL : {
+					kind: "string",
+					value: [...text].slice(0, formula.length).join("")
+				};
+			}
+			case "aggregate": {
+				const range = this.state.rangeFor(scope, formula.text);
+				const values = [];
+				for (let row = range.startRow; row < range.endRowExclusive; row += 1) values.push(this.referenceValue(formula.reference, row, formula.text, visiting));
+				return require_odb_values.aggregateCellValues(formula.aggregate, values, (message) => new require_odb_formula_errors.RptFormulaEvaluationError(message, formula.text));
+			}
+		}
+	}
+	requireRow(rowIndex, formula, what) {
+		if (rowIndex === void 0) fail(`${what} needs a data row, but the band it appears in belongs to no row (the report header and footer print outside the data)`, formula);
+		return rowIndex;
+	}
+	referenceValue(reference, rowIndex, formula, visiting) {
+		const resolved = this.prepared.resolveReference(reference, formula);
+		if (resolved.kind === "column") return this.prepared.valueAt(resolved.index, rowIndex, formula);
+		if (visiting.has(resolved.resolved.name)) fail(`rpt:function "${resolved.resolved.name}" refers to itself, directly or through another function`, formula);
+		return this.evaluate(resolved.resolved.formula, rowIndex, resolved.resolved.scope, /* @__PURE__ */ new Set([...visiting, resolved.resolved.name]));
+	}
+};
+function resolveOwnBreak(value, formula) {
+	if (value.kind !== "boolean") fail(`a group expression must evaluate to a boolean break test (rpt:HASCHANGED(...)), but this one produced a ${value.kind} value`, formula);
+	return value.value;
+}
+var GroupBreaks = class {
+	rowCount;
+	rows;
+	constructor(prepared, evaluator, rowCount) {
+		this.rowCount = rowCount;
+		const rows = [];
+		for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+			const flags = [];
+			let enclosingBroke = false;
+			for (const [level, expression] of prepared.groupExpressions.entries()) {
+				const ownBreak = resolveOwnBreak(evaluator.evaluate(expression, rowIndex, {
+					kind: "group",
+					level
+				}), expression.text);
+				const broke = enclosingBroke || rowIndex === 0 || ownBreak;
+				flags.push(broke);
+				enclosingBroke = broke;
+			}
+			rows.push(flags);
+		}
+		this.rows = rows;
+	}
+	flagsAt(rowIndex) {
+		const flags = this.rows[rowIndex];
+		if (flags === void 0) throw new Error(`rpt report run: row ${String(rowIndex)} is outside the ${String(this.rowCount)} rows its group breaks were computed for`);
+		return flags;
+	}
+	outermostBreakAt(rowIndex) {
+		return this.flagsAt(rowIndex).indexOf(true);
+	}
+	breaksAt(rowIndex, level) {
+		return this.flagsAt(rowIndex)[level] === true;
+	}
+	instanceContaining(level, rowIndex) {
+		let startRow = rowIndex;
+		while (startRow > 0 && !this.breaksAt(startRow, level)) startRow -= 1;
+		let endRowExclusive = rowIndex + 1;
+		while (endRowExclusive < this.rowCount && !this.breaksAt(endRowExclusive, level)) endRowExclusive += 1;
+		return {
+			startRow,
+			endRowExclusive
+		};
+	}
+};
+function detailScope(groupCount) {
+	return groupCount === 0 ? { kind: "report" } : {
+		kind: "group",
+		level: groupCount - 1
+	};
+}
+function runRptReport(definition, resultSet) {
+	const rowCount = resultSet.rows.length;
+	const levels = definition.groups.length;
+	const prepared = new PreparedReport(definition, resultSet);
+	const state = new RunState(levels, rowCount);
+	const evaluator = new FormulaEvaluator(prepared, state);
+	const bands = [];
+	const emit = (band, kind, groupLevel, rowIndex, scope) => {
+		if (band === void 0) return;
+		bands.push({
+			kind,
+			groupLevel,
+			rowIndex,
+			values: band.map((formula) => formula === void 0 ? void 0 : evaluator.evaluate(formula, rowIndex, scope))
+		});
+	};
+	emit(prepared.bands.reportHeader, "report-header", void 0, void 0, { kind: "report" });
+	const breaks = new GroupBreaks(prepared, evaluator, rowCount);
+	const closeFrom = (level) => {
+		for (let openLevel = levels - 1; openLevel >= level; openLevel -= 1) {
+			const open = state.openAt(openLevel);
+			if (open === void 0) continue;
+			emit(prepared.bands.groups[openLevel]?.footer, "group-footer", openLevel, open.endRowExclusive - 1, {
+				kind: "group",
+				level: openLevel
+			});
+			state.close(openLevel);
+		}
+	};
+	for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+		const outermostBroken = breaks.outermostBreakAt(rowIndex);
+		if (outermostBroken >= 0) {
+			closeFrom(outermostBroken);
+			for (let level = outermostBroken; level < levels; level += 1) {
+				state.open(level, breaks.instanceContaining(level, rowIndex));
+				emit(prepared.bands.groups[level]?.header, "group-header", level, rowIndex, {
+					kind: "group",
+					level
+				});
+			}
+		}
+		emit(prepared.bands.detail, "detail", void 0, rowIndex, detailScope(levels));
+	}
+	closeFrom(0);
+	emit(prepared.bands.reportFooter, "report-footer", void 0, void 0, { kind: "report" });
+	return { bands };
+}
+function evaluateRptBandOutsideData(definition, band, resultSet) {
+	const evaluator = new FormulaEvaluator(new PreparedReport(definition, resultSet), new RunState(definition.groups.length, resultSet.rows.length));
+	return prepareBandFormulas(band).map((formula) => formula === void 0 ? void 0 : evaluator.evaluate(formula, void 0, { kind: "report" }));
+}
+//#endregion
+exports.evaluateRptBandOutsideData = evaluateRptBandOutsideData;
+exports.runRptReport = runRptReport;

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

@@ -0,0 +1,43 @@
+import { t as SqlResultSet } from "../../evaluate-BhMXY6DM.cjs";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/formula/evaluate.d.ts
+type RptBandKind = 'report-header' | 'group-header' | 'detail' | 'group-footer' | 'report-footer';
+type RptScope = {
+  readonly kind: 'report';
+} | {
+  readonly kind: 'group';
+  readonly level: number;
+};
+interface RptNamedFunctionDefinition {
+  readonly name: string;
+  readonly formula: string;
+}
+interface RptBandDefinition {
+  readonly formulas: readonly (string | undefined)[];
+}
+interface RptGroupDefinition {
+  readonly groupExpression: string;
+  readonly functions: readonly RptNamedFunctionDefinition[];
+  readonly header: RptBandDefinition | undefined;
+  readonly footer: RptBandDefinition | undefined;
+}
+interface RptReportDefinition {
+  readonly functions: readonly RptNamedFunctionDefinition[];
+  readonly reportHeader: RptBandDefinition | undefined;
+  readonly groups: readonly RptGroupDefinition[];
+  readonly detail: RptBandDefinition | undefined;
+  readonly reportFooter: RptBandDefinition | undefined;
+}
+interface RptBandInstance {
+  readonly kind: RptBandKind;
+  readonly groupLevel: number | undefined;
+  readonly rowIndex: number | undefined;
+  readonly values: readonly (ContentCellValue | undefined)[];
+}
+interface RptReportRun {
+  readonly bands: readonly RptBandInstance[];
+}
+declare function runRptReport(definition: RptReportDefinition, resultSet: SqlResultSet): RptReportRun;
+declare function evaluateRptBandOutsideData(definition: RptReportDefinition, band: RptBandDefinition, resultSet: SqlResultSet): readonly (ContentCellValue | undefined)[];
+//#endregion
+export { RptBandDefinition, RptBandInstance, RptBandKind, RptGroupDefinition, RptNamedFunctionDefinition, RptReportDefinition, RptReportRun, RptScope, evaluateRptBandOutsideData, runRptReport };

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

@@ -0,0 +1,43 @@
+import { t as SqlResultSet } from "../../evaluate-BU5N1Jk1.js";
+import { ContentCellValue } from "document-schema.js";
+//#region src/odb/formula/evaluate.d.ts
+type RptBandKind = 'report-header' | 'group-header' | 'detail' | 'group-footer' | 'report-footer';
+type RptScope = {
+  readonly kind: 'report';
+} | {
+  readonly kind: 'group';
+  readonly level: number;
+};
+interface RptNamedFunctionDefinition {
+  readonly name: string;
+  readonly formula: string;
+}
+interface RptBandDefinition {
+  readonly formulas: readonly (string | undefined)[];
+}
+interface RptGroupDefinition {
+  readonly groupExpression: string;
+  readonly functions: readonly RptNamedFunctionDefinition[];
+  readonly header: RptBandDefinition | undefined;
+  readonly footer: RptBandDefinition | undefined;
+}
+interface RptReportDefinition {
+  readonly functions: readonly RptNamedFunctionDefinition[];
+  readonly reportHeader: RptBandDefinition | undefined;
+  readonly groups: readonly RptGroupDefinition[];
+  readonly detail: RptBandDefinition | undefined;
+  readonly reportFooter: RptBandDefinition | undefined;
+}
+interface RptBandInstance {
+  readonly kind: RptBandKind;
+  readonly groupLevel: number | undefined;
+  readonly rowIndex: number | undefined;
+  readonly values: readonly (ContentCellValue | undefined)[];
+}
+interface RptReportRun {
+  readonly bands: readonly RptBandInstance[];
+}
+declare function runRptReport(definition: RptReportDefinition, resultSet: SqlResultSet): RptReportRun;
+declare function evaluateRptBandOutsideData(definition: RptReportDefinition, band: RptBandDefinition, resultSet: SqlResultSet): readonly (ContentCellValue | undefined)[];
+//#endregion
+export { RptBandDefinition, RptBandInstance, RptBandKind, RptGroupDefinition, RptNamedFunctionDefinition, RptReportDefinition, RptReportRun, RptScope, evaluateRptBandOutsideData, runRptReport };

package/dist/odb/formula/evaluate.js

@@ -0,0 +1,281 @@
+import { CELL_NULL, aggregateCellValues, cellComparisonKey, cellValuesEqual } from "../values.js";
+import { RptFormulaEvaluationError } from "./errors.js";
+import { parseRptFormula } from "./parser.js";
+//#region src/odb/formula/evaluate.ts
+function fail(message, formula) {
+	throw new RptFormulaEvaluationError(message, formula);
+}
+function matchNamed(candidates, nameOf, name) {
+	const exact = candidates.filter((candidate) => nameOf(candidate) === name);
+	return exact.length > 0 ? exact : candidates.filter((candidate) => nameOf(candidate).toUpperCase() === name.toUpperCase());
+}
+function identity(name) {
+	return name;
+}
+function prepareBandFormulas(band) {
+	return band.formulas.map((formula) => formula === void 0 ? void 0 : parseRptFormula(formula));
+}
+function prepareBand(band) {
+	return band === void 0 ? void 0 : prepareBandFormulas(band);
+}
+var PreparedReport = class {
+	resultSet;
+	namedFunctions;
+	groupExpressions;
+	bands;
+	columnNames;
+	resolutions = /* @__PURE__ */ new Map();
+	constructor(definition, resultSet) {
+		this.resultSet = resultSet;
+		this.columnNames = resultSet.columns;
+		const named = /* @__PURE__ */ new Map();
+		const declare = (functions, scope) => {
+			for (const declaration of functions) {
+				if (named.has(declaration.name)) fail(`rpt:function "${declaration.name}" is declared more than once in this report`, declaration.formula);
+				named.set(declaration.name, {
+					name: declaration.name,
+					formula: parseRptFormula(declaration.formula),
+					scope
+				});
+			}
+		};
+		declare(definition.functions, { kind: "report" });
+		for (const [level, group] of definition.groups.entries()) declare(group.functions, {
+			kind: "group",
+			level
+		});
+		this.namedFunctions = named;
+		this.groupExpressions = definition.groups.map((group) => parseRptFormula(group.groupExpression));
+		this.bands = {
+			reportHeader: prepareBand(definition.reportHeader),
+			detail: prepareBand(definition.detail),
+			reportFooter: prepareBand(definition.reportFooter),
+			groups: definition.groups.map((group) => ({
+				header: prepareBand(group.header),
+				footer: prepareBand(group.footer)
+			}))
+		};
+		for (const expression of this.groupExpressions) this.rejectAggregateDependency(expression, expression, /* @__PURE__ */ new Set());
+	}
+	rejectAggregateDependency(formula, expression, visiting) {
+		if (formula.kind === "aggregate") fail(`a group expression cannot depend on the aggregate rpt:${formula.aggregate}(${formula.reference.name}) -- an aggregate's own rows are defined by the very group boundaries this expression decides`, expression.text);
+		const resolved = matchNamed([...this.namedFunctions.values()], (candidate) => candidate.name, formula.reference.name)[0];
+		if (resolved === void 0) return;
+		if (visiting.has(resolved.name)) fail(`rpt:function "${resolved.name}" refers to itself, directly or through another function`, expression.text);
+		this.rejectAggregateDependency(resolved.formula, expression, /* @__PURE__ */ new Set([...visiting, resolved.name]));
+	}
+	resolveReference(reference, formula) {
+		const cached = this.resolutions.get(reference);
+		if (cached !== void 0) return cached;
+		const functionMatches = matchNamed([...this.namedFunctions.values()], (candidate) => candidate.name, reference.name);
+		const columnMatches = matchNamed(this.columnNames, identity, reference.name);
+		if (functionMatches.length + columnMatches.length > 1) fail(`reference "${reference.name}" is ambiguous -- it matches ${[...functionMatches.map((match) => `rpt:function ${match.name}`), ...columnMatches.map((match) => `column ${match}`)].join(", ")}`, formula);
+		const resolved = this.resolveSingleMatch(reference, functionMatches[0], columnMatches[0], formula);
+		this.resolutions.set(reference, resolved);
+		return resolved;
+	}
+	resolveSingleMatch(reference, named, columnName, formula) {
+		if (named !== void 0) return {
+			kind: "function",
+			resolved: named
+		};
+		if (columnName === void 0) fail(`reference "${reference.name}" names neither a declared rpt:function nor a column of the report's own data -- functions: ${this.namedFunctions.size === 0 ? "(none)" : [...this.namedFunctions.keys()].join(", ")}; columns: ${this.columnNames.length === 0 ? "(none)" : this.columnNames.join(", ")}`, formula);
+		return {
+			kind: "column",
+			index: this.columnNames.indexOf(columnName)
+		};
+	}
+	valueAt(columnIndex, rowIndex, formula) {
+		const value = this.resultSet.rows[rowIndex]?.[columnIndex];
+		if (value === void 0) fail(`the report's own data has no value at row ${String(rowIndex)}, column ${String(columnIndex)}`, formula);
+		return value;
+	}
+};
+var RunState = class {
+	rowCount;
+	openInstances;
+	constructor(levels, rowCount) {
+		this.rowCount = rowCount;
+		this.openInstances = Array.from({ length: levels }, () => void 0);
+	}
+	open(level, range) {
+		this.openInstances[level] = range;
+	}
+	openAt(level) {
+		return this.openInstances[level];
+	}
+	close(level) {
+		this.openInstances[level] = void 0;
+	}
+	rangeFor(scope, formula) {
+		if (scope.kind === "report") return {
+			startRow: 0,
+			endRowExclusive: this.rowCount
+		};
+		const open = this.openInstances[scope.level];
+		if (open === void 0) fail(`an aggregate scoped to group level ${String(scope.level)} was evaluated while no instance of that group was open`, formula);
+		return open;
+	}
+};
+function textOf(value, formula, what) {
+	if (value.kind === "empty") return;
+	const key = cellComparisonKey(value);
+	if (key?.valueClass !== "text") fail(`${what} requires a text value, but found a ${value.kind} value -- this engine does not format a number or a boolean into text, since a report's own number format lives in its band styles rather than in the formula`, formula);
+	return key.text;
+}
+var FormulaEvaluator = class {
+	prepared;
+	state;
+	constructor(prepared, state) {
+		this.prepared = prepared;
+		this.state = state;
+	}
+	evaluate(formula, rowIndex, scope, visiting = /* @__PURE__ */ new Set()) {
+		switch (formula.kind) {
+			case "field": return this.referenceValue(formula.reference, this.requireRow(rowIndex, formula.text, "a field: reference"), formula.text, visiting);
+			case "hasChanged": {
+				const rowOfChange = this.requireRow(rowIndex, formula.text, "rpt:HASCHANGED");
+				const current = this.referenceValue(formula.reference, rowOfChange, formula.text, visiting);
+				if (rowOfChange === 0) return {
+					kind: "boolean",
+					value: true
+				};
+				const previous = this.referenceValue(formula.reference, rowOfChange - 1, formula.text, visiting);
+				return {
+					kind: "boolean",
+					value: !cellValuesEqual(current, previous)
+				};
+			}
+			case "left": {
+				const text = textOf(this.referenceValue(formula.reference, this.requireRow(rowIndex, formula.text, "rpt:LEFT"), formula.text, visiting), formula.text, "rpt:LEFT");
+				return text === void 0 ? CELL_NULL : {
+					kind: "string",
+					value: [...text].slice(0, formula.length).join("")
+				};
+			}
+			case "aggregate": {
+				const range = this.state.rangeFor(scope, formula.text);
+				const values = [];
+				for (let row = range.startRow; row < range.endRowExclusive; row += 1) values.push(this.referenceValue(formula.reference, row, formula.text, visiting));
+				return aggregateCellValues(formula.aggregate, values, (message) => new RptFormulaEvaluationError(message, formula.text));
+			}
+		}
+	}
+	requireRow(rowIndex, formula, what) {
+		if (rowIndex === void 0) fail(`${what} needs a data row, but the band it appears in belongs to no row (the report header and footer print outside the data)`, formula);
+		return rowIndex;
+	}
+	referenceValue(reference, rowIndex, formula, visiting) {
+		const resolved = this.prepared.resolveReference(reference, formula);
+		if (resolved.kind === "column") return this.prepared.valueAt(resolved.index, rowIndex, formula);
+		if (visiting.has(resolved.resolved.name)) fail(`rpt:function "${resolved.resolved.name}" refers to itself, directly or through another function`, formula);
+		return this.evaluate(resolved.resolved.formula, rowIndex, resolved.resolved.scope, /* @__PURE__ */ new Set([...visiting, resolved.resolved.name]));
+	}
+};
+function resolveOwnBreak(value, formula) {
+	if (value.kind !== "boolean") fail(`a group expression must evaluate to a boolean break test (rpt:HASCHANGED(...)), but this one produced a ${value.kind} value`, formula);
+	return value.value;
+}
+var GroupBreaks = class {
+	rowCount;
+	rows;
+	constructor(prepared, evaluator, rowCount) {
+		this.rowCount = rowCount;
+		const rows = [];
+		for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+			const flags = [];
+			let enclosingBroke = false;
+			for (const [level, expression] of prepared.groupExpressions.entries()) {
+				const ownBreak = resolveOwnBreak(evaluator.evaluate(expression, rowIndex, {
+					kind: "group",
+					level
+				}), expression.text);
+				const broke = enclosingBroke || rowIndex === 0 || ownBreak;
+				flags.push(broke);
+				enclosingBroke = broke;
+			}
+			rows.push(flags);
+		}
+		this.rows = rows;
+	}
+	flagsAt(rowIndex) {
+		const flags = this.rows[rowIndex];
+		if (flags === void 0) throw new Error(`rpt report run: row ${String(rowIndex)} is outside the ${String(this.rowCount)} rows its group breaks were computed for`);
+		return flags;
+	}
+	outermostBreakAt(rowIndex) {
+		return this.flagsAt(rowIndex).indexOf(true);
+	}
+	breaksAt(rowIndex, level) {
+		return this.flagsAt(rowIndex)[level] === true;
+	}
+	instanceContaining(level, rowIndex) {
+		let startRow = rowIndex;
+		while (startRow > 0 && !this.breaksAt(startRow, level)) startRow -= 1;
+		let endRowExclusive = rowIndex + 1;
+		while (endRowExclusive < this.rowCount && !this.breaksAt(endRowExclusive, level)) endRowExclusive += 1;
+		return {
+			startRow,
+			endRowExclusive
+		};
+	}
+};
+function detailScope(groupCount) {
+	return groupCount === 0 ? { kind: "report" } : {
+		kind: "group",
+		level: groupCount - 1
+	};
+}
+function runRptReport(definition, resultSet) {
+	const rowCount = resultSet.rows.length;
+	const levels = definition.groups.length;
+	const prepared = new PreparedReport(definition, resultSet);
+	const state = new RunState(levels, rowCount);
+	const evaluator = new FormulaEvaluator(prepared, state);
+	const bands = [];
+	const emit = (band, kind, groupLevel, rowIndex, scope) => {
+		if (band === void 0) return;
+		bands.push({
+			kind,
+			groupLevel,
+			rowIndex,
+			values: band.map((formula) => formula === void 0 ? void 0 : evaluator.evaluate(formula, rowIndex, scope))
+		});
+	};
+	emit(prepared.bands.reportHeader, "report-header", void 0, void 0, { kind: "report" });
+	const breaks = new GroupBreaks(prepared, evaluator, rowCount);
+	const closeFrom = (level) => {
+		for (let openLevel = levels - 1; openLevel >= level; openLevel -= 1) {
+			const open = state.openAt(openLevel);
+			if (open === void 0) continue;
+			emit(prepared.bands.groups[openLevel]?.footer, "group-footer", openLevel, open.endRowExclusive - 1, {
+				kind: "group",
+				level: openLevel
+			});
+			state.close(openLevel);
+		}
+	};
+	for (let rowIndex = 0; rowIndex < rowCount; rowIndex += 1) {
+		const outermostBroken = breaks.outermostBreakAt(rowIndex);
+		if (outermostBroken >= 0) {
+			closeFrom(outermostBroken);
+			for (let level = outermostBroken; level < levels; level += 1) {
+				state.open(level, breaks.instanceContaining(level, rowIndex));
+				emit(prepared.bands.groups[level]?.header, "group-header", level, rowIndex, {
+					kind: "group",
+					level
+				});
+			}
+		}
+		emit(prepared.bands.detail, "detail", void 0, rowIndex, detailScope(levels));
+	}
+	closeFrom(0);
+	emit(prepared.bands.reportFooter, "report-footer", void 0, void 0, { kind: "report" });
+	return { bands };
+}
+function evaluateRptBandOutsideData(definition, band, resultSet) {
+	const evaluator = new FormulaEvaluator(new PreparedReport(definition, resultSet), new RunState(definition.groups.length, resultSet.rows.length));
+	return prepareBandFormulas(band).map((formula) => formula === void 0 ? void 0 : evaluator.evaluate(formula, void 0, { kind: "report" }));
+}
+//#endregion
+export { evaluateRptBandOutsideData, runRptReport };