reamkit 0.1.0-alpha.0

package/dist/esm/ooxml/wordproc/font-table.js

@@ -0,0 +1,82 @@
+import { FontRegistry } from "../../font/font-registry.js";
+//#region src/ooxml/wordproc/font-table.ts
+var FONT_TABLE_PART = "word/fontTable.xml";
+var REL_FONT = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font";
+var VARIANT_BY_TAG = {
+	Regular: "regular",
+	Bold: "bold",
+	Italic: "italic",
+	BoldItalic: "boldItalic"
+};
+function deobfuscateEmbeddedFont(data, fontKey) {
+	const hex = fontKey.replace(/[{}-]/g, "");
+	if (hex.length !== 32) return data;
+	const key = new Uint8Array(16);
+	for (let i = 0; i < 16; i++) key[i] = parseInt(hex.substring(i * 2, i * 2 + 2), 16);
+	key.reverse();
+	const out = new Uint8Array(data);
+	const n = Math.min(32, out.length);
+	for (let i = 0; i < n; i++) out[i] = out[i] ^ key[i % 16];
+	return out;
+}
+function parseFontTable(data) {
+	const xml = new TextDecoder("utf-8").decode(data);
+	const out = [];
+	const fontRe = /<w:font\b[^>]*\bw:name="([^"]+)"[^>]*>([\s\S]*?)<\/w:font>/g;
+	let fm;
+	while ((fm = fontRe.exec(xml)) !== null) {
+		const name = fm[1];
+		const inner = fm[2];
+		const embeds = {};
+		const embedRe = /<w:embed(Regular|Bold|Italic|BoldItalic)\b[^>]*\br:id="([^"]+)"[^>]*\bw:fontKey="([^"]+)"/g;
+		let em;
+		while ((em = embedRe.exec(inner)) !== null) {
+			const variant = VARIANT_BY_TAG[em[1]];
+			if (variant) embeds[variant] = {
+				rId: em[2],
+				fontKey: em[3]
+			};
+		}
+		if (Object.keys(embeds).length > 0) out.push({
+			name,
+			embeds
+		});
+	}
+	return out;
+}
+function loadEmbeddedFonts(pkg) {
+	const out = /* @__PURE__ */ new Map();
+	const ftData = pkg.getPart(FONT_TABLE_PART);
+	if (!ftData) return out;
+	const relById = new Map(pkg.getPartRelationships(FONT_TABLE_PART).map((r) => [r.id, r]));
+	for (const entry of parseFontTable(ftData)) {
+		const bytes = {};
+		for (const variant of [
+			"regular",
+			"bold",
+			"italic",
+			"boldItalic"
+		]) {
+			const ref = entry.embeds[variant];
+			if (!ref) continue;
+			const rel = relById.get(ref.rId);
+			if (!rel || rel.type !== REL_FONT) continue;
+			const resolved = pkg.resolveRelatedPart(FONT_TABLE_PART, rel);
+			if (!resolved) continue;
+			try {
+				const ttf = deobfuscateEmbeddedFont(resolved.data, ref.fontKey);
+				const sig = (ttf[0] << 24 | ttf[1] << 16 | ttf[2] << 8 | ttf[3]) >>> 0;
+				if (sig === 65536 || sig === 1330926671 || sig === 1953658213 || sig === 1953784678) bytes[variant] = ttf;
+			} catch {}
+		}
+		if (bytes.regular) try {
+			out.set(entry.name.trim().toLowerCase(), FontRegistry.fromBytes({
+				...bytes,
+				regular: bytes.regular
+			}));
+		} catch {}
+	}
+	return out;
+}
+//#endregion
+export { deobfuscateEmbeddedFont, loadEmbeddedFonts, parseFontTable };

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

@@ -0,0 +1,10 @@
+export { extractParagraphs } from './text-extractor.js';
+export { parseDocument, parseBodyElements, parseSection, parseSections, parseHeaderFooter, EMPTY_SECTION, } from './document-parser.js';
+export { parseRunProperties } from './run-properties.js';
+export { parseParagraphProperties } from './paragraph-properties.js';
+export { parseStyles, EMPTY_STYLE_SHEET } from './styles-parser.js';
+export { parseTable } from './table-parser.js';
+export { loadEmbeddedFonts, deobfuscateEmbeddedFont, parseFontTable, } from './font-table.js';
+export { parseNumbering, EMPTY_NUMBERING } from './numbering-parser.js';
+export { parseSettings, EMPTY_SETTINGS } from './settings-parser.js';
+export type { DocumentSettings } from './settings-parser.js';

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

@@ -0,0 +1,9 @@
+import "./run-properties.js";
+import "./paragraph-properties.js";
+import "./table-parser.js";
+import "./document-parser.js";
+import "./text-extractor.js";
+import "./styles-parser.js";
+import "./font-table.js";
+import "./numbering-parser.js";
+import "./settings-parser.js";

package/dist/esm/ooxml/wordproc/numbering-parser.d.ts

@@ -0,0 +1,3 @@
+import { Numbering } from '../../document-model/index.js';
+export declare const EMPTY_NUMBERING: Numbering;
+export declare function parseNumbering(data: Uint8Array): Numbering;

package/dist/esm/ooxml/wordproc/numbering-parser.js

@@ -0,0 +1,89 @@
+import { asArray, asElement, getAttr } from "./xml-helpers.js";
+import { parseRunProperties } from "./run-properties.js";
+import { parseParagraphProperties } from "./paragraph-properties.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/wordproc/numbering-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var FORMATS = new Set([
+	"decimal",
+	"lowerLetter",
+	"upperLetter",
+	"lowerRoman",
+	"upperRoman",
+	"bullet",
+	"none"
+]);
+var EMPTY_NUMBERING = {
+	abstractNums: /* @__PURE__ */ new Map(),
+	numInstances: /* @__PURE__ */ new Map()
+};
+function parseNumbering(data) {
+	const xml = decoder.decode(data);
+	const root = asElement(parser.parse(xml)["w:numbering"]);
+	if (!root) return EMPTY_NUMBERING;
+	const abstractNums = /* @__PURE__ */ new Map();
+	for (const a of asArray(root["w:abstractNum"])) {
+		const el = asElement(a);
+		if (!el) continue;
+		const id = getAttr(el, "abstractNumId");
+		if (!id) continue;
+		const levels = /* @__PURE__ */ new Map();
+		for (const lvlNode of asArray(el["w:lvl"])) {
+			const lvlEl = asElement(lvlNode);
+			if (!lvlEl) continue;
+			const ilvlStr = getAttr(lvlEl, "ilvl");
+			if (!ilvlStr) continue;
+			const ilvl = Number(ilvlStr);
+			if (!Number.isFinite(ilvl)) continue;
+			const startAttr = getValVal(lvlEl["w:start"]);
+			const start = startAttr !== void 0 ? Number(startAttr) : 1;
+			const fmtStr = getValVal(lvlEl["w:numFmt"]) ?? "decimal";
+			const format = FORMATS.has(fmtStr) ? fmtStr : "decimal";
+			const lvlText = getValVal(lvlEl["w:lvlText"]) ?? "";
+			levels.set(ilvl, {
+				ilvl,
+				start: Number.isFinite(start) ? start : 1,
+				format,
+				lvlText,
+				paragraphProperties: parseParagraphProperties(lvlEl["w:pPr"]),
+				runProperties: parseRunProperties(lvlEl["w:rPr"])
+			});
+		}
+		abstractNums.set(id, {
+			id,
+			levels
+		});
+	}
+	const numInstances = /* @__PURE__ */ new Map();
+	for (const n of asArray(root["w:num"])) {
+		const el = asElement(n);
+		if (!el) continue;
+		const numId = getAttr(el, "numId");
+		if (!numId) continue;
+		const abstractNumId = getValVal(el["w:abstractNumId"]);
+		if (!abstractNumId) continue;
+		numInstances.set(numId, {
+			numId,
+			abstractNumId
+		});
+	}
+	return {
+		abstractNums,
+		numInstances
+	};
+}
+function getValVal(node) {
+	if (!node || typeof node !== "object") return void 0;
+	const v = node["@_w:val"] ?? node["@_val"];
+	return typeof v === "string" ? v : void 0;
+}
+//#endregion
+export { EMPTY_NUMBERING, parseNumbering };

package/dist/esm/ooxml/wordproc/paragraph-properties.d.ts

@@ -0,0 +1,2 @@
+import { ParagraphProperties } from '../../document-model/index.js';
+export declare function parseParagraphProperties(pPr: unknown): ParagraphProperties;

package/dist/esm/ooxml/wordproc/paragraph-properties.js

@@ -0,0 +1,85 @@
+import { asElement, getAttr, getVal, parseIntAttr, parseToggle } from "./xml-helpers.js";
+import { parseRunProperties } from "./run-properties.js";
+//#region src/ooxml/wordproc/paragraph-properties.ts
+var ALIGNMENTS = new Set([
+	"left",
+	"right",
+	"center",
+	"both",
+	"distribute"
+]);
+var LINE_RULES = new Set([
+	"auto",
+	"exact",
+	"atLeast"
+]);
+function parseParagraphProperties(pPr) {
+	const el = asElement(pPr);
+	if (!el) return {};
+	const out = {};
+	if ("w:pStyle" in el) {
+		const v = getVal(el["w:pStyle"]);
+		if (v) out.styleId = v;
+	}
+	if ("w:jc" in el) {
+		const v = getVal(el["w:jc"]);
+		if (v && ALIGNMENTS.has(v)) out.alignment = v;
+	}
+	if ("w:spacing" in el) {
+		const node = el["w:spacing"];
+		const before = parseIntAttr(node, "before");
+		const after = parseIntAttr(node, "after");
+		const line = parseIntAttr(node, "line");
+		const lineRule = getAttr(node, "lineRule");
+		if (before !== void 0) out.spacingBeforeTwips = before;
+		if (after !== void 0) out.spacingAfterTwips = after;
+		if (line !== void 0) out.spacingLineTwips = line;
+		if (lineRule && LINE_RULES.has(lineRule)) out.spacingLineRule = lineRule;
+	}
+	if ("w:ind" in el) {
+		const node = el["w:ind"];
+		const left = parseIntAttr(node, "left");
+		const right = parseIntAttr(node, "right");
+		const firstLine = parseIntAttr(node, "firstLine");
+		const hanging = parseIntAttr(node, "hanging");
+		if (left !== void 0) out.indentLeftTwips = left;
+		if (right !== void 0) out.indentRightTwips = right;
+		if (firstLine !== void 0) out.indentFirstLineTwips = firstLine;
+		else if (hanging !== void 0) out.indentFirstLineTwips = -hanging;
+	}
+	if ("w:pageBreakBefore" in el) {
+		const v = parseToggle(el["w:pageBreakBefore"]);
+		if (v !== void 0) out.pageBreakBefore = v;
+	}
+	if ("w:bidi" in el) {
+		const v = parseToggle(el["w:bidi"]);
+		if (v !== void 0) out.bidi = v;
+	}
+	if ("w:outlineLvl" in el) {
+		const v = parseIntAttr(el["w:outlineLvl"], "val");
+		if (v !== void 0) out.outlineLevel = v;
+	}
+	if ("w:numPr" in el) {
+		const numPr = asElement(el["w:numPr"]);
+		if (numPr) {
+			const numIdVal = numPr["w:numId"];
+			const ilvlVal = numPr["w:ilvl"];
+			const numIdAttr = typeof numIdVal === "object" && numIdVal !== null ? getAttr(numIdVal, "val") : void 0;
+			const ilvlAttr = typeof ilvlVal === "object" && ilvlVal !== null ? getAttr(ilvlVal, "val") : void 0;
+			if (numIdAttr !== void 0) {
+				const ilvlNum = ilvlAttr !== void 0 ? Number(ilvlAttr) : 0;
+				out.numbering = {
+					numId: numIdAttr,
+					ilvl: Number.isFinite(ilvlNum) ? ilvlNum : 0
+				};
+			}
+		}
+	}
+	if ("w:rPr" in el) {
+		const rPr = parseRunProperties(el["w:rPr"]);
+		if (Object.keys(rPr).length > 0) out.runProperties = rPr;
+	}
+	return out;
+}
+//#endregion
+export { parseParagraphProperties };

package/dist/esm/ooxml/wordproc/po-helpers.d.ts

@@ -0,0 +1,14 @@
+export type PoNode = Record<string, unknown>;
+export type PoTree = ReadonlyArray<PoNode>;
+export declare function poTag(node: PoNode | undefined): string | undefined;
+export declare function poIs(node: PoNode | undefined, tag: string): boolean;
+export declare function poChildren(node: PoNode | undefined): ReadonlyArray<PoNode>;
+export declare function poChildrenWith(node: PoNode | undefined, tag: string): Array<PoNode>;
+export declare function poFirstChild(node: PoNode | undefined, tag: string): PoNode | undefined;
+export declare function poAttr(node: PoNode | undefined, name: string): string | undefined;
+export declare function poIntAttr(node: PoNode | undefined, name: string): number | undefined;
+export declare function poVal(node: PoNode | undefined): string | undefined;
+export declare function poToggle(node: PoNode | undefined): boolean | undefined;
+export declare function poText(node: PoNode | undefined): string;
+export declare function poFindByPath(tree: PoTree, path: ReadonlyArray<string>): PoNode | undefined;
+export declare function poFindDescendant(node: PoNode | undefined, tag: string): PoNode | undefined;

package/dist/esm/ooxml/wordproc/po-helpers.js

@@ -0,0 +1,76 @@
+//#region src/ooxml/wordproc/po-helpers.ts
+var ATTRS_KEY = ":@";
+var TEXT_KEY = "#text";
+function poTag(node) {
+	if (!node || typeof node !== "object") return void 0;
+	for (const key of Object.keys(node)) if (key !== ATTRS_KEY && key !== TEXT_KEY) return key;
+}
+function poIs(node, tag) {
+	return poTag(node) === tag;
+}
+function poChildren(node) {
+	const tag = poTag(node);
+	if (!tag || !node) return [];
+	const arr = node[tag];
+	return Array.isArray(arr) ? arr : [];
+}
+function poChildrenWith(node, tag) {
+	return poChildren(node).filter((c) => poIs(c, tag));
+}
+function poFirstChild(node, tag) {
+	return poChildren(node).find((c) => poIs(c, tag));
+}
+function poAttr(node, name) {
+	if (!node || typeof node !== "object") return void 0;
+	const attrs = node[ATTRS_KEY];
+	if (!attrs || typeof attrs !== "object") return void 0;
+	const a = attrs;
+	const v = a[`@_w:${name}`] ?? a[`@_r:${name}`] ?? a[`@_m:${name}`] ?? a[`@_xml:${name}`] ?? a[`@_${name}`];
+	return typeof v === "string" ? v : void 0;
+}
+function poIntAttr(node, name) {
+	const v = poAttr(node, name);
+	if (v === void 0) return void 0;
+	const n = Number(v);
+	return Number.isFinite(n) ? n : void 0;
+}
+function poVal(node) {
+	return poAttr(node, "val");
+}
+function poToggle(node) {
+	if (!node) return void 0;
+	const v = poAttr(node, "val");
+	if (v === void 0) return true;
+	return !(v === "false" || v === "0" || v === "off");
+}
+function poText(node) {
+	if (!node) return "";
+	const children = poChildren(node);
+	let out = "";
+	for (const c of children) if (c && typeof c === "object" && TEXT_KEY in c) {
+		const t = c[TEXT_KEY];
+		if (typeof t === "string") out += t;
+		else if (typeof t === "number") out += String(t);
+	}
+	return out;
+}
+function poFindByPath(tree, path) {
+	let cursor = tree;
+	let current;
+	for (const seg of path) {
+		current = cursor.find((n) => poIs(n, seg));
+		if (!current) return void 0;
+		cursor = poChildren(current);
+	}
+	return current;
+}
+function poFindDescendant(node, tag) {
+	if (!node) return void 0;
+	for (const child of poChildren(node)) {
+		if (poIs(child, tag)) return child;
+		const found = poFindDescendant(child, tag);
+		if (found) return found;
+	}
+}
+//#endregion
+export { poAttr, poChildren, poChildrenWith, poFindByPath, poFindDescendant, poFirstChild, poIntAttr, poIs, poTag, poText, poToggle, poVal };

package/dist/esm/ooxml/wordproc/po-to-flat.d.ts

@@ -0,0 +1,2 @@
+import { PoNode } from './po-helpers.js';
+export declare function poElementToFlat(node: PoNode | undefined): Record<string, unknown>;

package/dist/esm/ooxml/wordproc/po-to-flat.js

@@ -0,0 +1,28 @@
+import { poChildren, poTag } from "./po-helpers.js";
+//#region src/ooxml/wordproc/po-to-flat.ts
+var ATTRS_KEY = ":@";
+var TEXT_KEY = "#text";
+function poElementToFlat(node) {
+	const out = {};
+	if (!node) return out;
+	const attrs = node[ATTRS_KEY];
+	if (attrs && typeof attrs === "object") for (const [k, v] of Object.entries(attrs)) out[k] = v;
+	for (const child of poChildren(node)) {
+		if (TEXT_KEY in child) {
+			const t = child[TEXT_KEY];
+			const str = typeof t === "string" ? t : typeof t === "number" ? String(t) : "";
+			out[TEXT_KEY] = out[TEXT_KEY] === void 0 ? str : `${out[TEXT_KEY]}${str}`;
+			continue;
+		}
+		const childTag = poTag(child);
+		if (!childTag) continue;
+		const childFlat = poElementToFlat(child);
+		const existing = out[childTag];
+		if (existing === void 0) out[childTag] = childFlat;
+		else if (Array.isArray(existing)) existing.push(childFlat);
+		else out[childTag] = [existing, childFlat];
+	}
+	return out;
+}
+//#endregion
+export { poElementToFlat };

package/dist/esm/ooxml/wordproc/run-properties.d.ts

@@ -0,0 +1,2 @@
+import { RunProperties } from '../../document-model/index.js';
+export declare function parseRunProperties(rPr: unknown): RunProperties;

package/dist/esm/ooxml/wordproc/run-properties.js

@@ -0,0 +1,82 @@
+import { asElement, getAttr, getVal, parseIntAttr, parseToggle } from "./xml-helpers.js";
+//#region src/ooxml/wordproc/run-properties.ts
+var UNDERLINE_STYLES = new Set([
+	"none",
+	"single",
+	"double",
+	"thick",
+	"dotted",
+	"dottedHeavy",
+	"dash",
+	"dashHeavy",
+	"wave"
+]);
+var VERTICAL_ALIGNS = new Set([
+	"baseline",
+	"superscript",
+	"subscript"
+]);
+function parseRunProperties(rPr) {
+	const el = asElement(rPr);
+	if (!el) return {};
+	const out = {};
+	if ("w:rStyle" in el) {
+		const v = getVal(el["w:rStyle"]);
+		if (v) out.styleId = v;
+	}
+	if ("w:b" in el) {
+		const v = parseToggle(el["w:b"]);
+		if (v !== void 0) out.bold = v;
+	}
+	if ("w:i" in el) {
+		const v = parseToggle(el["w:i"]);
+		if (v !== void 0) out.italic = v;
+	}
+	if ("w:strike" in el) {
+		const v = parseToggle(el["w:strike"]);
+		if (v !== void 0) out.strike = v;
+	}
+	if ("w:u" in el) {
+		const v = getVal(el["w:u"]);
+		if (v && UNDERLINE_STYLES.has(v)) out.underline = v;
+	}
+	if ("w:sz" in el) {
+		const v = parseIntAttr(el["w:sz"], "val");
+		if (v !== void 0) out.fontSizeHalfPoints = v;
+	}
+	if ("w:color" in el) {
+		const v = getVal(el["w:color"]);
+		if (v && /^[0-9A-Fa-f]{6}$/.test(v)) out.colorHex = v.toUpperCase();
+	}
+	if ("w:rFonts" in el) {
+		const ff = parseFontFamily(el["w:rFonts"]);
+		if (ff) out.fontFamily = ff;
+	}
+	if ("w:vertAlign" in el) {
+		const v = getVal(el["w:vertAlign"]);
+		if (v && VERTICAL_ALIGNS.has(v)) out.verticalAlign = v;
+	}
+	if ("w:rtl" in el) {
+		const v = parseToggle(el["w:rtl"]);
+		if (v !== void 0) out.rtl = v;
+	}
+	if ("w:lang" in el) {
+		const v = getAttr(el["w:lang"], "val");
+		if (v) out.lang = v;
+	}
+	return out;
+}
+function parseFontFamily(node) {
+	const ff = {};
+	const ascii = getAttr(node, "ascii");
+	const hAnsi = getAttr(node, "hAnsi");
+	const cs = getAttr(node, "cs");
+	const eastAsia = getAttr(node, "eastAsia");
+	if (ascii) ff.ascii = ascii;
+	if (hAnsi) ff.hAnsi = hAnsi;
+	if (cs) ff.cs = cs;
+	if (eastAsia) ff.eastAsia = eastAsia;
+	return Object.keys(ff).length > 0 ? ff : void 0;
+}
+//#endregion
+export { parseRunProperties };

package/dist/esm/ooxml/wordproc/settings-parser.d.ts

@@ -0,0 +1,5 @@
+export interface DocumentSettings {
+    readonly evenAndOddHeaders: boolean;
+}
+export declare const EMPTY_SETTINGS: DocumentSettings;
+export declare function parseSettings(data: Uint8Array): DocumentSettings;

package/dist/esm/ooxml/wordproc/settings-parser.js

@@ -0,0 +1,26 @@
+import { poAttr, poChildren, poFindByPath, poIs } from "./po-helpers.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/wordproc/settings-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	preserveOrder: true,
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var EMPTY_SETTINGS = { evenAndOddHeaders: false };
+function parseSettings(data) {
+	const xml = decoder.decode(data);
+	const settings = poFindByPath(parser.parse(xml), ["w:settings"]);
+	if (!settings) return EMPTY_SETTINGS;
+	let evenAndOddHeaders = false;
+	for (const child of poChildren(settings)) if (poIs(child, "w:evenAndOddHeaders")) {
+		const val = poAttr(child, "val");
+		evenAndOddHeaders = val === void 0 || val === "" || val !== "0" && val !== "false";
+	}
+	return { evenAndOddHeaders };
+}
+//#endregion
+export { EMPTY_SETTINGS, parseSettings };

package/dist/esm/ooxml/wordproc/styles-parser.d.ts

@@ -0,0 +1,3 @@
+import { StyleSheet } from '../../document-model/index.js';
+export declare const EMPTY_STYLE_SHEET: StyleSheet;
+export declare function parseStyles(stylesXml: Uint8Array): StyleSheet;

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

@@ -0,0 +1,67 @@
+import { asArray, asElement, getAttr, getVal } from "./xml-helpers.js";
+import { parseRunProperties } from "./run-properties.js";
+import { parseParagraphProperties } from "./paragraph-properties.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/wordproc/styles-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	textNodeName: "#text",
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var STYLE_TYPES = new Set([
+	"paragraph",
+	"character",
+	"table",
+	"numbering"
+]);
+var EMPTY_STYLE_SHEET = {
+	defaultRunProperties: {},
+	defaultParagraphProperties: {},
+	styles: /* @__PURE__ */ new Map()
+};
+function parseStyles(stylesXml) {
+	const xml = decoder.decode(stylesXml);
+	const root = asElement(parser.parse(xml)["w:styles"]);
+	if (!root) return EMPTY_STYLE_SHEET;
+	const docDefaults = asElement(root["w:docDefaults"]);
+	let defaultRunProperties = {};
+	let defaultParagraphProperties = {};
+	if (docDefaults) {
+		const rPrDef = asElement(docDefaults["w:rPrDefault"]);
+		if (rPrDef) defaultRunProperties = parseRunProperties(rPrDef["w:rPr"]);
+		const pPrDef = asElement(docDefaults["w:pPrDefault"]);
+		if (pPrDef) defaultParagraphProperties = parseParagraphProperties(pPrDef["w:pPr"]);
+	}
+	const styles = /* @__PURE__ */ new Map();
+	for (const s of asArray(root["w:style"])) {
+		const el = asElement(s);
+		if (!el) continue;
+		const id = getAttr(el, "styleId");
+		const typeAttr = getAttr(el, "type");
+		if (!id || !typeAttr) continue;
+		if (!STYLE_TYPES.has(typeAttr)) continue;
+		const type = typeAttr;
+		const basedOnVal = getVal(el["w:basedOn"]);
+		const isDefault = getAttr(el, "default") === "1";
+		const style = {
+			id,
+			type,
+			...basedOnVal ? { basedOn: basedOnVal } : {},
+			isDefault,
+			runProperties: parseRunProperties(el["w:rPr"]),
+			paragraphProperties: parseParagraphProperties(el["w:pPr"])
+		};
+		styles.set(id, style);
+	}
+	return {
+		defaultRunProperties,
+		defaultParagraphProperties,
+		styles
+	};
+}
+//#endregion
+export { EMPTY_STYLE_SHEET, parseStyles };

package/dist/esm/ooxml/wordproc/table-parser.d.ts

@@ -0,0 +1,3 @@
+import { Table } from '../../document-model/index.js';
+import { PoNode } from './po-helpers.js';
+export declare function parseTable(tbl: PoNode): Table;