xls-codec 1.0.2 → 2.0.0

package/dist/workbook/print-names.cjs

@@ -0,0 +1,241 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../biff/record-types.cjs");
+const require_biff_cursor = require("../biff/cursor.cjs");
+const require_biff_builder = require("../biff/builder.cjs");
+const require_biff_record_writer = require("../biff/record-writer.cjs");
+//#region src/workbook/print-names.ts
+/** The built-in name index a Print_Area Lbl carries in place of a name ([MS-XLS] 2.4.150's own built-in name table). */
+const BUILTIN_NAME_PRINT_AREA = 6;
+/** The same table's Print_Titles entry. */
+const BUILTIN_NAME_PRINT_TITLES = 7;
+/** Lbl.grbit's fBuiltin bit -- field F of [MS-XLS] 2.4.150 (fHidden, fFunc, fOB, fProc, fCalcExp, fBuiltin, fGrp (6 bits), reserved1, fPublished, fWorkbookParam, reserved2). */
+const LBL_FLAG_BUILTIN = 32;
+/** The Ptg opcodes a print name's own token stream is built from ([MS-XLS] 2.5.198.25's enumeration). Each reference-class token shares its layout with its value- and array-class spellings, exactly as biff/ptg.ts documents, so all three are accepted. */
+const PTG_UNION = 16;
+const PTG_PAREN = 21;
+const PTG_REF3D_REF = 58;
+const PTG_REF3D_VALUE = 90;
+const PTG_REF3D_ARRAY = 122;
+const PTG_AREA3D_REF = 59;
+const PTG_AREA3D_VALUE = 91;
+const PTG_AREA3D_ARRAY = 123;
+const PTG_MEMAREA_REF = 38;
+const PTG_MEMAREA_VALUE = 70;
+const PTG_MEMAREA_ARRAY = 102;
+const PTG_MEMFUNC_REF = 41;
+const PTG_MEMFUNC_VALUE = 73;
+const PTG_MEMFUNC_ARRAY = 105;
+/** PtgMemArea ([MS-XLS] 2.5.198.70) carries four unused bytes ahead of its own cce, where PtgMemFunc ([MS-XLS] 2.5.198.71) carries none. */
+const PTG_MEMAREA_UNUSED_BYTES = 4;
+/** BIFF8's own grid ceilings, which are also how a Print_Titles band says which axis it repeats: a band covering every column of the sheet is a ROW band, and one covering every row is a COLUMN band. */
+const MAX_ROW_INDEX = 65535;
+const MAX_COLUMN_INDEX = 255;
+/**
+* Reads every Lbl record in a globals substream into per-sheet print names, keyed by ZERO-based sheet index -- Lbl's own itab is one-based, and a sheet index everywhere else in this package is not.
+*
+* A name this reader does not act on leaves nothing behind rather than failing the workbook: a user-defined name (fBuiltin clear), a built-in name other than the two below, a workbook-scoped one (itab 0, which no real producer uses for a print area since a print area belongs to a sheet), and a name whose token stream holds a construct outside the narrow vocabulary parsePrintAreas resolves are all simply not carried. The sheet then reads with no printRange or repeat bands, which is the same answer a sheet that genuinely declares none gives.
+*/
+function readPrintNames(records) {
+	const bySheet = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (record.type !== 24) continue;
+		const label = readLbl(record);
+		if (label === void 0) continue;
+		const existing = bySheet.get(label.sheetIndex) ?? {};
+		if (label.builtinName === BUILTIN_NAME_PRINT_AREA) {
+			const range = printRangeOf(label.areas);
+			if (range !== void 0) bySheet.set(label.sheetIndex, {
+				...existing,
+				printRange: range
+			});
+		} else bySheet.set(label.sheetIndex, {
+			...existing,
+			...repeatBandsOf(label.areas)
+		});
+	}
+	return bySheet;
+}
+/**
+* Lbl ([MS-XLS] 2.4.150): a two-byte grbit, chKey, cch, cce, a two-byte reserved3, itab, four reserved bytes, the Name as an XLUnicodeStringNoCch, then cce bytes of rgce.
+*
+* A built-in name's Name field is that string holding exactly one character whose code unit IS the built-in index ([MS-XLS] 2.4.150: "Each built-in name has a zero-based index value associated with it. A built-in name or its index value MUST be used for this field."), so cch is 1 and the character is read rather than the spelled-out name. A built-in name spelled out in full instead is not resolved -- no producer writes one, and inventing a name-string table to match against would be guessing at which spelling and which locale.
+*/
+function readLbl(record) {
+	const cursor = new require_biff_cursor.BlockCursor(record.blocks);
+	if ((cursor.u16() & LBL_FLAG_BUILTIN) === 0) return;
+	cursor.skip(1);
+	const cch = cursor.u8();
+	const cce = cursor.u16();
+	cursor.skip(2);
+	const itab = cursor.u16();
+	cursor.skip(4);
+	const highByte = (cursor.u8() & 1) !== 0;
+	if (cch !== 1 || highByte) return;
+	const builtinName = cursor.u8();
+	if (builtinName !== BUILTIN_NAME_PRINT_AREA && builtinName !== BUILTIN_NAME_PRINT_TITLES) return;
+	if (itab === 0) return;
+	const areas = parsePrintAreas(cursor.take(cce));
+	return areas === void 0 ? void 0 : {
+		sheetIndex: itab - 1,
+		builtinName,
+		areas
+	};
+}
+/**
+* Walks a print name's own rgce into the areas it names, or returns undefined for a token stream outside this vocabulary.
+*
+* The whole vocabulary is: a 3D area or single-cell reference (the areas themselves), the union operator joining two of them in a Print_Titles that repeats both a row band and a column band, a mem token wrapping that union (a real producer emits one -- LibreOffice writes PtgMemFunc, Excel may write PtgMemArea -- to say the enclosed reference expression is a single reference result), and PtgParen, a pure display token restating parentheses. Nothing else appears in a print name a spreadsheet application produced, and anything else aborts rather than being partially resolved: half a print range is a wrong print range, not a smaller one.
+*
+* A mem token's own cce covers exactly the sub-expression that follows it, which is the rest of this stream in every real case, so it is read past rather than used to bound a nested parse -- the tokens after it are walked by this same loop either way.
+*/
+function parsePrintAreas(rgce) {
+	const cursor = new require_biff_cursor.BlockCursor([rgce]);
+	const areas = [];
+	while (cursor.remainingInBlock() > 0) switch (cursor.u8()) {
+		case PTG_AREA3D_REF:
+		case PTG_AREA3D_VALUE:
+		case PTG_AREA3D_ARRAY:
+			cursor.skip(2);
+			areas.push(readArea(cursor));
+			break;
+		case PTG_REF3D_REF:
+		case PTG_REF3D_VALUE:
+		case PTG_REF3D_ARRAY: {
+			cursor.skip(2);
+			const row = cursor.u16();
+			const column = cursor.u16() & 16383;
+			areas.push({
+				rowFirst: row,
+				rowLast: row,
+				columnFirst: column,
+				columnLast: column
+			});
+			break;
+		}
+		case PTG_MEMAREA_REF:
+		case PTG_MEMAREA_VALUE:
+		case PTG_MEMAREA_ARRAY:
+			cursor.skip(PTG_MEMAREA_UNUSED_BYTES);
+			cursor.skip(2);
+			break;
+		case PTG_MEMFUNC_REF:
+		case PTG_MEMFUNC_VALUE:
+		case PTG_MEMFUNC_ARRAY:
+			cursor.skip(2);
+			break;
+		case PTG_UNION:
+		case PTG_PAREN: break;
+		default: return;
+	}
+	return areas;
+}
+/** RgceArea ([MS-XLS] 2.5.198.105), as PtgArea3d carries it: both row bounds, then both ColRelU column fields, whose low 14 bits hold the column index and whose top two bits say whether each coordinate is relative. A print name's coordinates are always absolute in practice, and are read as plain indices either way -- ContentSheetPrintRange has no relative/absolute distinction to carry one into. */
+function readArea(cursor) {
+	return {
+		rowFirst: cursor.u16(),
+		rowLast: cursor.u16(),
+		columnFirst: cursor.u16() & 16383,
+		columnLast: cursor.u16() & 16383
+	};
+}
+/** A Print_Area name's own range. A name declaring several disjoint areas -- legal in BIFF8, and what Excel writes for a multi-area print selection -- yields only the first: ContentSheetPrintSettings.printRange models one rectangle, and merging several into their bounding box would claim cells print that do not. */
+function printRangeOf(areas) {
+	const area = areas[0];
+	return area === void 0 ? void 0 : {
+		startRow: area.rowFirst,
+		startColumn: area.columnFirst,
+		endRow: area.rowLast,
+		endColumn: area.columnLast
+	};
+}
+/**
+* A Print_Titles name's own repeated bands, classified by shape.
+*
+* BIFF8 has no field saying which axis a title band repeats along: a repeated row band is written as an area spanning every column of the sheet ($1:$2, columns 0-255), and a repeated column band as one spanning every row ($A:$A, rows 0-65535). The shape IS the discriminant, and an area that spans both axes at once names the whole sheet, which is neither -- so it is left unclassified rather than being assigned to whichever branch happened to be tested first.
+*/
+function repeatBandsOf(areas) {
+	const bands = {};
+	for (const area of areas) {
+		const spansEveryRow = area.rowFirst === 0 && area.rowLast === MAX_ROW_INDEX;
+		const spansEveryColumn = area.columnFirst === 0 && area.columnLast === MAX_COLUMN_INDEX;
+		if (spansEveryColumn && !spansEveryRow) bands.repeatRows = {
+			start: area.rowFirst,
+			end: area.rowLast
+		};
+		else if (spansEveryRow && !spansEveryColumn) bands.repeatColumns = {
+			start: area.columnFirst,
+			end: area.columnLast
+		};
+	}
+	return bands;
+}
+/**
+* Clamps a coordinate into BIFF8's own row/column ceiling. `ContentSheetPrintRange`/`ContentSheetRepeatRange` bound neither a start nor an end coordinate from above, and `writeArea3d` below writes each one into a 16-bit field regardless (`RecordBuilder.u16` masks with `0xffff`), so an out-of-grid coordinate would otherwise silently wrap to a plausible-looking in-grid one -- a print range asked for through row 70000 landing at row 4464, with nothing downstream to notice.
+*
+* Clamped rather than dropped or refused: a print range or a repeated header band is a rectangle whose intent survives shrinking to the grid's own edge -- "print through the bottom of the sheet" is genuinely what an end coordinate past the last row means once the grid is smaller than the caller assumed -- unlike a single-position page break (see sheet-writer.ts's own inGridBreaks, which drops rather than clamps for exactly that distinction).
+*/
+function clampToGrid(index, maxIndex) {
+	return Math.min(index, maxIndex);
+}
+/** The Print_Area and Print_Titles entries one sheet's print settings need, or an empty list when it declares neither a print range nor a repeated band. */
+function printNameEntriesFor(sheetIndex, ixti, settings) {
+	const entries = [];
+	if (settings.printRange !== void 0) entries.push({
+		sheetIndex,
+		ixti,
+		builtinName: BUILTIN_NAME_PRINT_AREA,
+		areas: [{
+			rowFirst: clampToGrid(settings.printRange.startRow, MAX_ROW_INDEX),
+			rowLast: clampToGrid(settings.printRange.endRow, MAX_ROW_INDEX),
+			columnFirst: clampToGrid(settings.printRange.startColumn, MAX_COLUMN_INDEX),
+			columnLast: clampToGrid(settings.printRange.endColumn, MAX_COLUMN_INDEX)
+		}]
+	});
+	const titleAreas = [];
+	if (settings.repeatColumns !== void 0) titleAreas.push({
+		rowFirst: 0,
+		rowLast: MAX_ROW_INDEX,
+		columnFirst: clampToGrid(settings.repeatColumns.start, MAX_COLUMN_INDEX),
+		columnLast: clampToGrid(settings.repeatColumns.end, MAX_COLUMN_INDEX)
+	});
+	if (settings.repeatRows !== void 0) titleAreas.push({
+		rowFirst: clampToGrid(settings.repeatRows.start, MAX_ROW_INDEX),
+		rowLast: clampToGrid(settings.repeatRows.end, MAX_ROW_INDEX),
+		columnFirst: 0,
+		columnLast: MAX_COLUMN_INDEX
+	});
+	if (titleAreas.length > 0) entries.push({
+		sheetIndex,
+		ixti,
+		builtinName: BUILTIN_NAME_PRINT_TITLES,
+		areas: titleAreas
+	});
+	return entries;
+}
+/** PtgArea3d ([MS-XLS] 2.5.198.28), reference class: the opcode, the ixti, then an RgceArea. Every coordinate is written absolute (both ColRelU relative bits clear), which is what a print name means -- a print area does not move relative to anything. */
+function writeArea3d(ixti, area) {
+	return new require_biff_builder.RecordBuilder().u8(PTG_AREA3D_REF).u16(ixti).u16(area.rowFirst).u16(area.rowLast).u16(area.columnFirst).u16(area.columnLast).build();
+}
+/**
+* One Lbl record ([MS-XLS] 2.4.150) for a built-in print name, the write-side mirror of readLbl above.
+*
+* A single area is written as a bare PtgArea3d. Two are written as [MS-XLS] 2.5.198.71's own mem-area-expression shape -- PtgMemFunc carrying the byte count of what follows, then the two areas and the PtgUnion joining them -- which is what says the pair is one reference result rather than two loose operands, and is byte-for-byte the structure a real LibreOffice-written Print_Titles carries for the same pair.
+*/
+function writePrintNameRecord(entry) {
+	const areaTokens = entry.areas.map((area) => writeArea3d(entry.ixti, area));
+	const expression = new require_biff_builder.RecordBuilder();
+	for (const token of areaTokens) expression.bytes(token);
+	for (let index = 1; index < areaTokens.length; index += 1) expression.u8(PTG_UNION);
+	const expressionBytes = expression.build();
+	const rgce = areaTokens.length > 1 ? new require_biff_builder.RecordBuilder().u8(PTG_MEMFUNC_REF).u16(expressionBytes.length).bytes(expressionBytes).build() : expressionBytes;
+	const data = new require_biff_builder.RecordBuilder().u16(LBL_FLAG_BUILTIN).u8(0).u8(1).u16(rgce.length).u16(0).u16(entry.sheetIndex + 1).u32(0).u8(0).u8(entry.builtinName).bytes(rgce).build();
+	return require_biff_record_writer.writeRecord(24, data);
+}
+/** Every planned print name as its own Lbl record, in the order given. */
+function writePrintNameRecords(entries) {
+	return entries.map(writePrintNameRecord);
+}
+//#endregion
+exports.printNameEntriesFor = printNameEntriesFor;
+exports.readPrintNames = readPrintNames;
+exports.writePrintNameRecords = writePrintNameRecords;

package/dist/workbook/print-names.d.cts

@@ -0,0 +1,2 @@
+import { a as writePrintNameRecords, i as readPrintNames, n as SheetPrintNames, r as printNameEntriesFor, t as PrintNamePlanEntry } from "../print-names-D-njuzVw.cjs";
+export { PrintNamePlanEntry, SheetPrintNames, printNameEntriesFor, readPrintNames, writePrintNameRecords };

package/dist/workbook/print-names.d.ts

@@ -0,0 +1,2 @@
+import { a as writePrintNameRecords, i as readPrintNames, n as SheetPrintNames, r as printNameEntriesFor, t as PrintNamePlanEntry } from "../print-names-DUlpVE00.js";
+export { PrintNamePlanEntry, SheetPrintNames, printNameEntriesFor, readPrintNames, writePrintNameRecords };

package/dist/workbook/print-names.js

@@ -0,0 +1,238 @@
+import "../biff/record-types.js";
+import { BlockCursor } from "../biff/cursor.js";
+import { RecordBuilder } from "../biff/builder.js";
+import { writeRecord } from "../biff/record-writer.js";
+//#region src/workbook/print-names.ts
+/** The built-in name index a Print_Area Lbl carries in place of a name ([MS-XLS] 2.4.150's own built-in name table). */
+const BUILTIN_NAME_PRINT_AREA = 6;
+/** The same table's Print_Titles entry. */
+const BUILTIN_NAME_PRINT_TITLES = 7;
+/** Lbl.grbit's fBuiltin bit -- field F of [MS-XLS] 2.4.150 (fHidden, fFunc, fOB, fProc, fCalcExp, fBuiltin, fGrp (6 bits), reserved1, fPublished, fWorkbookParam, reserved2). */
+const LBL_FLAG_BUILTIN = 32;
+/** The Ptg opcodes a print name's own token stream is built from ([MS-XLS] 2.5.198.25's enumeration). Each reference-class token shares its layout with its value- and array-class spellings, exactly as biff/ptg.ts documents, so all three are accepted. */
+const PTG_UNION = 16;
+const PTG_PAREN = 21;
+const PTG_REF3D_REF = 58;
+const PTG_REF3D_VALUE = 90;
+const PTG_REF3D_ARRAY = 122;
+const PTG_AREA3D_REF = 59;
+const PTG_AREA3D_VALUE = 91;
+const PTG_AREA3D_ARRAY = 123;
+const PTG_MEMAREA_REF = 38;
+const PTG_MEMAREA_VALUE = 70;
+const PTG_MEMAREA_ARRAY = 102;
+const PTG_MEMFUNC_REF = 41;
+const PTG_MEMFUNC_VALUE = 73;
+const PTG_MEMFUNC_ARRAY = 105;
+/** PtgMemArea ([MS-XLS] 2.5.198.70) carries four unused bytes ahead of its own cce, where PtgMemFunc ([MS-XLS] 2.5.198.71) carries none. */
+const PTG_MEMAREA_UNUSED_BYTES = 4;
+/** BIFF8's own grid ceilings, which are also how a Print_Titles band says which axis it repeats: a band covering every column of the sheet is a ROW band, and one covering every row is a COLUMN band. */
+const MAX_ROW_INDEX = 65535;
+const MAX_COLUMN_INDEX = 255;
+/**
+* Reads every Lbl record in a globals substream into per-sheet print names, keyed by ZERO-based sheet index -- Lbl's own itab is one-based, and a sheet index everywhere else in this package is not.
+*
+* A name this reader does not act on leaves nothing behind rather than failing the workbook: a user-defined name (fBuiltin clear), a built-in name other than the two below, a workbook-scoped one (itab 0, which no real producer uses for a print area since a print area belongs to a sheet), and a name whose token stream holds a construct outside the narrow vocabulary parsePrintAreas resolves are all simply not carried. The sheet then reads with no printRange or repeat bands, which is the same answer a sheet that genuinely declares none gives.
+*/
+function readPrintNames(records) {
+	const bySheet = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (record.type !== 24) continue;
+		const label = readLbl(record);
+		if (label === void 0) continue;
+		const existing = bySheet.get(label.sheetIndex) ?? {};
+		if (label.builtinName === BUILTIN_NAME_PRINT_AREA) {
+			const range = printRangeOf(label.areas);
+			if (range !== void 0) bySheet.set(label.sheetIndex, {
+				...existing,
+				printRange: range
+			});
+		} else bySheet.set(label.sheetIndex, {
+			...existing,
+			...repeatBandsOf(label.areas)
+		});
+	}
+	return bySheet;
+}
+/**
+* Lbl ([MS-XLS] 2.4.150): a two-byte grbit, chKey, cch, cce, a two-byte reserved3, itab, four reserved bytes, the Name as an XLUnicodeStringNoCch, then cce bytes of rgce.
+*
+* A built-in name's Name field is that string holding exactly one character whose code unit IS the built-in index ([MS-XLS] 2.4.150: "Each built-in name has a zero-based index value associated with it. A built-in name or its index value MUST be used for this field."), so cch is 1 and the character is read rather than the spelled-out name. A built-in name spelled out in full instead is not resolved -- no producer writes one, and inventing a name-string table to match against would be guessing at which spelling and which locale.
+*/
+function readLbl(record) {
+	const cursor = new BlockCursor(record.blocks);
+	if ((cursor.u16() & LBL_FLAG_BUILTIN) === 0) return;
+	cursor.skip(1);
+	const cch = cursor.u8();
+	const cce = cursor.u16();
+	cursor.skip(2);
+	const itab = cursor.u16();
+	cursor.skip(4);
+	const highByte = (cursor.u8() & 1) !== 0;
+	if (cch !== 1 || highByte) return;
+	const builtinName = cursor.u8();
+	if (builtinName !== BUILTIN_NAME_PRINT_AREA && builtinName !== BUILTIN_NAME_PRINT_TITLES) return;
+	if (itab === 0) return;
+	const areas = parsePrintAreas(cursor.take(cce));
+	return areas === void 0 ? void 0 : {
+		sheetIndex: itab - 1,
+		builtinName,
+		areas
+	};
+}
+/**
+* Walks a print name's own rgce into the areas it names, or returns undefined for a token stream outside this vocabulary.
+*
+* The whole vocabulary is: a 3D area or single-cell reference (the areas themselves), the union operator joining two of them in a Print_Titles that repeats both a row band and a column band, a mem token wrapping that union (a real producer emits one -- LibreOffice writes PtgMemFunc, Excel may write PtgMemArea -- to say the enclosed reference expression is a single reference result), and PtgParen, a pure display token restating parentheses. Nothing else appears in a print name a spreadsheet application produced, and anything else aborts rather than being partially resolved: half a print range is a wrong print range, not a smaller one.
+*
+* A mem token's own cce covers exactly the sub-expression that follows it, which is the rest of this stream in every real case, so it is read past rather than used to bound a nested parse -- the tokens after it are walked by this same loop either way.
+*/
+function parsePrintAreas(rgce) {
+	const cursor = new BlockCursor([rgce]);
+	const areas = [];
+	while (cursor.remainingInBlock() > 0) switch (cursor.u8()) {
+		case PTG_AREA3D_REF:
+		case PTG_AREA3D_VALUE:
+		case PTG_AREA3D_ARRAY:
+			cursor.skip(2);
+			areas.push(readArea(cursor));
+			break;
+		case PTG_REF3D_REF:
+		case PTG_REF3D_VALUE:
+		case PTG_REF3D_ARRAY: {
+			cursor.skip(2);
+			const row = cursor.u16();
+			const column = cursor.u16() & 16383;
+			areas.push({
+				rowFirst: row,
+				rowLast: row,
+				columnFirst: column,
+				columnLast: column
+			});
+			break;
+		}
+		case PTG_MEMAREA_REF:
+		case PTG_MEMAREA_VALUE:
+		case PTG_MEMAREA_ARRAY:
+			cursor.skip(PTG_MEMAREA_UNUSED_BYTES);
+			cursor.skip(2);
+			break;
+		case PTG_MEMFUNC_REF:
+		case PTG_MEMFUNC_VALUE:
+		case PTG_MEMFUNC_ARRAY:
+			cursor.skip(2);
+			break;
+		case PTG_UNION:
+		case PTG_PAREN: break;
+		default: return;
+	}
+	return areas;
+}
+/** RgceArea ([MS-XLS] 2.5.198.105), as PtgArea3d carries it: both row bounds, then both ColRelU column fields, whose low 14 bits hold the column index and whose top two bits say whether each coordinate is relative. A print name's coordinates are always absolute in practice, and are read as plain indices either way -- ContentSheetPrintRange has no relative/absolute distinction to carry one into. */
+function readArea(cursor) {
+	return {
+		rowFirst: cursor.u16(),
+		rowLast: cursor.u16(),
+		columnFirst: cursor.u16() & 16383,
+		columnLast: cursor.u16() & 16383
+	};
+}
+/** A Print_Area name's own range. A name declaring several disjoint areas -- legal in BIFF8, and what Excel writes for a multi-area print selection -- yields only the first: ContentSheetPrintSettings.printRange models one rectangle, and merging several into their bounding box would claim cells print that do not. */
+function printRangeOf(areas) {
+	const area = areas[0];
+	return area === void 0 ? void 0 : {
+		startRow: area.rowFirst,
+		startColumn: area.columnFirst,
+		endRow: area.rowLast,
+		endColumn: area.columnLast
+	};
+}
+/**
+* A Print_Titles name's own repeated bands, classified by shape.
+*
+* BIFF8 has no field saying which axis a title band repeats along: a repeated row band is written as an area spanning every column of the sheet ($1:$2, columns 0-255), and a repeated column band as one spanning every row ($A:$A, rows 0-65535). The shape IS the discriminant, and an area that spans both axes at once names the whole sheet, which is neither -- so it is left unclassified rather than being assigned to whichever branch happened to be tested first.
+*/
+function repeatBandsOf(areas) {
+	const bands = {};
+	for (const area of areas) {
+		const spansEveryRow = area.rowFirst === 0 && area.rowLast === MAX_ROW_INDEX;
+		const spansEveryColumn = area.columnFirst === 0 && area.columnLast === MAX_COLUMN_INDEX;
+		if (spansEveryColumn && !spansEveryRow) bands.repeatRows = {
+			start: area.rowFirst,
+			end: area.rowLast
+		};
+		else if (spansEveryRow && !spansEveryColumn) bands.repeatColumns = {
+			start: area.columnFirst,
+			end: area.columnLast
+		};
+	}
+	return bands;
+}
+/**
+* Clamps a coordinate into BIFF8's own row/column ceiling. `ContentSheetPrintRange`/`ContentSheetRepeatRange` bound neither a start nor an end coordinate from above, and `writeArea3d` below writes each one into a 16-bit field regardless (`RecordBuilder.u16` masks with `0xffff`), so an out-of-grid coordinate would otherwise silently wrap to a plausible-looking in-grid one -- a print range asked for through row 70000 landing at row 4464, with nothing downstream to notice.
+*
+* Clamped rather than dropped or refused: a print range or a repeated header band is a rectangle whose intent survives shrinking to the grid's own edge -- "print through the bottom of the sheet" is genuinely what an end coordinate past the last row means once the grid is smaller than the caller assumed -- unlike a single-position page break (see sheet-writer.ts's own inGridBreaks, which drops rather than clamps for exactly that distinction).
+*/
+function clampToGrid(index, maxIndex) {
+	return Math.min(index, maxIndex);
+}
+/** The Print_Area and Print_Titles entries one sheet's print settings need, or an empty list when it declares neither a print range nor a repeated band. */
+function printNameEntriesFor(sheetIndex, ixti, settings) {
+	const entries = [];
+	if (settings.printRange !== void 0) entries.push({
+		sheetIndex,
+		ixti,
+		builtinName: BUILTIN_NAME_PRINT_AREA,
+		areas: [{
+			rowFirst: clampToGrid(settings.printRange.startRow, MAX_ROW_INDEX),
+			rowLast: clampToGrid(settings.printRange.endRow, MAX_ROW_INDEX),
+			columnFirst: clampToGrid(settings.printRange.startColumn, MAX_COLUMN_INDEX),
+			columnLast: clampToGrid(settings.printRange.endColumn, MAX_COLUMN_INDEX)
+		}]
+	});
+	const titleAreas = [];
+	if (settings.repeatColumns !== void 0) titleAreas.push({
+		rowFirst: 0,
+		rowLast: MAX_ROW_INDEX,
+		columnFirst: clampToGrid(settings.repeatColumns.start, MAX_COLUMN_INDEX),
+		columnLast: clampToGrid(settings.repeatColumns.end, MAX_COLUMN_INDEX)
+	});
+	if (settings.repeatRows !== void 0) titleAreas.push({
+		rowFirst: clampToGrid(settings.repeatRows.start, MAX_ROW_INDEX),
+		rowLast: clampToGrid(settings.repeatRows.end, MAX_ROW_INDEX),
+		columnFirst: 0,
+		columnLast: MAX_COLUMN_INDEX
+	});
+	if (titleAreas.length > 0) entries.push({
+		sheetIndex,
+		ixti,
+		builtinName: BUILTIN_NAME_PRINT_TITLES,
+		areas: titleAreas
+	});
+	return entries;
+}
+/** PtgArea3d ([MS-XLS] 2.5.198.28), reference class: the opcode, the ixti, then an RgceArea. Every coordinate is written absolute (both ColRelU relative bits clear), which is what a print name means -- a print area does not move relative to anything. */
+function writeArea3d(ixti, area) {
+	return new RecordBuilder().u8(PTG_AREA3D_REF).u16(ixti).u16(area.rowFirst).u16(area.rowLast).u16(area.columnFirst).u16(area.columnLast).build();
+}
+/**
+* One Lbl record ([MS-XLS] 2.4.150) for a built-in print name, the write-side mirror of readLbl above.
+*
+* A single area is written as a bare PtgArea3d. Two are written as [MS-XLS] 2.5.198.71's own mem-area-expression shape -- PtgMemFunc carrying the byte count of what follows, then the two areas and the PtgUnion joining them -- which is what says the pair is one reference result rather than two loose operands, and is byte-for-byte the structure a real LibreOffice-written Print_Titles carries for the same pair.
+*/
+function writePrintNameRecord(entry) {
+	const areaTokens = entry.areas.map((area) => writeArea3d(entry.ixti, area));
+	const expression = new RecordBuilder();
+	for (const token of areaTokens) expression.bytes(token);
+	for (let index = 1; index < areaTokens.length; index += 1) expression.u8(PTG_UNION);
+	const expressionBytes = expression.build();
+	const rgce = areaTokens.length > 1 ? new RecordBuilder().u8(PTG_MEMFUNC_REF).u16(expressionBytes.length).bytes(expressionBytes).build() : expressionBytes;
+	const data = new RecordBuilder().u16(LBL_FLAG_BUILTIN).u8(0).u8(1).u16(rgce.length).u16(0).u16(entry.sheetIndex + 1).u32(0).u8(0).u8(entry.builtinName).bytes(rgce).build();
+	return writeRecord(24, data);
+}
+/** Every planned print name as its own Lbl record, in the order given. */
+function writePrintNameRecords(entries) {
+	return entries.map(writePrintNameRecord);
+}
+//#endregion
+export { printNameEntriesFor, readPrintNames, writePrintNameRecords };