reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/math/omml-parser.js

@@ -0,0 +1,217 @@
+import { poChildren, poChildrenWith, poIs, poTag, poText, poToggle, poVal } from "../wordproc/po-helpers.js";
+//#region src/ooxml/math/omml-parser.ts
+function parseOMath(oMath) {
+	return {
+		type: "row",
+		children: parseMathSeq(poChildren(oMath))
+	};
+}
+function parseMathSeq(children) {
+	const out = [];
+	for (const child of children) {
+		const node = parseMathNode(child);
+		if (node) out.push(node);
+	}
+	return out;
+}
+function parseMathNode(node) {
+	switch (poTag(node)) {
+		case "m:r": return parseMathRun(node);
+		case "m:f": return parseFraction(node);
+		case "m:sSup": return parseScript(node, false, true);
+		case "m:sSub": return parseScript(node, true, false);
+		case "m:sSubSup": return parseScript(node, true, true);
+		case "m:sPre": return {
+			type: "script",
+			base: childRow(node, "m:e"),
+			sub: childRow(node, "m:sub"),
+			sup: childRow(node, "m:sup"),
+			pre: true
+		};
+		case "m:rad": return parseRadical(node);
+		case "m:nary": return parseNary(node);
+		case "m:func": return {
+			type: "func",
+			name: childRow(node, "m:fName"),
+			body: childRow(node, "m:e")
+		};
+		case "m:limLow": return {
+			type: "limit",
+			base: childRow(node, "m:e"),
+			lim: childRow(node, "m:lim"),
+			pos: "low"
+		};
+		case "m:limUpp": return {
+			type: "limit",
+			base: childRow(node, "m:e"),
+			lim: childRow(node, "m:lim"),
+			pos: "upp"
+		};
+		case "m:d": return parseDelimiter(node);
+		case "m:m": return parseMatrix(node);
+		case "m:eqArr": return parseEqArray(node);
+		case "m:acc": return parseAccent(node);
+		case "m:bar": return parseBar(node);
+		case "m:groupChr": return parseGroupChr(node);
+		case "m:rPr":
+		case "m:fPr":
+		case "m:ctrlPr": return null;
+		default: {
+			const kids = parseMathSeq(poChildren(node));
+			return kids.length > 0 ? {
+				type: "row",
+				children: kids
+			} : null;
+		}
+	}
+}
+function childRow(parent, tag) {
+	const el = poChildren(parent).find((c) => poIs(c, tag));
+	return {
+		type: "row",
+		children: el ? parseMathSeq(poChildren(el)) : []
+	};
+}
+function parseMathRun(r) {
+	let text = "";
+	for (const c of poChildren(r)) if (poIs(c, "m:t")) text += poText(c);
+	const rPr = poChildren(r).find((c) => poIs(c, "m:rPr"));
+	let italic = false;
+	let bold = false;
+	let nor = false;
+	if (rPr) {
+		const sty = poVal(poChildren(rPr).find((c) => poIs(c, "m:sty")));
+		if (sty === "i") italic = true;
+		else if (sty === "b") bold = true;
+		else if (sty === "bi") {
+			italic = true;
+			bold = true;
+		} else if (sty === "p") nor = true;
+		if (poChildren(rPr).some((c) => poIs(c, "m:nor"))) nor = true;
+	}
+	return {
+		type: "run",
+		text,
+		...italic ? { italic: true } : {},
+		...bold ? { bold: true } : {},
+		...nor ? { nor: true } : {}
+	};
+}
+function parseFraction(f) {
+	const num = childRow(f, "m:num");
+	const den = childRow(f, "m:den");
+	const fPr = poChildren(f).find((c) => poIs(c, "m:fPr"));
+	return {
+		type: "fraction",
+		num,
+		den,
+		...(fPr ? poVal(poChildren(fPr).find((c) => poIs(c, "m:type"))) : void 0) === "noBar" ? { barless: true } : {}
+	};
+}
+function parseScript(node, hasSub, hasSup) {
+	return {
+		type: "script",
+		base: childRow(node, "m:e"),
+		...hasSub ? { sub: childRow(node, "m:sub") } : {},
+		...hasSup ? { sup: childRow(node, "m:sup") } : {}
+	};
+}
+function parseNary(node) {
+	const naryPr = poChildren(node).find((c) => poIs(c, "m:naryPr"));
+	let op = "∫";
+	let limLoc;
+	const hidden = (tag) => {
+		if (!naryPr) return false;
+		const el = poChildren(naryPr).find((c) => poIs(c, tag));
+		return el !== void 0 && poToggle(el) !== false;
+	};
+	if (naryPr) {
+		const chr = poVal(poChildren(naryPr).find((c) => poIs(c, "m:chr")));
+		if (chr) op = chr;
+		const ll = poVal(poChildren(naryPr).find((c) => poIs(c, "m:limLoc")));
+		if (ll === "undOvr" || ll === "subSup") limLoc = ll;
+	}
+	return {
+		type: "nary",
+		op,
+		body: childRow(node, "m:e"),
+		...hidden("m:subHide") ? {} : { sub: childRow(node, "m:sub") },
+		...hidden("m:supHide") ? {} : { sup: childRow(node, "m:sup") },
+		...limLoc ? { limLoc } : {}
+	};
+}
+function parseDelimiter(node) {
+	const dPr = poChildren(node).find((c) => poIs(c, "m:dPr"));
+	const chrVal = (tag) => dPr ? poVal(poChildren(dPr).find((c) => poIs(c, tag))) : void 0;
+	const beg = chrVal("m:begChr");
+	const end = chrVal("m:endChr");
+	const sep = chrVal("m:sepChr");
+	const children = poChildrenWith(node, "m:e").map((e) => ({
+		type: "row",
+		children: parseMathSeq(poChildren(e))
+	}));
+	return {
+		type: "delimiter",
+		begChr: beg ?? "(",
+		endChr: end ?? ")",
+		children,
+		...sep !== void 0 ? { sepChr: sep } : {}
+	};
+}
+function parseMatrix(node) {
+	return {
+		type: "matrix",
+		rows: poChildrenWith(node, "m:mr").map((mr) => poChildrenWith(mr, "m:e").map((e) => ({
+			type: "row",
+			children: parseMathSeq(poChildren(e))
+		})))
+	};
+}
+function parseEqArray(node) {
+	return {
+		type: "eqArr",
+		rows: poChildrenWith(node, "m:e").map((e) => ({
+			type: "row",
+			children: parseMathSeq(poChildren(e))
+		}))
+	};
+}
+function parseAccent(node) {
+	const accPr = poChildren(node).find((c) => poIs(c, "m:accPr"));
+	return {
+		type: "accent",
+		char: (accPr ? poVal(poChildren(accPr).find((c) => poIs(c, "m:chr"))) : void 0) ?? "̂",
+		base: childRow(node, "m:e")
+	};
+}
+function parseBar(node) {
+	const barPr = poChildren(node).find((c) => poIs(c, "m:barPr"));
+	const pos = barPr ? poVal(poChildren(barPr).find((c) => poIs(c, "m:pos"))) : void 0;
+	return {
+		type: "bar",
+		base: childRow(node, "m:e"),
+		pos: pos === "bot" ? "bot" : "top"
+	};
+}
+function parseGroupChr(node) {
+	const gPr = poChildren(node).find((c) => poIs(c, "m:groupChrPr"));
+	const chr = gPr ? poVal(poChildren(gPr).find((c) => poIs(c, "m:chr"))) : void 0;
+	const pos = gPr ? poVal(poChildren(gPr).find((c) => poIs(c, "m:pos"))) : void 0;
+	return {
+		type: "groupChr",
+		char: chr ?? "⏟",
+		base: childRow(node, "m:e"),
+		pos: pos === "top" ? "top" : "bot"
+	};
+}
+function parseRadical(node) {
+	const degEl = poChildren(node).find((c) => poIs(c, "m:deg"));
+	const hasDeg = degEl !== void 0 && parseMathSeq(poChildren(degEl)).length > 0;
+	return {
+		type: "radical",
+		radicand: childRow(node, "m:e"),
+		...hasDeg ? { degree: childRow(node, "m:deg") } : {}
+	};
+}
+//#endregion
+export { parseOMath };

package/dist/esm/ooxml/spreadsheet/cell-reference.d.ts

@@ -0,0 +1,6 @@
+export interface CellAddress {
+    readonly column: number;
+    readonly row: number;
+}
+export declare function parseCellRef(ref: string): CellAddress;
+export declare function formatCellRef(address: CellAddress): string;

package/dist/esm/ooxml/spreadsheet/cell-reference.js

@@ -0,0 +1,26 @@
+//#region src/ooxml/spreadsheet/cell-reference.ts
+var A = 65;
+var Z = 90;
+var a = 97;
+var z = 122;
+function parseCellRef(ref) {
+	let i = 0;
+	let column = 0;
+	while (i < ref.length) {
+		const code = ref.charCodeAt(i);
+		if (code >= A && code <= Z) column = column * 26 + (code - A + 1);
+		else if (code >= a && code <= z) column = column * 26 + (code - a + 1);
+		else break;
+		i++;
+	}
+	if (column === 0) throw new Error(`Invalid cell reference: ${ref}`);
+	const rowPart = ref.substring(i);
+	const row = Number(rowPart);
+	if (!Number.isInteger(row) || row < 1) throw new Error(`Invalid cell reference: ${ref}`);
+	return {
+		column: column - 1,
+		row: row - 1
+	};
+}
+//#endregion
+export { parseCellRef };

package/dist/esm/ooxml/spreadsheet/defined-name-ref.d.ts

@@ -0,0 +1,11 @@
+export interface CellRange {
+    readonly startColumn: number;
+    readonly startRow: number;
+    readonly endColumn: number;
+    readonly endRow: number;
+}
+export declare function parseTitleRowRange(value: string): {
+    readonly startRow: number;
+    readonly endRow: number;
+} | undefined;
+export declare function parseAreaRef(value: string): CellRange | undefined;

package/dist/esm/ooxml/spreadsheet/defined-name-ref.js

@@ -0,0 +1,64 @@
+import { parseCellRef } from "./cell-reference.js";
+//#region src/ooxml/spreadsheet/defined-name-ref.ts
+function stripQualifier(token) {
+	const bang = token.lastIndexOf("!");
+	return (bang >= 0 ? token.substring(bang + 1) : token).replace(/\$/g, "").trim();
+}
+function parseSingleArea(token) {
+	const ref = stripQualifier(token);
+	if (ref.length === 0) return void 0;
+	const colon = ref.indexOf(":");
+	try {
+		if (colon < 0) {
+			const a = parseCellRef(ref);
+			return {
+				startColumn: a.column,
+				startRow: a.row,
+				endColumn: a.column,
+				endRow: a.row
+			};
+		}
+		const a = parseCellRef(ref.substring(0, colon));
+		const b = parseCellRef(ref.substring(colon + 1));
+		return {
+			startColumn: Math.min(a.column, b.column),
+			startRow: Math.min(a.row, b.row),
+			endColumn: Math.max(a.column, b.column),
+			endRow: Math.max(a.row, b.row)
+		};
+	} catch {
+		return;
+	}
+}
+function parseTitleRowRange(value) {
+	if (!value) return void 0;
+	for (const token of value.split(",")) {
+		const ref = stripQualifier(token);
+		const m = /^(\d+)(?::(\d+))?$/.exec(ref);
+		if (!m) continue;
+		const a = Number(m[1]);
+		const b = m[2] !== void 0 ? Number(m[2]) : a;
+		if (!Number.isInteger(a) || a < 1 || !Number.isInteger(b) || b < 1) continue;
+		return {
+			startRow: Math.min(a, b) - 1,
+			endRow: Math.max(a, b) - 1
+		};
+	}
+}
+function parseAreaRef(value) {
+	if (!value) return void 0;
+	let box;
+	for (const token of value.split(",")) {
+		const area = parseSingleArea(token);
+		if (!area) continue;
+		box = box ? {
+			startColumn: Math.min(box.startColumn, area.startColumn),
+			startRow: Math.min(box.startRow, area.startRow),
+			endColumn: Math.max(box.endColumn, area.endColumn),
+			endRow: Math.max(box.endRow, area.endRow)
+		} : area;
+	}
+	return box;
+}
+//#endregion
+export { parseAreaRef, parseTitleRowRange };

package/dist/esm/ooxml/spreadsheet/index.d.ts

@@ -0,0 +1,12 @@
+export { parseCellRef, formatCellRef } from './cell-reference.js';
+export type { CellAddress } from './cell-reference.js';
+export { parseAreaRef, parseTitleRowRange } from './defined-name-ref.js';
+export type { CellRange } from './defined-name-ref.js';
+export { parseSharedStrings } from './shared-strings-parser.js';
+export { parseWorkbook } from './workbook-parser.js';
+export type { DefinedName, ParsedWorkbook, SheetReference, } from './workbook-parser.js';
+export { parseWorksheet } from './worksheet-parser.js';
+export type { CellType, ColumnWidth, MergedRange, ParsedWorksheet, RowHeight, WorksheetCell, XlsxPageMargins, XlsxPageSetup, XlsxPrintOptions, } from './worksheet-parser.js';
+export { parseXlsxStyles, EMPTY_XLSX_STYLES } from './styles-parser.js';
+export type { XlsxBorder, XlsxBorderEdge, XlsxBorderStyleName, XlsxCellAlignment, XlsxCellXf, XlsxFill, XlsxFont, XlsxHorizontalAlign, XlsxStyles, XlsxVerticalAlign, } from './styles-parser.js';
+export { applyNumberFormat } from './number-format.js';

package/dist/esm/ooxml/spreadsheet/index.js

@@ -0,0 +1,7 @@
+import "./cell-reference.js";
+import "./defined-name-ref.js";
+import "./shared-strings-parser.js";
+import "./workbook-parser.js";
+import "./worksheet-parser.js";
+import "./styles-parser.js";
+import "./number-format.js";

package/dist/esm/ooxml/spreadsheet/number-format.d.ts

@@ -0,0 +1 @@
+export declare function applyNumberFormat(rawValue: string, numFmtId: number, customFormats: ReadonlyMap<number, string>, date1904?: boolean): string;