reamkit 1.13.0 → 1.15.0

package/dist/esm/excel/xls/biff-reader.js

@@ -0,0 +1,1418 @@
+import { pt } from "../../core/ir/units.js";
+import { ResourceStore } from "../../core/ir/resources.js";
+import { openCfb } from "../../core/ole/cfb.js";
+import { parseBiffChart } from "./biff-chart.js";
+import { buildBiffPalette, parseBiffStyles } from "./biff-styles.js";
+import { parseBlipStore, parseSheetPictures, parseSheetShapes } from "./escher.js";
+//#region src/excel/xls/biff-reader.ts
+var REC = {
+	BOF: 2057,
+	EOF: 10,
+	BOUNDSHEET8: 133,
+	SST: 252,
+	CONTINUE: 60,
+	DATEMODE: 34,
+	DIMENSIONS: 512,
+	NUMBER: 515,
+	RK: 638,
+	MULRK: 189,
+	LABELSST: 253,
+	LABEL: 516,
+	RSTRING: 214,
+	BOOLERR: 517,
+	FORMULA: 6,
+	STRING: 519,
+	MERGECELLS: 229,
+	COLINFO: 125,
+	ROW: 520,
+	WINDOW2: 574,
+	PANE: 65,
+	MSODRAWINGGROUP: 235,
+	MSODRAWING: 236,
+	TXO: 438,
+	HLINK: 440,
+	NAME: 24,
+	SETUP: 161,
+	WSBOOL: 129,
+	PRINTGRIDLINES: 43,
+	HCENTER: 131,
+	VCENTER: 132,
+	LEFTMARGIN: 38,
+	RIGHTMARGIN: 39,
+	TOPMARGIN: 40,
+	BOTTOMMARGIN: 41,
+	HEADER: 20,
+	FOOTER: 21,
+	HPAGEBREAK: 27,
+	VPAGEBREAK: 26,
+	NOTE: 28,
+	OBJ: 93,
+	DV: 446,
+	CONDFMT: 432,
+	CF: 433,
+	CONDFMT12: 2169,
+	CF12: 2170
+};
+var MAX_SHEETS = 4096;
+var MAX_CELLS = 1 << 22;
+var MAX_STRINGS = 1 << 21;
+var MAX_ROW_HEIGHTS = 1 << 20;
+function readXlsToSheetDoc(xls) {
+	const cfb = openCfb(xls);
+	const wb = cfb.readStream("Workbook") ?? cfb.readStream("Book");
+	if (!wb) throw new Error("not an .xls: no Workbook/Book stream");
+	const view = new DataView(wb.buffer, wb.byteOffset, wb.byteLength);
+	const globals = readSubstream(wb, view, 0);
+	if (globals.length === 0 || globals[0].type !== REC.BOF) throw new Error(".xls: missing workbook globals BOF");
+	if (globals[0].data.length >= 2 && readU16(globals[0].data, 0) !== 1536) throw new Error(".xls: only BIFF8 (Excel 97-2003) is supported — re-save as .xlsx");
+	let date1904 = false;
+	const boundSheets = [];
+	let sharedStrings = [];
+	const lblRecords = [];
+	for (let i = 0; i < globals.length; i++) {
+		const rec = globals[i];
+		switch (rec.type) {
+			case REC.NAME:
+				lblRecords.push(rec.data);
+				break;
+			case REC.DATEMODE:
+				date1904 = rec.data.length >= 2 && readU16(rec.data, 0) === 1;
+				break;
+			case REC.BOUNDSHEET8:
+				if (boundSheets.length < MAX_SHEETS) boundSheets.push(parseBoundSheet(rec.data));
+				break;
+			case REC.SST: {
+				const blocks = [rec.data];
+				while (i + 1 < globals.length && globals[i + 1].type === REC.CONTINUE) blocks.push(globals[++i].data);
+				sharedStrings = readSst(blocks);
+				break;
+			}
+		}
+	}
+	const resources = new ResourceStore();
+	const blips = parseBlipStore(gatherDrawing(globals, REC.MSODRAWINGGROUP));
+	const chartData = /* @__PURE__ */ new Map();
+	const dxfs = [];
+	const cfColor = buildBiffPalette(globals);
+	const sheets = [];
+	for (const bs of boundSheets) {
+		if (bs.type !== 0) continue;
+		if (bs.offset + 4 > wb.length) continue;
+		const { grid, images, charts, shapes, hyperlinks, comments } = readSheet(wb, view, bs.offset, blips, resources, sharedStrings, chartData, dxfs, cfColor);
+		sheets.push({
+			name: bs.name,
+			grid,
+			...images.length > 0 ? { images } : {},
+			...charts.length > 0 ? { charts } : {},
+			...shapes.length > 0 ? { shapes } : {},
+			...hyperlinks.length > 0 ? { hyperlinks } : {},
+			...comments.length > 0 ? { comments } : {}
+		});
+	}
+	if (sheets.length === 0) throw new Error(".xls has no worksheets");
+	const baseStyles = parseBiffStyles(globals);
+	return {
+		kind: "sheet",
+		sheets,
+		styles: dxfs.length > 0 ? {
+			...baseStyles,
+			dxfs
+		} : baseStyles,
+		sharedStrings,
+		definedNames: buildDefinedNames(lblRecords, boundSheets),
+		date1904,
+		resources,
+		...chartData.size > 0 ? { chartData } : {}
+	};
+}
+function gatherDrawing(recs, type) {
+	const parts = [];
+	let inside = false;
+	for (const rec of recs) if (rec.type === type) {
+		parts.push(rec.data);
+		inside = true;
+	} else if (rec.type === REC.CONTINUE && inside) parts.push(rec.data);
+	else inside = false;
+	return concatBytes(parts);
+}
+function concatBytes(parts) {
+	const total = parts.reduce((n, p) => n + p.length, 0);
+	const out = new Uint8Array(total);
+	let off = 0;
+	for (const p of parts) {
+		out.set(p, off);
+		off += p.length;
+	}
+	return out;
+}
+function readSubstream(wb, view, start) {
+	const out = [];
+	let p = start;
+	let depth = 0;
+	while (p + 4 <= wb.length) {
+		const type = view.getUint16(p, true);
+		const len = view.getUint16(p + 2, true);
+		const dataStart = p + 4;
+		if (dataStart + len > wb.length) break;
+		out.push({
+			type,
+			data: wb.subarray(dataStart, dataStart + len)
+		});
+		p = dataStart + len;
+		if (type === REC.BOF) depth++;
+		else if (type === REC.EOF && --depth <= 0) break;
+		if (out.length > 1e6) break;
+	}
+	return out;
+}
+function parseBoundSheet(data) {
+	const offset = readU32(data, 0);
+	const type = data[5] ?? 0;
+	return {
+		name: readShortString(data, 6),
+		offset,
+		type
+	};
+}
+function readSheet(wb, view, start, blips, resources, sharedStrings, chartData, dxfs, cfColor) {
+	const records = readSubstream(wb, view, start);
+	const cells = [];
+	const merges = [];
+	const columns = [];
+	const hyperlinks = [];
+	const rowHeights = [];
+	let frozen = false;
+	let paneSplit;
+	let maxRow = -1;
+	let maxColumn = -1;
+	const add = (cell) => {
+		if (cells.length >= MAX_CELLS) return;
+		cells.push(cell);
+		if (cell.row > maxRow) maxRow = cell.row;
+		if (cell.column > maxColumn) maxColumn = cell.column;
+	};
+	for (let i = 0; i < records.length; i++) {
+		const rec = records[i];
+		const d = rec.data;
+		switch (rec.type) {
+			case REC.NUMBER:
+				add(numCell(readU16(d, 0), readU16(d, 2), readU16(d, 4), String(readF64(d, 6))));
+				break;
+			case REC.RK:
+				add(numCell(readU16(d, 0), readU16(d, 2), readU16(d, 4), String(decodeRk(readU32(d, 6)))));
+				break;
+			case REC.MULRK: {
+				const row = readU16(d, 0);
+				const colFirst = readU16(d, 2);
+				const count = Math.floor((d.length - 6) / 6);
+				for (let k = 0; k < count; k++) {
+					const ixfe = readU16(d, 4 + k * 6);
+					const rk = readU32(d, 4 + k * 6 + 2);
+					add(numCell(row, colFirst + k, ixfe, String(decodeRk(rk))));
+				}
+				break;
+			}
+			case REC.LABELSST: {
+				const isst = readU32(d, 6);
+				add({
+					column: readU16(d, 2),
+					row: readU16(d, 0),
+					type: "s",
+					rawValue: String(isst),
+					styleIndex: readU16(d, 4)
+				});
+				break;
+			}
+			case REC.LABEL:
+			case REC.RSTRING:
+				add(strCell(readU16(d, 0), readU16(d, 2), readU16(d, 4), readXlString(d, 6)));
+				break;
+			case REC.BOOLERR: {
+				const row = readU16(d, 0);
+				const col = readU16(d, 2);
+				const styleIndex = readU16(d, 4);
+				const val = d[6] ?? 0;
+				add((d[7] ?? 0) !== 0 ? {
+					column: col,
+					row,
+					type: "e",
+					rawValue: errorText(val),
+					styleIndex
+				} : {
+					column: col,
+					row,
+					type: "b",
+					rawValue: val ? "1" : "0",
+					styleIndex
+				});
+				break;
+			}
+			case REC.FORMULA: {
+				const cell = formulaCell(d, records[i + 1]);
+				if (cell) add(cell);
+				break;
+			}
+			case REC.MERGECELLS: {
+				const cmcs = readU16(d, 0);
+				for (let k = 0; k < cmcs; k++) {
+					const o = 2 + k * 8;
+					if (o + 8 > d.length) break;
+					merges.push({
+						startRow: readU16(d, o),
+						endRow: readU16(d, o + 2),
+						startColumn: readU16(d, o + 4),
+						endColumn: readU16(d, o + 6)
+					});
+				}
+				break;
+			}
+			case REC.COLINFO: {
+				const colFirst = readU16(d, 0);
+				const colLast = readU16(d, 2);
+				const widthChars = readU16(d, 4) / 256;
+				columns.push({
+					min: colFirst + 1,
+					max: colLast + 1,
+					widthChars
+				});
+				break;
+			}
+			case REC.ROW:
+				if (d.length >= 14 && rowHeights.length < MAX_ROW_HEIGHTS) {
+					if ((readU16(d, 12) & 64) !== 0) rowHeights.push({
+						row: readU16(d, 0),
+						heightPt: (readU16(d, 6) & 32767) / 20,
+						customHeight: true
+					});
+				}
+				break;
+			case REC.WINDOW2:
+				if (d.length >= 2) frozen = (readU16(d, 0) & 8) !== 0;
+				break;
+			case REC.PANE:
+				if (d.length >= 4) paneSplit = {
+					cols: readU16(d, 0),
+					rows: readU16(d, 2)
+				};
+				break;
+			case REC.HLINK: {
+				const link = parseHlink(d);
+				if (link) hyperlinks.push(link);
+				break;
+			}
+		}
+	}
+	const dataValidations = parseDataValidations(records);
+	const conditionalFormats = [...parseConditionalFormats(records, dxfs, cfColor), ...parseConditionalFormats12(records, cfColor)];
+	const pane = frozen && paneSplit && (paneSplit.rows > 0 || paneSplit.cols > 0) ? {
+		frozenRows: paneSplit.rows,
+		frozenCols: paneSplit.cols
+	} : void 0;
+	const grid = {
+		cells,
+		maxRow,
+		maxColumn,
+		columns,
+		merges,
+		rowHeights,
+		...parsePrintModel(records),
+		...dataValidations.length > 0 ? { dataValidations } : {},
+		...conditionalFormats.length > 0 ? { conditionalFormats } : {},
+		...pane ? { pane } : {}
+	};
+	const drawing = gatherDrawing(records, REC.MSODRAWING);
+	const images = drawing.length > 0 && blips.length > 0 ? buildImages(drawing, blips, resources) : [];
+	const charts = [];
+	for (let i = 0; i < records.length; i++) {
+		if (records[i].type !== REC.BOF || readU16(records[i].data, 2) !== 32) continue;
+		let depth = 0;
+		const sub = [];
+		let j = i;
+		for (; j < records.length; j++) {
+			sub.push(records[j]);
+			if (records[j].type === REC.BOF) depth++;
+			else if (records[j].type === REC.EOF && --depth <= 0) break;
+		}
+		i = j;
+		const chart = parseBiffChart(sub, cells, sharedStrings);
+		if (chart) {
+			const path = `xls-chart-${chartData.size}`;
+			chartData.set(path, chart);
+			charts.push({
+				chartPartPath: path,
+				widthPt: 360,
+				heightPt: 240
+			});
+		}
+	}
+	return {
+		grid,
+		images,
+		charts,
+		shapes: drawing.length > 0 ? buildShapes(parseSheetShapes(drawing), gatherTxoTexts(records)) : [],
+		hyperlinks,
+		comments: parseComments(records)
+	};
+}
+var HLINK_HAS_MONIKER = 1;
+var HLINK_HAS_DISPLAY_NAME = 16;
+var HLINK_HAS_FRAME_NAME = 128;
+var HLINK_MONIKER_AS_STR = 256;
+var URL_MONIKER_CLSID = [
+	224,
+	201,
+	234,
+	121,
+	249,
+	186,
+	206,
+	17,
+	140,
+	130,
+	0,
+	170,
+	0,
+	75,
+	169,
+	11
+];
+function parseHlink(d) {
+	if (d.length < 32) return void 0;
+	const ref = {
+		startRow: readU16(d, 0),
+		endRow: readU16(d, 2),
+		startColumn: readU16(d, 4),
+		endColumn: readU16(d, 6)
+	};
+	if (readU32(d, 24) !== 2) return void 0;
+	const flags = readU32(d, 28);
+	let off = 32;
+	if (flags & HLINK_HAS_DISPLAY_NAME) off = skipHlinkString(d, off);
+	if (flags & HLINK_HAS_FRAME_NAME) off = skipHlinkString(d, off);
+	if ((flags & HLINK_HAS_MONIKER) === 0) return void 0;
+	if (flags & HLINK_MONIKER_AS_STR) {
+		const s = readHlinkString(d, off);
+		return s && isAbsoluteUrl(s.value) ? {
+			ref,
+			url: s.value
+		} : void 0;
+	}
+	if (off + 16 > d.length || !clsidEquals(d, off, URL_MONIKER_CLSID)) return void 0;
+	const url = readUrlMonikerUrl(d, off + 16);
+	return url ? {
+		ref,
+		url
+	} : void 0;
+}
+function readHlinkString(d, off) {
+	if (off + 4 > d.length) return void 0;
+	const bytes = readU32(d, off) * 2;
+	const start = off + 4;
+	if (start + bytes > d.length) return void 0;
+	return {
+		value: stripNul(decodeUtf16Le(d, start, bytes)),
+		next: start + bytes
+	};
+}
+function skipHlinkString(d, off) {
+	return readHlinkString(d, off)?.next ?? d.length;
+}
+function readUrlMonikerUrl(d, off) {
+	if (off + 4 > d.length) return void 0;
+	let s = "";
+	for (let i = off + 4; i + 1 < d.length; i += 2) {
+		const c = d[i] | d[i + 1] << 8;
+		if (c === 0) break;
+		s += String.fromCharCode(c);
+	}
+	return s.length > 0 ? s : void 0;
+}
+function decodeUtf16Le(d, off, bytes) {
+	let s = "";
+	for (let i = 0; i + 1 < bytes; i += 2) s += String.fromCharCode(d[off + i] | d[off + i + 1] << 8);
+	return s;
+}
+function stripNul(s) {
+	for (let i = 0; i < s.length; i++) if (s.charCodeAt(i) === 0) return s.slice(0, i);
+	return s;
+}
+function isAbsoluteUrl(s) {
+	return /^[a-z][a-z0-9+.-]*:\/\//i.test(s);
+}
+function clsidEquals(d, off, clsid) {
+	for (let i = 0; i < 16; i++) if (d[off + i] !== clsid[i]) return false;
+	return true;
+}
+function parsePrintModel(records) {
+	let paperSize;
+	let orientation;
+	let scale;
+	let fitToWidth;
+	let fitToHeight;
+	let fitToPage;
+	let gridLines;
+	let horizontalCentered;
+	let verticalCentered;
+	let left;
+	let right;
+	let top;
+	let bottom;
+	let headerMargin;
+	let footerMargin;
+	let oddHeader;
+	let oddFooter;
+	let rowBreaks;
+	let colBreaks;
+	for (const r of records) {
+		const d = r.data;
+		switch (r.type) {
+			case REC.SETUP: {
+				if (d.length < 12) break;
+				const grbit = readU16(d, 10);
+				if ((grbit & 4) === 0 && (grbit & 64) === 0) orientation = (grbit & 2) !== 0 ? "portrait" : "landscape";
+				const sc = readU16(d, 2);
+				if (sc >= 10 && sc <= 400) scale = sc;
+				const ps = readU16(d, 0);
+				if ((grbit & 4) === 0 && ps > 0) paperSize = ps;
+				fitToWidth = readU16(d, 6);
+				fitToHeight = readU16(d, 8);
+				if (d.length >= 32) {
+					headerMargin = readF64(d, 16);
+					footerMargin = readF64(d, 24);
+				}
+				break;
+			}
+			case REC.WSBOOL:
+				if (d.length >= 2) fitToPage = (readU16(d, 0) & 256) !== 0;
+				break;
+			case REC.PRINTGRIDLINES:
+				if (d.length >= 2) gridLines = (readU16(d, 0) & 1) !== 0;
+				break;
+			case REC.HCENTER:
+				if (d.length >= 2) horizontalCentered = readU16(d, 0) !== 0;
+				break;
+			case REC.VCENTER:
+				if (d.length >= 2) verticalCentered = readU16(d, 0) !== 0;
+				break;
+			case REC.LEFTMARGIN:
+				if (d.length >= 8) left = readF64(d, 0);
+				break;
+			case REC.RIGHTMARGIN:
+				if (d.length >= 8) right = readF64(d, 0);
+				break;
+			case REC.TOPMARGIN:
+				if (d.length >= 8) top = readF64(d, 0);
+				break;
+			case REC.BOTTOMMARGIN:
+				if (d.length >= 8) bottom = readF64(d, 0);
+				break;
+			case REC.HEADER: {
+				const s = readXlString(d, 0);
+				if (s.length > 0) oddHeader = s;
+				break;
+			}
+			case REC.FOOTER: {
+				const s = readXlString(d, 0);
+				if (s.length > 0) oddFooter = s;
+				break;
+			}
+			case REC.HPAGEBREAK:
+				rowBreaks = parseBreaks(d);
+				break;
+			case REC.VPAGEBREAK:
+				colBreaks = parseBreaks(d);
+				break;
+		}
+	}
+	const pageSetup = {
+		...paperSize !== void 0 ? { paperSize } : {},
+		...orientation !== void 0 ? { orientation } : {},
+		...scale !== void 0 ? { scale } : {},
+		...fitToWidth !== void 0 ? { fitToWidth } : {},
+		...fitToHeight !== void 0 ? { fitToHeight } : {}
+	};
+	const printOptions = {
+		...gridLines !== void 0 ? { gridLines } : {},
+		...horizontalCentered !== void 0 ? { horizontalCentered } : {},
+		...verticalCentered !== void 0 ? { verticalCentered } : {}
+	};
+	const pageMargins = left !== void 0 && right !== void 0 && top !== void 0 && bottom !== void 0 ? {
+		leftInches: left,
+		rightInches: right,
+		topInches: top,
+		bottomInches: bottom,
+		...headerMargin !== void 0 ? { headerInches: headerMargin } : {},
+		...footerMargin !== void 0 ? { footerInches: footerMargin } : {}
+	} : void 0;
+	const headerFooter = {
+		...oddHeader !== void 0 ? { oddHeader } : {},
+		...oddFooter !== void 0 ? { oddFooter } : {}
+	};
+	return {
+		...Object.keys(pageSetup).length > 0 ? { pageSetup } : {},
+		...fitToPage !== void 0 ? { fitToPage } : {},
+		...Object.keys(printOptions).length > 0 ? { printOptions } : {},
+		...pageMargins ? { pageMargins } : {},
+		...Object.keys(headerFooter).length > 0 ? { headerFooter } : {},
+		...rowBreaks && rowBreaks.length > 0 ? { rowBreaks } : {},
+		...colBreaks && colBreaks.length > 0 ? { colBreaks } : {}
+	};
+}
+function parseBreaks(d) {
+	const count = readU16(d, 0);
+	const out = [];
+	for (let k = 0; k < count && 2 + k * 6 + 2 <= d.length; k++) out.push(readU16(d, 2 + k * 6));
+	return out;
+}
+var BUILTIN_NAMES = new Map([[6, "_xlnm.Print_Area"], [7, "_xlnm.Print_Titles"]]);
+function buildDefinedNames(lblRecords, boundSheets) {
+	const wsIndex = [];
+	let ws = 0;
+	for (const bs of boundSheets) wsIndex.push(bs.type === 0 ? ws++ : void 0);
+	const out = [];
+	for (const d of lblRecords) {
+		const dn = parseLbl(d, wsIndex);
+		if (dn) out.push(dn);
+	}
+	return out;
+}
+function parseLbl(d, wsIndex) {
+	if (d.length < 15) return void 0;
+	const builtin = (readU16(d, 0) & 32) !== 0;
+	const cch = d[3];
+	const cce = readU16(d, 4);
+	const itab = readU16(d, 8);
+	const highByte = (d[14] & 1) !== 0;
+	const nameBytes = cch * (highByte ? 2 : 1);
+	let name;
+	if (builtin) {
+		const id = highByte ? readU16(d, 15) : d[15] ?? 255;
+		const mapped = BUILTIN_NAMES.get(id);
+		if (mapped === void 0) return void 0;
+		name = mapped;
+	} else {
+		name = decodeChars(d, 15, cch, highByte);
+		if (name.length === 0) return void 0;
+	}
+	const rgceOff = 15 + nameBytes;
+	const value = formatNameValue(d.subarray(rgceOff, Math.min(d.length, rgceOff + cce)));
+	if (value === void 0) return void 0;
+	if (itab > 0) {
+		const localSheetId = wsIndex[itab - 1];
+		if (localSheetId === void 0) return void 0;
+		return {
+			name,
+			value,
+			localSheetId
+		};
+	}
+	return {
+		name,
+		value
+	};
+}
+function formatNameValue(rgce) {
+	const areas = extractNameAreas(rgce);
+	return areas ? areas.map(formatArea).join(",") : void 0;
+}
+function extractNameAreas(rgce) {
+	const areas = [];
+	let off = 0;
+	while (off < rgce.length) {
+		const ptg = rgce[off];
+		const base = ptg & 31;
+		if (ptg >= 32 && base === 5) {
+			if (off + 9 > rgce.length) return void 0;
+			areas.push(readArea(rgce, off + 1));
+			off += 9;
+		} else if (ptg >= 32 && base === 27) {
+			if (off + 11 > rgce.length) return void 0;
+			areas.push(readArea(rgce, off + 3));
+			off += 11;
+		} else if (ptg >= 32 && base === 4) {
+			if (off + 5 > rgce.length) return void 0;
+			areas.push(readCell(rgce, off + 1));
+			off += 5;
+		} else if (ptg >= 32 && base === 26) {
+			if (off + 7 > rgce.length) return void 0;
+			areas.push(readCell(rgce, off + 3));
+			off += 7;
+		} else if (ptg >= 32 && base === 9) off += 3;
+		else if (ptg >= 32 && base === 6) off += 7;
+		else if (ptg === 16 || ptg === 15 || ptg === 17 || ptg === 21) off += 1;
+		else return;
+	}
+	return areas.length > 0 ? areas : void 0;
+}
+function readArea(d, off) {
+	return {
+		r0: readU16(d, off),
+		r1: readU16(d, off + 2),
+		c0: readU16(d, off + 4) & 16383,
+		c1: readU16(d, off + 6) & 16383
+	};
+}
+function readCell(d, off) {
+	const r = readU16(d, off);
+	const c = readU16(d, off + 2) & 16383;
+	return {
+		r0: r,
+		r1: r,
+		c0: c,
+		c1: c
+	};
+}
+function formatArea(a) {
+	const fullWidth = a.c0 === 0 && a.c1 >= 255;
+	const fullHeight = a.r0 === 0 && a.r1 >= 65535;
+	if (fullWidth && !fullHeight) return `${a.r0 + 1}:${a.r1 + 1}`;
+	if (fullHeight && !fullWidth) return `${colLetters(a.c0)}:${colLetters(a.c1)}`;
+	const tl = `${colLetters(a.c0)}${a.r0 + 1}`;
+	return a.r0 === a.r1 && a.c0 === a.c1 ? tl : `${tl}:${colLetters(a.c1)}${a.r1 + 1}`;
+}
+function colLetters(c) {
+	let n = c + 1;
+	let s = "";
+	while (n > 0) {
+		n--;
+		s = String.fromCharCode(65 + n % 26) + s;
+		n = Math.floor(n / 26);
+	}
+	return s;
+}
+var DV_TYPES = [
+	"none",
+	"whole",
+	"decimal",
+	"list",
+	"date",
+	"time",
+	"textLength",
+	"custom"
+];
+var DV_OPERATORS = [
+	"between",
+	"notBetween",
+	"equal",
+	"notEqual",
+	"greaterThan",
+	"lessThan",
+	"greaterThanOrEqual",
+	"lessThanOrEqual"
+];
+var DV_OPERATOR_TYPES = new Set([
+	"whole",
+	"decimal",
+	"date",
+	"time",
+	"textLength"
+]);
+function parseDataValidations(records) {
+	const out = [];
+	for (const r of records) if (r.type === REC.DV) {
+		const dv = parseDv(r.data);
+		if (dv) out.push(dv);
+	}
+	return out;
+}
+function parseDv(d) {
+	if (d.length < 4) return void 0;
+	const flags = readU32(d, 0);
+	const type = DV_TYPES[flags & 15];
+	if (type === void 0) return void 0;
+	const operator = DV_OPERATORS[flags >> 20 & 15];
+	let off = 4;
+	const promptTitle = readXlStringEnd(d, off);
+	off = promptTitle.next;
+	const errorTitle = readXlStringEnd(d, off);
+	off = errorTitle.next;
+	const prompt = readXlStringEnd(d, off);
+	off = prompt.next;
+	const error = readXlStringEnd(d, off);
+	off = error.next;
+	if (off + 4 > d.length) return void 0;
+	const cce1 = readU16(d, off);
+	off += 4;
+	const rgce1 = d.subarray(off, Math.min(d.length, off + cce1));
+	off += cce1;
+	if (off + 4 > d.length) return void 0;
+	const cce2 = readU16(d, off);
+	off += 4 + cce2;
+	if (off + 2 > d.length) return void 0;
+	const cref = readU16(d, off);
+	off += 2;
+	const ranges = [];
+	for (let k = 0; k < cref && off + 8 <= d.length; k++) {
+		ranges.push({
+			startRow: readU16(d, off),
+			endRow: readU16(d, off + 2),
+			startColumn: readU16(d, off + 4),
+			endColumn: readU16(d, off + 6)
+		});
+		off += 8;
+	}
+	if (ranges.length === 0) return void 0;
+	const formula1 = type === "list" ? extractListSource(rgce1) : void 0;
+	return {
+		type,
+		ranges,
+		...operator !== void 0 && DV_OPERATOR_TYPES.has(type) ? { operator } : {},
+		...(flags & 256) !== 0 ? { allowBlank: true } : {},
+		showDropDown: (flags & 512) !== 0,
+		...(flags & 262144) !== 0 ? { showInputMessage: true } : {},
+		...(flags & 524288) !== 0 ? { showErrorMessage: true } : {},
+		...promptTitle.value ? { promptTitle: promptTitle.value } : {},
+		...errorTitle.value ? { errorTitle: errorTitle.value } : {},
+		...prompt.value ? { prompt: prompt.value } : {},
+		...error.value ? { error: error.value } : {},
+		...formula1 ? { formula1 } : {}
+	};
+}
+function extractListSource(rgce) {
+	if (rgce.length >= 3 && rgce[0] === 23) {
+		const cch = rgce[1];
+		return `"${decodeChars(rgce, 3, cch, (rgce[2] & 1) !== 0)}"`;
+	}
+	const areas = extractNameAreas(rgce);
+	return areas ? areas.map(formatArea).join(",") : void 0;
+}
+function readXlStringEnd(d, off) {
+	if (off + 3 > d.length) return {
+		value: "",
+		next: d.length
+	};
+	const cch = readU16(d, off);
+	const flags = d[off + 2];
+	const high = (flags & 1) !== 0;
+	let p = off + 3;
+	if ((flags & 8) !== 0) p += 2;
+	if ((flags & 4) !== 0) p += 4;
+	return {
+		value: decodeChars(d, p, cch, high),
+		next: p + cch * (high ? 2 : 1)
+	};
+}
+var CF_OPERATORS = [
+	void 0,
+	"between",
+	"notBetween",
+	"equal",
+	"notEqual",
+	"greaterThan",
+	"lessThan",
+	"greaterThanOrEqual",
+	"lessThanOrEqual"
+];
+var DXF_FONT = 67108864;
+var DXF_ALIGN = 134217728;
+var DXF_BORDER = 268435456;
+var DXF_PATTERN = 536870912;
+var DXF_PROT = 1073741824;
+function parseConditionalFormats(records, dxfs, color) {
+	const out = [];
+	for (let i = 0; i < records.length; i++) {
+		if (records[i].type !== REC.CONDFMT) continue;
+		const head = records[i].data;
+		if (head.length < 14) continue;
+		const ccf = readU16(head, 0);
+		const cref = readU16(head, 12);
+		const ranges = [];
+		for (let k = 0; k < cref && 14 + k * 8 + 8 <= head.length; k++) {
+			const o = 14 + k * 8;
+			ranges.push({
+				startRow: readU16(head, o),
+				endRow: readU16(head, o + 2),
+				startColumn: readU16(head, o + 4),
+				endColumn: readU16(head, o + 6)
+			});
+		}
+		const rules = [];
+		let priority = 1;
+		for (let j = i + 1; j < records.length && rules.length < ccf; j++) {
+			if (records[j].type !== REC.CF) break;
+			const rule = parseCfRule(records[j].data, dxfs, color, priority++);
+			if (rule) rules.push(rule);
+		}
+		if (ranges.length > 0 && rules.length > 0) out.push({
+			ranges,
+			rules
+		});
+	}
+	return out;
+}
+function parseCfRule(d, dxfs, color, priority) {
+	if (d.length < 6) return void 0;
+	const ct = d[0];
+	if (ct !== 1 && ct !== 2) return void 0;
+	const cce1 = readU16(d, 2);
+	const cce2 = readU16(d, 4);
+	const rgce1Start = d.length - cce2 - cce1;
+	if (rgce1Start < 6) return void 0;
+	const dxfId = dxfs.length;
+	dxfs.push(parseCfDxf(d, rgce1Start, color));
+	if (ct === 2) return {
+		type: "expression",
+		priority,
+		formula: "(formula)",
+		dxfId
+	};
+	const operator = CF_OPERATORS[d[1]];
+	if (operator === void 0) return void 0;
+	const formulas = [];
+	const f1 = cfConstant(d.subarray(rgce1Start, d.length - cce2));
+	if (f1 !== void 0) formulas.push(f1);
+	if (cce2 > 0) {
+		const f2 = cfConstant(d.subarray(d.length - cce2));
+		if (f2 !== void 0) formulas.push(f2);
+	}
+	return {
+		type: "cellIs",
+		priority,
+		operator,
+		formulas,
+		dxfId
+	};
+}
+function parseCfDxf(d, rgce1Start, color) {
+	const dxf = {};
+	if (rgce1Start < 12) return dxf;
+	const options = readU32(d, 6);
+	let p = 12;
+	const fontAt = (options & DXF_FONT) !== 0 ? p : -1;
+	if (options & DXF_FONT) p += 118;
+	if (options & DXF_ALIGN) p += 8;
+	if (options & DXF_BORDER) p += 8;
+	const patAt = (options & DXF_PATTERN) !== 0 ? p : -1;
+	if (options & DXF_PATTERN) p += 4;
+	if (options & DXF_PROT) p += 2;
+	if (p !== rgce1Start) return dxf;
+	if (patAt >= 0 && patAt + 4 <= d.length) {
+		const pat = readU32(d, patAt);
+		const hex = color(pat >> 16 & 127) ?? color(pat >> 23 & 127);
+		if (hex) dxf.fill = {
+			patternType: "solid",
+			fgColorHex: hex
+		};
+	}
+	if (fontAt >= 0 && fontAt + 84 <= d.length) {
+		const icvFore = readU32(d, fontAt + 80) | 0;
+		if (icvFore >= 0) {
+			const hex = color(icvFore);
+			if (hex) dxf.font = { colorHex: hex };
+		}
+	}
+	return dxf;
+}
+function cfConstant(rgce) {
+	if (rgce.length < 1) return void 0;
+	const ptg = rgce[0];
+	if (ptg === 30 && rgce.length >= 3) return String(readU16(rgce, 1));
+	if (ptg === 31 && rgce.length >= 9) return String(readF64(rgce, 1));
+	if (ptg === 23 && rgce.length >= 3) return `"${decodeChars(rgce, 3, rgce[1], (rgce[2] & 1) !== 0)}"`;
+}
+var FTR_HEADER = 12;
+var CF12_COLOR_SCALE = 3;
+var CF12_DATA_BAR = 4;
+var CF12_ICON_SET = 6;
+var CF12_ICON_REVERSED = 4;
+var CF12_ICON_SETS = [
+	"3Arrows",
+	"3ArrowsGray",
+	"3Flags",
+	"3TrafficLights1",
+	"3TrafficLights2",
+	"3Signs",
+	"3Symbols",
+	"3Symbols2",
+	"4Arrows",
+	"4ArrowsGray",
+	"4RedToBlack",
+	"4Rating",
+	"4TrafficLights",
+	"5Arrows",
+	"5ArrowsGray",
+	"5Rating",
+	"5Quarters"
+];
+var CF12_CFVO_TYPES = [
+	void 0,
+	"num",
+	"min",
+	"max",
+	"percent",
+	"percentile",
+	void 0,
+	"formula"
+];
+var u8 = (c) => c.d[c.p++] ?? 0;
+var u16At = (c) => {
+	const v = readU16(c.d, c.p);
+	c.p += 2;
+	return v;
+};
+var i32At = (c) => {
+	const v = readU32(c.d, c.p) | 0;
+	c.p += 4;
+	return v;
+};
+var f64At = (c) => {
+	const v = readF64(c.d, c.p);
+	c.p += 8;
+	return v;
+};
+function rgbToHex(r, g, b) {
+	return (r.toString(16).padStart(2, "0") + g.toString(16).padStart(2, "0") + b.toString(16).padStart(2, "0")).toUpperCase();
+}
+function readExtColor(c, color) {
+	if (c.p + 16 > c.d.length) return void 0;
+	const xclrType = i32At(c);
+	let hex;
+	if (xclrType === 1) hex = color(i32At(c));
+	else if (xclrType === 2) {
+		hex = rgbToHex(c.d[c.p] ?? 0, c.d[c.p + 1] ?? 0, c.d[c.p + 2] ?? 0);
+		c.p += 4;
+	} else c.p += 4;
+	c.p += 8;
+	return hex;
+}
+function readCfvo(c, trailer) {
+	if (c.p + 3 > c.d.length) return void 0;
+	const typeId = u8(c);
+	const cce = u16At(c);
+	c.p += cce;
+	let val;
+	if (cce === 0 && typeId !== 2 && typeId !== 3) val = String(f64At(c));
+	c.p += trailer;
+	const type = CF12_CFVO_TYPES[typeId];
+	if (type === void 0 || c.p > c.d.length) return void 0;
+	return val !== void 0 ? {
+		type,
+		val
+	} : { type };
+}
+function readColorScale(c, priority, color) {
+	c.p += 3;
+	const numI = u8(c);
+	const numG = u8(c);
+	c.p += 1;
+	if (numI < 2 || numI > 3 || numI !== numG) return void 0;
+	const cfvos = [];
+	for (let k = 0; k < numI; k++) {
+		const v = readCfvo(c, 8);
+		if (!v) return void 0;
+		cfvos.push(v);
+	}
+	const colorsHex = [];
+	for (let k = 0; k < numG; k++) {
+		c.p += 8;
+		const hex = readExtColor(c, color);
+		if (!hex) return void 0;
+		colorsHex.push(hex);
+	}
+	if (c.p > c.d.length) return void 0;
+	return {
+		type: "colorScale",
+		priority,
+		cfvos,
+		colorsHex
+	};
+}
+function readDataBar(c, priority, color) {
+	c.p += 4;
+	const minLength = u8(c);
+	const maxLength = u8(c);
+	const colorHex = readExtColor(c, color);
+	if (!colorHex) return void 0;
+	const lo = readCfvo(c, 0);
+	const hi = readCfvo(c, 0);
+	if (!lo || !hi) return void 0;
+	return {
+		type: "dataBar",
+		priority,
+		cfvos: [lo, hi],
+		colorHex,
+		minLength,
+		maxLength
+	};
+}
+function readIconSet(c, priority) {
+	c.p += 3;
+	const num = u8(c);
+	const setId = u8(c);
+	const options = u8(c);
+	const iconSet = CF12_ICON_SETS[setId];
+	if (iconSet === void 0 || num < 3 || num > 5) return void 0;
+	const cfvos = [];
+	for (let k = 0; k < num; k++) {
+		const v = readCfvo(c, 5);
+		if (!v) return void 0;
+		cfvos.push(v);
+	}
+	const reverse = (options & CF12_ICON_REVERSED) !== 0;
+	return {
+		type: "iconSet",
+		priority,
+		iconSet,
+		cfvos,
+		...reverse ? { reverse } : {}
+	};
+}
+function parseCf12Rule(d, color) {
+	if (d.length < FTR_HEADER + 16) return void 0;
+	const c = {
+		d,
+		p: FTR_HEADER
+	};
+	const ct = u8(c);
+	c.p += 1;
+	const cce1 = u16At(c);
+	const cce2 = u16At(c);
+	const extLen = i32At(c);
+	c.p += extLen === 0 ? 2 : extLen;
+	c.p += cce1 + cce2;
+	const scaleLen = u16At(c);
+	c.p += scaleLen;
+	c.p += 1;
+	const priority = u16At(c);
+	c.p += 2;
+	const tplLen = u8(c);
+	c.p += tplLen;
+	if (c.p > d.length) return void 0;
+	if (ct === CF12_COLOR_SCALE) return readColorScale(c, priority, color);
+	if (ct === CF12_DATA_BAR) return readDataBar(c, priority, color);
+	if (ct === CF12_ICON_SET) return readIconSet(c, priority);
+}
+function parseConditionalFormats12(records, color) {
+	const out = [];
+	for (let i = 0; i < records.length; i++) {
+		if (records[i].type !== REC.CONDFMT12) continue;
+		const head = records[i].data;
+		if (head.length < FTR_HEADER + 14) continue;
+		const numcf = readU16(head, FTR_HEADER);
+		const cref = readU16(head, FTR_HEADER + 12);
+		const ranges = [];
+		for (let k = 0; k < cref && FTR_HEADER + 14 + k * 8 + 8 <= head.length; k++) {
+			const o = FTR_HEADER + 14 + k * 8;
+			ranges.push({
+				startRow: readU16(head, o),
+				endRow: readU16(head, o + 2),
+				startColumn: readU16(head, o + 4),
+				endColumn: readU16(head, o + 6)
+			});
+		}
+		const rules = [];
+		let seen = 0;
+		for (let j = i + 1; j < records.length && seen < numcf; j++) {
+			if (records[j].type !== REC.CF12) break;
+			seen++;
+			const rule = parseCf12Rule(records[j].data, color);
+			if (rule) rules.push(rule);
+		}
+		if (ranges.length > 0 && rules.length > 0) out.push({
+			ranges,
+			rules
+		});
+	}
+	return out;
+}
+function gatherTxoTexts(recs) {
+	const out = [];
+	for (let i = 0; i < recs.length; i++) {
+		if (recs[i].type !== REC.TXO) continue;
+		const cch = readU16(recs[i].data, 10);
+		const next = recs[i + 1];
+		if (cch > 0 && next && next.type === REC.CONTINUE && next.data.length > 0) out.push(decodeChars(next.data, 1, cch, (next.data[0] & 1) !== 0));
+		else out.push("");
+	}
+	return out;
+}
+function parseComments(records) {
+	const textByObj = /* @__PURE__ */ new Map();
+	let pendingObjId;
+	const notes = [];
+	for (let i = 0; i < records.length; i++) {
+		const r = records[i];
+		const d = r.data;
+		if (r.type === REC.OBJ) pendingObjId = d.length >= 8 && readU16(d, 0) === 21 && readU16(d, 4) === 25 ? readU16(d, 6) : void 0;
+		else if (r.type === REC.TXO && pendingObjId !== void 0) {
+			const cch = readU16(d, 10);
+			const next = records[i + 1];
+			textByObj.set(pendingObjId, cch > 0 && next && next.type === REC.CONTINUE && next.data.length > 0 ? decodeChars(next.data, 1, cch, (next.data[0] & 1) !== 0) : "");
+			pendingObjId = void 0;
+		} else if (r.type === REC.NOTE && d.length >= 11) {
+			const cchAuthor = readU16(d, 8);
+			notes.push({
+				rw: readU16(d, 0),
+				col: readU16(d, 2),
+				idObj: readU16(d, 6),
+				author: decodeChars(d, 11, cchAuthor, (d[10] & 1) !== 0)
+			});
+		}
+	}
+	const out = [];
+	for (const n of notes) {
+		const text = textByObj.get(n.idObj) ?? "";
+		if (text.length === 0) continue;
+		out.push({
+			ref: `${colLetters(n.col)}${n.rw + 1}`,
+			...n.author.length > 0 ? { author: n.author } : {},
+			text,
+			threaded: false
+		});
+	}
+	return out;
+}
+function buildShapes(escherShapes, txoTexts) {
+	const out = [];
+	let textIdx = 0;
+	for (const s of escherShapes) {
+		const text = s.hasText ? txoTexts[textIdx++] ?? "" : "";
+		const { widthPt, heightPt } = anchorSize(s.anchor);
+		out.push({
+			width: pt(widthPt),
+			height: pt(heightPt),
+			geometry: {
+				kind: "preset",
+				preset: shapePreset(s.shapeType)
+			},
+			fill: s.fillColorHex ? {
+				kind: "solid",
+				colorHex: s.fillColorHex
+			} : { kind: "none" },
+			...s.lineColorHex ? { line: { colorHex: s.lineColorHex } } : {},
+			...text.length > 0 ? { text: { content: [{
+				kind: "paragraph",
+				paragraph: {
+					properties: {},
+					runs: [{
+						text,
+						properties: {}
+					}]
+				}
+			}] } } : {},
+			paragraphProperties: {}
+		});
+	}
+	return out;
+}
+function shapePreset(type) {
+	switch (type) {
+		case 1: return "rect";
+		case 2: return "roundRect";
+		case 3: return "ellipse";
+		case 4: return "diamond";
+		case 5: return "triangle";
+		case 6: return "rtTriangle";
+		case 7: return "parallelogram";
+		case 8: return "trapezoid";
+		case 9: return "hexagon";
+		case 20: return "line";
+		default: return "rect";
+	}
+}
+function buildImages(drawing, blips, resources) {
+	const out = [];
+	for (const pic of parseSheetPictures(drawing)) {
+		const bytes = blips[pic.blipIndex - 1];
+		if (!bytes) continue;
+		const { widthPt, heightPt } = anchorSize(pic.anchor);
+		out.push({
+			resourceId: resources.put(bytes),
+			widthPt,
+			heightPt
+		});
+	}
+	return out;
+}
+function anchorSize(anchor) {
+	if (!anchor) return {
+		widthPt: 96,
+		heightPt: 72
+	};
+	const DEFAULT_COL_PT = 48;
+	const DEFAULT_ROW_PT = 15;
+	const cols = anchor.col2 + anchor.dx2 / 1024 - (anchor.col1 + anchor.dx1 / 1024);
+	const rows = anchor.row2 + anchor.dy2 / 1024 - (anchor.row1 + anchor.dy1 / 1024);
+	return {
+		widthPt: Math.max(8, cols * DEFAULT_COL_PT),
+		heightPt: Math.max(8, rows * DEFAULT_ROW_PT)
+	};
+}
+function numCell(row, column, style, rawValue) {
+	return {
+		column,
+		row,
+		type: "n",
+		rawValue,
+		styleIndex: style
+	};
+}
+function strCell(row, column, style, text) {
+	return {
+		column,
+		row,
+		type: "inlineStr",
+		rawValue: "",
+		inlineText: text,
+		styleIndex: style
+	};
+}
+function formulaCell(d, next) {
+	const row = readU16(d, 0);
+	const col = readU16(d, 2);
+	const style = readU16(d, 4);
+	if (d.length >= 14 && readU16(d, 12) === 65535) {
+		const kind = d[6] ?? 0;
+		if (kind === 0) return strCell(row, col, style, next && next.type === REC.STRING ? readXlString(next.data, 0) : "");
+		if (kind === 1) return {
+			column: col,
+			row,
+			type: "b",
+			rawValue: d[8] ? "1" : "0",
+			styleIndex: style
+		};
+		if (kind === 2) return {
+			column: col,
+			row,
+			type: "e",
+			rawValue: errorText(d[8] ?? 0),
+			styleIndex: style
+		};
+		return;
+	}
+	return numCell(row, col, style, String(readF64(d, 6)));
+}
+function decodeRk(rk) {
+	const div100 = (rk & 1) !== 0;
+	let value;
+	if ((rk & 2) !== 0) value = rk >> 2;
+	else {
+		const dv = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
+		dv.setUint32(0, 0, true);
+		dv.setUint32(4, rk & 4294967292, true);
+		value = dv.getFloat64(0, true);
+	}
+	return div100 ? value / 100 : value;
+}
+function errorText(code) {
+	switch (code) {
+		case 0: return "#NULL!";
+		case 7: return "#DIV/0!";
+		case 15: return "#VALUE!";
+		case 23: return "#REF!";
+		case 29: return "#NAME?";
+		case 36: return "#NUM!";
+		case 42: return "#N/A";
+		default: return "#VALUE!";
+	}
+}
+function readShortString(d, off) {
+	if (off >= d.length) return "";
+	const cch = d[off];
+	const highByte = (d[off + 1] & 1) !== 0;
+	return decodeChars(d, off + 2, cch, highByte);
+}
+function readXlString(d, off) {
+	if (off + 3 > d.length) return "";
+	const cch = readU16(d, off);
+	const flags = d[off + 2];
+	const highByte = (flags & 1) !== 0;
+	const rich = (flags & 8) !== 0;
+	const phonetic = (flags & 4) !== 0;
+	let p = off + 3;
+	if (rich) p += 2;
+	if (phonetic) p += 4;
+	return decodeChars(d, p, cch, highByte);
+}
+function decodeChars(d, off, cch, highByte) {
+	let s = "";
+	if (highByte) for (let i = 0; i < cch && off + i * 2 + 1 < d.length; i++) s += String.fromCharCode(d[off + i * 2] | d[off + i * 2 + 1] << 8);
+	else for (let i = 0; i < cch && off + i < d.length; i++) s += String.fromCharCode(d[off + i]);
+	return s;
+}
+function readSst(blocks) {
+	const r = new SstReader(blocks);
+	r.u32();
+	const cstUnique = Math.min(r.u32(), MAX_STRINGS);
+	const out = [];
+	for (let i = 0; i < cstUnique && !r.atEnd(); i++) out.push(r.readString());
+	return out;
+}
+var SstReader = class {
+	bi = 0;
+	off = 0;
+	constructor(blocks) {
+		this.blocks = blocks;
+	}
+	atEnd() {
+		this.settle();
+		return this.bi >= this.blocks.length;
+	}
+	settle() {
+		while (this.bi < this.blocks.length && this.off >= this.blocks[this.bi].length) {
+			this.bi++;
+			this.off = 0;
+		}
+	}
+	byte() {
+		this.settle();
+		if (this.bi >= this.blocks.length) return 0;
+		return this.blocks[this.bi][this.off++];
+	}
+	u16() {
+		return this.byte() | this.byte() << 8;
+	}
+	u32() {
+		return (this.u16() | this.u16() << 16) >>> 0;
+	}
+	skip(n) {
+		let left = n;
+		while (left > 0) {
+			this.settle();
+			if (this.bi >= this.blocks.length) return;
+			const take = Math.min(left, this.blocks[this.bi].length - this.off);
+			this.off += take;
+			left -= take;
+		}
+	}
+	readString() {
+		const cch = this.u16();
+		const flags = this.byte();
+		let highByte = (flags & 1) !== 0;
+		const rich = (flags & 8) !== 0;
+		const phonetic = (flags & 4) !== 0;
+		const cRun = rich ? this.u16() : 0;
+		const cbExtRst = phonetic ? this.u32() : 0;
+		let s = "";
+		for (let i = 0; i < cch; i++) {
+			if (this.off >= this.blocks[this.bi].length) {
+				this.bi++;
+				this.off = 0;
+				if (this.bi >= this.blocks.length) break;
+				highByte = (this.blocks[this.bi][this.off++] & 1) !== 0;
+			}
+			const block = this.blocks[this.bi];
+			if (highByte) {
+				s += String.fromCharCode(block[this.off] | block[this.off + 1] << 8);
+				this.off += 2;
+			} else {
+				s += String.fromCharCode(block[this.off]);
+				this.off += 1;
+			}
+		}
+		this.skip(cRun * 4 + cbExtRst);
+		return s;
+	}
+};
+function readU16(d, off) {
+	return (d[off] ?? 0) | (d[off + 1] ?? 0) << 8;
+}
+function readU32(d, off) {
+	return ((d[off] ?? 0) | (d[off + 1] ?? 0) << 8 | (d[off + 2] ?? 0) << 16 | (d[off + 3] ?? 0) << 24) >>> 0;
+}
+function readF64(d, off) {
+	if (off + 8 > d.length) return 0;
+	return new DataView(d.buffer, d.byteOffset + off, 8).getFloat64(0, true);
+}
+//#endregion
+export { readXlsToSheetDoc };