reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/spreadsheet/styles-parser.js

@@ -0,0 +1,225 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/spreadsheet/styles-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false,
+	removeNSPrefix: true
+});
+var EMPTY_XLSX_STYLES = {
+	numFmts: /* @__PURE__ */ new Map(),
+	fonts: [],
+	fills: [],
+	borders: [],
+	cellXfs: []
+};
+function parseXlsxStyles(data) {
+	const xml = decoder.decode(data);
+	const root = asObject(parser.parse(xml)["styleSheet"]);
+	if (!root) return EMPTY_XLSX_STYLES;
+	return {
+		numFmts: parseNumFmts(root),
+		fonts: parseFonts(root),
+		fills: parseFills(root),
+		borders: parseBorders(root),
+		cellXfs: parseCellXfs(root)
+	};
+}
+var VALID_BORDER_STYLES = new Set([
+	"none",
+	"thin",
+	"medium",
+	"thick",
+	"hair",
+	"dashed",
+	"dotted",
+	"double",
+	"mediumDashed",
+	"dashDot",
+	"mediumDashDot",
+	"dashDotDot",
+	"mediumDashDotDot",
+	"slantDashDot"
+]);
+function parseBorders(root) {
+	const node = asObject(root["borders"]);
+	if (!node) return [];
+	const out = [];
+	for (const item of asArray(node["border"])) {
+		const obj = asObject(item);
+		if (!obj) {
+			out.push({});
+			continue;
+		}
+		const border = {};
+		const top = parseBorderEdge(asObject(obj["top"]));
+		const right = parseBorderEdge(asObject(obj["right"]));
+		const bottom = parseBorderEdge(asObject(obj["bottom"]));
+		const left = parseBorderEdge(asObject(obj["left"]));
+		if (top) border.top = top;
+		if (right) border.right = right;
+		if (bottom) border.bottom = bottom;
+		if (left) border.left = left;
+		out.push(border);
+	}
+	return out;
+}
+function parseBorderEdge(node) {
+	if (!node) return void 0;
+	const styleRaw = strAttr(node, "style");
+	if (!styleRaw) return void 0;
+	if (!VALID_BORDER_STYLES.has(styleRaw)) return void 0;
+	const colorHex = colorOf(asObject(node["color"]));
+	const edge = { style: styleRaw };
+	if (colorHex) edge.colorHex = colorHex;
+	return edge;
+}
+function parseNumFmts(root) {
+	const result = /* @__PURE__ */ new Map();
+	const node = asObject(root["numFmts"]);
+	if (!node) return result;
+	for (const item of asArray(node["numFmt"])) {
+		const obj = asObject(item);
+		if (!obj) continue;
+		const id = numAttr(obj, "numFmtId");
+		const code = strAttr(obj, "formatCode");
+		if (id !== void 0 && code !== void 0) result.set(id, code);
+	}
+	return result;
+}
+function parseFonts(root) {
+	const node = asObject(root["fonts"]);
+	if (!node) return [];
+	const out = [];
+	for (const item of asArray(node["font"])) {
+		const obj = asObject(item);
+		if (!obj) continue;
+		const font = {};
+		const sz = childValAttr(obj, "sz");
+		if (sz !== void 0) {
+			const n = Number(sz);
+			if (Number.isFinite(n)) font.sizePt = n;
+		}
+		if (hasChild(obj, "b")) font.bold = childToggle(obj, "b");
+		if (hasChild(obj, "i")) font.italic = childToggle(obj, "i");
+		if (hasChild(obj, "u")) font.underline = childToggle(obj, "u");
+		const colorRgb = colorOf(asObject(obj["color"]));
+		if (colorRgb) font.colorHex = colorRgb;
+		const nameVal = childValAttr(obj, "name");
+		if (nameVal) font.name = nameVal;
+		out.push(font);
+	}
+	return out;
+}
+function parseFills(root) {
+	const node = asObject(root["fills"]);
+	if (!node) return [];
+	const out = [];
+	for (const item of asArray(node["fill"])) {
+		const obj = asObject(item);
+		if (!obj) continue;
+		const fill = {};
+		const pf = asObject(obj["patternFill"]);
+		if (pf) {
+			const pt = strAttr(pf, "patternType");
+			if (pt) fill.patternType = pt;
+			const fg = colorOf(asObject(pf["fgColor"]));
+			const bg = colorOf(asObject(pf["bgColor"]));
+			if (fg) fill.fgColorHex = fg;
+			if (bg) fill.bgColorHex = bg;
+		}
+		out.push(fill);
+	}
+	return out;
+}
+function parseCellXfs(root) {
+	const node = asObject(root["cellXfs"]);
+	if (!node) return [];
+	const out = [];
+	for (const item of asArray(node["xf"])) {
+		const obj = asObject(item);
+		if (!obj) continue;
+		const xf = {
+			numFmtId: numAttr(obj, "numFmtId") ?? 0,
+			fontId: numAttr(obj, "fontId") ?? 0,
+			fillId: numAttr(obj, "fillId") ?? 0,
+			borderId: numAttr(obj, "borderId") ?? 0
+		};
+		const applyNumberFormat = boolAttr(obj, "applyNumberFormat");
+		const applyFont = boolAttr(obj, "applyFont");
+		const applyFill = boolAttr(obj, "applyFill");
+		const applyBorder = boolAttr(obj, "applyBorder");
+		const applyAlignment = boolAttr(obj, "applyAlignment");
+		if (applyNumberFormat !== void 0) xf.applyNumberFormat = applyNumberFormat;
+		if (applyFont !== void 0) xf.applyFont = applyFont;
+		if (applyFill !== void 0) xf.applyFill = applyFill;
+		if (applyBorder !== void 0) xf.applyBorder = applyBorder;
+		if (applyAlignment !== void 0) xf.applyAlignment = applyAlignment;
+		const align = asObject(obj["alignment"]);
+		if (align) {
+			const a = {};
+			const h = strAttr(align, "horizontal");
+			const v = strAttr(align, "vertical");
+			const wrap = boolAttr(align, "wrapText");
+			if (h) a.horizontal = h;
+			if (v) a.vertical = v;
+			if (wrap !== void 0) a.wrapText = wrap;
+			if (Object.keys(a).length > 0) xf.alignment = a;
+		}
+		out.push(xf);
+	}
+	return out;
+}
+function asObject(v) {
+	if (!v || typeof v !== "object" || Array.isArray(v)) return void 0;
+	return v;
+}
+function asArray(v) {
+	if (v === null || v === void 0) return [];
+	return Array.isArray(v) ? v : [v];
+}
+function strAttr(obj, name) {
+	const v = obj[`@_${name}`];
+	return typeof v === "string" ? v : void 0;
+}
+function numAttr(obj, name) {
+	const v = strAttr(obj, name);
+	if (v === void 0) return void 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : void 0;
+}
+function boolAttr(obj, name) {
+	const v = strAttr(obj, name);
+	if (v === void 0) return void 0;
+	return v === "1" || v === "true";
+}
+function childValAttr(obj, childName) {
+	const child = asObject(obj[childName]);
+	if (!child) return void 0;
+	return strAttr(child, "val");
+}
+function hasChild(obj, childName) {
+	return childName in obj;
+}
+function childToggle(obj, childName) {
+	const child = obj[childName];
+	if (child === "" || child === null || child === void 0) return true;
+	if (typeof child !== "object") return true;
+	const val = strAttr(child, "val");
+	if (val === void 0) return true;
+	return !(val === "false" || val === "0");
+}
+function colorOf(node) {
+	if (!node) return void 0;
+	const rgb = strAttr(node, "rgb");
+	if (rgb) {
+		if (/^[0-9A-Fa-f]{8}$/.test(rgb)) return rgb.substring(2).toUpperCase();
+		if (/^[0-9A-Fa-f]{6}$/.test(rgb)) return rgb.toUpperCase();
+	}
+}
+//#endregion
+export { EMPTY_XLSX_STYLES, parseXlsxStyles };

package/dist/esm/ooxml/spreadsheet/workbook-parser.d.ts

@@ -0,0 +1,16 @@
+export interface SheetReference {
+    readonly name: string;
+    readonly sheetId: string;
+    readonly relationshipId: string;
+}
+export interface DefinedName {
+    readonly name: string;
+    readonly localSheetId?: number;
+    readonly value: string;
+}
+export interface ParsedWorkbook {
+    readonly sheets: ReadonlyArray<SheetReference>;
+    readonly date1904: boolean;
+    readonly definedNames: ReadonlyArray<DefinedName>;
+}
+export declare function parseWorkbook(data: Uint8Array): ParsedWorkbook;

package/dist/esm/ooxml/spreadsheet/workbook-parser.js

@@ -0,0 +1,90 @@
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/spreadsheet/workbook-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false,
+	removeNSPrefix: true
+});
+function parseWorkbook(data) {
+	const xml = decoder.decode(data);
+	const workbook = parser.parse(xml)["workbook"];
+	if (!workbook || typeof workbook !== "object") return {
+		sheets: [],
+		date1904: false,
+		definedNames: []
+	};
+	const wbObj = workbook;
+	const date1904 = parseDate1904(wbObj);
+	const definedNames = parseDefinedNames(wbObj);
+	const sheets = wbObj["sheets"];
+	if (!sheets || typeof sheets !== "object") return {
+		sheets: [],
+		date1904,
+		definedNames
+	};
+	const sheetRaw = sheets["sheet"];
+	const items = Array.isArray(sheetRaw) ? sheetRaw : sheetRaw !== void 0 ? [sheetRaw] : [];
+	const out = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const name = strAttr(obj, "name");
+		const sheetId = strAttr(obj, "sheetId");
+		const rId = strAttr(obj, "r:id") ?? strAttr(obj, "id");
+		if (!name || !rId) continue;
+		out.push({
+			name,
+			sheetId: sheetId ?? "",
+			relationshipId: rId
+		});
+	}
+	return {
+		sheets: out,
+		date1904,
+		definedNames
+	};
+}
+function parseDefinedNames(wbObj) {
+	const node = wbObj["definedNames"];
+	if (!node || typeof node !== "object") return [];
+	const raw = node["definedName"];
+	const items = Array.isArray(raw) ? raw : raw !== void 0 ? [raw] : [];
+	const out = [];
+	for (const item of items) {
+		if (!item || typeof item !== "object") continue;
+		const obj = item;
+		const name = strAttr(obj, "name");
+		if (!name) continue;
+		const value = textOf(obj["#text"]);
+		const localRaw = strAttr(obj, "localSheetId");
+		const localSheetId = localRaw !== void 0 ? Number(localRaw) : void 0;
+		out.push({
+			name,
+			value,
+			...localSheetId !== void 0 && Number.isInteger(localSheetId) ? { localSheetId } : {}
+		});
+	}
+	return out;
+}
+function textOf(node) {
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	return "";
+}
+function parseDate1904(wbObj) {
+	const pr = wbObj["workbookPr"];
+	if (!pr || typeof pr !== "object") return false;
+	const raw = strAttr(pr, "date1904");
+	return raw === "1" || raw === "true";
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+export { parseWorkbook };

package/dist/esm/ooxml/spreadsheet/worksheet-parser.d.ts

@@ -0,0 +1,60 @@
+export type CellType = 'n' | 's' | 'str' | 'b' | 'd' | 'e' | 'inlineStr';
+export interface WorksheetCell {
+    readonly column: number;
+    readonly row: number;
+    readonly type: CellType;
+    readonly rawValue: string;
+    readonly inlineText?: string;
+    readonly styleIndex?: number;
+}
+export interface ColumnWidth {
+    readonly min: number;
+    readonly max: number;
+    readonly widthChars: number;
+}
+export interface MergedRange {
+    readonly startColumn: number;
+    readonly startRow: number;
+    readonly endColumn: number;
+    readonly endRow: number;
+}
+export interface RowHeight {
+    readonly row: number;
+    readonly heightPt: number;
+    readonly customHeight: boolean;
+}
+export interface XlsxPageMargins {
+    readonly leftInches: number;
+    readonly rightInches: number;
+    readonly topInches: number;
+    readonly bottomInches: number;
+    readonly headerInches?: number;
+    readonly footerInches?: number;
+}
+export interface XlsxPageSetup {
+    readonly paperSize?: number;
+    readonly orientation?: 'portrait' | 'landscape' | 'default';
+    readonly scale?: number;
+    readonly fitToWidth?: number;
+    readonly fitToHeight?: number;
+}
+export interface XlsxPrintOptions {
+    readonly gridLines?: boolean;
+    readonly horizontalCentered?: boolean;
+    readonly verticalCentered?: boolean;
+}
+export interface ParsedWorksheet {
+    readonly cells: ReadonlyArray<WorksheetCell>;
+    readonly maxRow: number;
+    readonly maxColumn: number;
+    readonly columns: ReadonlyArray<ColumnWidth>;
+    readonly merges: ReadonlyArray<MergedRange>;
+    readonly rowHeights: ReadonlyArray<RowHeight>;
+    readonly pageMargins?: XlsxPageMargins;
+    readonly pageSetup?: XlsxPageSetup;
+    readonly fitToPage?: boolean;
+    readonly printOptions?: XlsxPrintOptions;
+    readonly rowBreaks?: ReadonlyArray<number>;
+    readonly colBreaks?: ReadonlyArray<number>;
+}
+export declare function parseWorksheet(data: Uint8Array): ParsedWorksheet;

package/dist/esm/ooxml/spreadsheet/worksheet-parser.js

@@ -0,0 +1,311 @@
+import { parseCellRef } from "./cell-reference.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/spreadsheet/worksheet-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false,
+	removeNSPrefix: true
+});
+function parseWorksheet(data) {
+	const xml = decoder.decode(data);
+	const worksheet = parser.parse(xml)["worksheet"];
+	const emptyExtras = () => ({
+		columns: [],
+		merges: [],
+		rowHeights: []
+	});
+	if (!worksheet || typeof worksheet !== "object") return {
+		cells: [],
+		maxRow: -1,
+		maxColumn: -1,
+		...emptyExtras()
+	};
+	const wsObj = worksheet;
+	const pageMargins = parsePageMargins(wsObj);
+	const pageSetup = parsePageSetup(wsObj);
+	const fitToPage = parseFitToPage(wsObj);
+	const printOptions = parsePrintOptions(wsObj);
+	const rowBreaks = parseBreaks(wsObj, "rowBreaks");
+	const colBreaks = parseBreaks(wsObj, "colBreaks");
+	const printModel = {
+		...pageMargins ? { pageMargins } : {},
+		...pageSetup ? { pageSetup } : {},
+		...fitToPage ? { fitToPage } : {},
+		...printOptions ? { printOptions } : {},
+		...rowBreaks.length > 0 ? { rowBreaks } : {},
+		...colBreaks.length > 0 ? { colBreaks } : {}
+	};
+	const sheetData = wsObj["sheetData"];
+	if (!sheetData || typeof sheetData !== "object") return {
+		cells: [],
+		maxRow: -1,
+		maxColumn: -1,
+		columns: parseColumns(wsObj),
+		merges: parseMerges(wsObj),
+		rowHeights: [],
+		...printModel
+	};
+	const rowRaw = sheetData["row"];
+	const rows = Array.isArray(rowRaw) ? rowRaw : rowRaw !== void 0 ? [rowRaw] : [];
+	const cells = [];
+	const rowHeights = [];
+	let maxRow = -1;
+	let maxColumn = -1;
+	let currentRow = -1;
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		const obj = row;
+		const explicitRow = parseRowIndex(obj);
+		currentRow = explicitRow !== void 0 ? explicitRow : currentRow + 1;
+		const height = parseRowHeight(obj, currentRow);
+		if (height) rowHeights.push(height);
+		const cellRaw = obj["c"];
+		const rowCells = Array.isArray(cellRaw) ? cellRaw : cellRaw !== void 0 ? [cellRaw] : [];
+		let prevCol = -1;
+		for (const c of rowCells) {
+			const parsed = parseCell(c, currentRow, prevCol + 1);
+			if (!parsed) continue;
+			prevCol = parsed.column;
+			cells.push(parsed);
+			if (parsed.row > maxRow) maxRow = parsed.row;
+			if (parsed.column > maxColumn) maxColumn = parsed.column;
+		}
+	}
+	return {
+		cells,
+		maxRow,
+		maxColumn,
+		columns: parseColumns(wsObj),
+		merges: parseMerges(wsObj),
+		rowHeights,
+		...printModel
+	};
+}
+function parseRowIndex(obj) {
+	const raw = strAttr(obj, "r");
+	if (!raw) return void 0;
+	const n = Number(raw);
+	return Number.isInteger(n) && n > 0 ? n - 1 : void 0;
+}
+function parseRowHeight(obj, rowIndex) {
+	if (rowIndex === void 0) return void 0;
+	const htRaw = strAttr(obj, "ht");
+	if (htRaw === void 0) return void 0;
+	const heightPt = Number(htRaw);
+	if (!Number.isFinite(heightPt)) return void 0;
+	const customRaw = strAttr(obj, "customHeight");
+	return {
+		row: rowIndex,
+		heightPt,
+		customHeight: customRaw === "1" || customRaw === "true"
+	};
+}
+function parsePageMargins(ws) {
+	const node = ws["pageMargins"];
+	if (!node || typeof node !== "object") return void 0;
+	const obj = node;
+	const left = parseNumericAttr(obj, "left");
+	const right = parseNumericAttr(obj, "right");
+	const top = parseNumericAttr(obj, "top");
+	const bottom = parseNumericAttr(obj, "bottom");
+	if (left === void 0 || right === void 0 || top === void 0 || bottom === void 0) return;
+	const header = parseNumericAttr(obj, "header");
+	const footer = parseNumericAttr(obj, "footer");
+	return {
+		leftInches: left,
+		rightInches: right,
+		topInches: top,
+		bottomInches: bottom,
+		...header !== void 0 ? { headerInches: header } : {},
+		...footer !== void 0 ? { footerInches: footer } : {}
+	};
+}
+function parsePageSetup(ws) {
+	const node = ws["pageSetup"];
+	if (!node || typeof node !== "object") return void 0;
+	const obj = node;
+	const paperSize = parseNumericAttr(obj, "paperSize");
+	const orientationRaw = strAttr(obj, "orientation");
+	const orientation = orientationRaw === "portrait" || orientationRaw === "landscape" || orientationRaw === "default" ? orientationRaw : void 0;
+	const scale = parseNumericAttr(obj, "scale");
+	const fitToWidth = parseNumericAttr(obj, "fitToWidth");
+	const fitToHeight = parseNumericAttr(obj, "fitToHeight");
+	if (paperSize === void 0 && orientation === void 0 && scale === void 0 && fitToWidth === void 0 && fitToHeight === void 0) return;
+	return {
+		...paperSize !== void 0 ? { paperSize: Math.round(paperSize) } : {},
+		...orientation !== void 0 ? { orientation } : {},
+		...scale !== void 0 ? { scale } : {},
+		...fitToWidth !== void 0 ? { fitToWidth: Math.round(fitToWidth) } : {},
+		...fitToHeight !== void 0 ? { fitToHeight: Math.round(fitToHeight) } : {}
+	};
+}
+function parseFitToPage(ws) {
+	const sheetPr = ws["sheetPr"];
+	if (!sheetPr || typeof sheetPr !== "object") return false;
+	const pr = sheetPr["pageSetUpPr"];
+	if (!pr || typeof pr !== "object") return false;
+	const raw = strAttr(pr, "fitToPage");
+	return raw === "1" || raw === "true";
+}
+function parsePrintOptions(ws) {
+	const node = ws["printOptions"];
+	if (!node || typeof node !== "object") return void 0;
+	const obj = node;
+	const flag = (key) => {
+		const raw = strAttr(obj, key);
+		if (raw === void 0) return void 0;
+		return raw === "1" || raw === "true";
+	};
+	const gridLines = flag("gridLines");
+	const horizontalCentered = flag("horizontalCentered");
+	const verticalCentered = flag("verticalCentered");
+	if (gridLines === void 0 && horizontalCentered === void 0 && verticalCentered === void 0) return;
+	return {
+		...gridLines !== void 0 ? { gridLines } : {},
+		...horizontalCentered !== void 0 ? { horizontalCentered } : {},
+		...verticalCentered !== void 0 ? { verticalCentered } : {}
+	};
+}
+function parseBreaks(ws, tag) {
+	const node = ws[tag];
+	if (!node || typeof node !== "object") return [];
+	const brkRaw = node["brk"];
+	const items = Array.isArray(brkRaw) ? brkRaw : brkRaw !== void 0 ? [brkRaw] : [];
+	const out = [];
+	for (const b of items) {
+		if (!b || typeof b !== "object") continue;
+		const id = parseNumericAttr(b, "id");
+		if (id !== void 0 && Number.isInteger(id) && id >= 0) out.push(id);
+	}
+	return out;
+}
+function parseNumericAttr(obj, key) {
+	const raw = strAttr(obj, key);
+	if (raw === void 0) return void 0;
+	const n = Number(raw);
+	return Number.isFinite(n) ? n : void 0;
+}
+function parseColumns(ws) {
+	const colsNode = ws["cols"];
+	if (!colsNode || typeof colsNode !== "object") return [];
+	const colRaw = colsNode["col"];
+	const items = Array.isArray(colRaw) ? colRaw : colRaw !== void 0 ? [colRaw] : [];
+	const out = [];
+	for (const c of items) {
+		if (!c || typeof c !== "object") continue;
+		const obj = c;
+		const min = Number(strAttr(obj, "min"));
+		const max = Number(strAttr(obj, "max"));
+		const width = Number(strAttr(obj, "width"));
+		if (Number.isFinite(min) && Number.isFinite(max) && Number.isFinite(width)) out.push({
+			min,
+			max,
+			widthChars: width
+		});
+	}
+	return out;
+}
+function parseMerges(ws) {
+	const mergeNode = ws["mergeCells"];
+	if (!mergeNode || typeof mergeNode !== "object") return [];
+	const mergeRaw = mergeNode["mergeCell"];
+	const items = Array.isArray(mergeRaw) ? mergeRaw : mergeRaw !== void 0 ? [mergeRaw] : [];
+	const out = [];
+	for (const m of items) {
+		if (!m || typeof m !== "object") continue;
+		const ref = strAttr(m, "ref");
+		if (!ref) continue;
+		const colonIdx = ref.indexOf(":");
+		if (colonIdx < 0) continue;
+		try {
+			const start = parseCellRef(ref.substring(0, colonIdx));
+			const end = parseCellRef(ref.substring(colonIdx + 1));
+			const range = {
+				startColumn: Math.min(start.column, end.column),
+				startRow: Math.min(start.row, end.row),
+				endColumn: Math.max(start.column, end.column),
+				endRow: Math.max(start.row, end.row)
+			};
+			out.push(range);
+		} catch {}
+	}
+	return out;
+}
+function parseCell(c, fallbackRow, fallbackCol) {
+	if (!c || typeof c !== "object") return null;
+	const obj = c;
+	const ref = strAttr(obj, "r");
+	let address;
+	if (ref) try {
+		address = parseCellRef(ref);
+	} catch {
+		return null;
+	}
+	else address = {
+		column: fallbackCol,
+		row: fallbackRow
+	};
+	const type = validateCellType(strAttr(obj, "t") ?? "n");
+	const styleStr = strAttr(obj, "s");
+	const styleIndex = styleStr !== void 0 ? Number(styleStr) : void 0;
+	const v = obj["v"];
+	const rawValue = textOf(v);
+	const base = {
+		column: address.column,
+		row: address.row,
+		type
+	};
+	if (type === "inlineStr") {
+		const is = obj["is"];
+		const inlineText = inlineStringText(is);
+		return {
+			...base,
+			rawValue: "",
+			inlineText,
+			...Number.isFinite(styleIndex) ? { styleIndex } : {}
+		};
+	}
+	return {
+		...base,
+		rawValue,
+		...Number.isFinite(styleIndex) ? { styleIndex } : {}
+	};
+}
+function validateCellType(t) {
+	if (t === "n" || t === "s" || t === "str" || t === "b" || t === "d" || t === "e" || t === "inlineStr") return t;
+	return "n";
+}
+function strAttr(obj, key) {
+	const v = obj[`@_${key}`];
+	return typeof v === "string" ? v : void 0;
+}
+function textOf(node) {
+	if (typeof node === "string") return node;
+	if (typeof node === "number") return String(node);
+	if (!node || typeof node !== "object") return "";
+	const inner = node["#text"];
+	if (typeof inner === "string") return inner;
+	if (typeof inner === "number") return String(inner);
+	return "";
+}
+var MAX_CELL_CHARS = 32767;
+function inlineStringText(is) {
+	if (!is || typeof is !== "object") return "";
+	const obj = is;
+	const t = obj["t"];
+	const direct = textOf(t);
+	if (direct) return direct.length > MAX_CELL_CHARS ? direct.slice(0, MAX_CELL_CHARS) : direct;
+	const r = obj["r"];
+	if (Array.isArray(r)) {
+		const joined = r.map((rr) => textOf(rr?.["t"])).join("");
+		return joined.length > MAX_CELL_CHARS ? joined.slice(0, MAX_CELL_CHARS) : joined;
+	}
+	return "";
+}
+//#endregion
+export { parseWorksheet };