reamkit 0.1.0-alpha.0

package/dist/esm/line-breaker/knuth-plass.js

@@ -0,0 +1,172 @@
+//#region src/line-breaker/knuth-plass.ts
+var FORCED_BREAK = -1e4;
+var FORBIDDEN_BREAK = 1e4;
+var LINE_PENALTY = 10;
+var FITNESS_PENALTY = 100;
+var FLAGGED_PENALTY = 100;
+var TOLERANCE_RATIO = 4;
+var MAX_ACTIVE_NODES = 200;
+var FIT_VERY_TIGHT = 0;
+var FIT_TIGHT = 1;
+var FIT_LOOSE = 2;
+var FIT_VERY_LOOSE = 3;
+function fitnessClass(r) {
+	if (r < -.5) return FIT_VERY_TIGHT;
+	if (r <= .5) return FIT_TIGHT;
+	if (r <= 1) return FIT_LOOSE;
+	return FIT_VERY_LOOSE;
+}
+/**
+* Break a paragraph into lines using the Knuth-Plass total-fit algorithm.
+*
+* `lineWidths`: either a number (uniform width) or an array indexed by line
+* (0-based). When the array is shorter than the paragraph the last entry is
+* reused for trailing lines — this matches the common case of "first line
+* different, rest the same".
+*/
+function breakLines(items, lineWidths) {
+	if (items.length === 0) return {
+		breaks: [],
+		ratios: []
+	};
+	const widthFor = (line) => {
+		if (typeof lineWidths === "number") return lineWidths;
+		if (line < lineWidths.length) return lineWidths[line];
+		return lineWidths[lineWidths.length - 1];
+	};
+	const startNode = {
+		itemIndex: -1,
+		line: 0,
+		fitness: FIT_TIGHT,
+		totalWidth: 0,
+		totalStretch: 0,
+		totalShrink: 0,
+		totalDemerits: 0,
+		previous: null
+	};
+	let active = [startNode];
+	const isFeasibleBreakpoint = (i) => {
+		const item = items[i];
+		if (item.type === "penalty" && item.penalty < FORBIDDEN_BREAK) return true;
+		if (item.type === "glue") {
+			const prev = items[i - 1];
+			return !!prev && prev.type === "box";
+		}
+		return false;
+	};
+	const widthBeforeItem = new Array(items.length + 1);
+	const stretchBeforeItem = new Array(items.length + 1);
+	const shrinkBeforeItem = new Array(items.length + 1);
+	widthBeforeItem[0] = 0;
+	stretchBeforeItem[0] = 0;
+	shrinkBeforeItem[0] = 0;
+	for (let i = 0; i < items.length; i++) {
+		const it = items[i];
+		const addW = it.type === "penalty" ? 0 : it.width;
+		const addSt = it.type === "glue" ? it.stretch : 0;
+		const addSh = it.type === "glue" ? it.shrink : 0;
+		widthBeforeItem[i + 1] = widthBeforeItem[i] + addW;
+		stretchBeforeItem[i + 1] = stretchBeforeItem[i] + addSt;
+		shrinkBeforeItem[i + 1] = shrinkBeforeItem[i] + addSh;
+	}
+	const measureLine = (a, b) => {
+		const startIdx = a.itemIndex + 1;
+		let width = widthBeforeItem[b] - widthBeforeItem[startIdx];
+		const stretch = stretchBeforeItem[b] - stretchBeforeItem[startIdx];
+		const shrink = shrinkBeforeItem[b] - shrinkBeforeItem[startIdx];
+		const item = items[b];
+		if (item.type === "penalty") width += item.width;
+		return {
+			width,
+			stretch,
+			shrink
+		};
+	};
+	const computeRatio = (line, target) => {
+		if (line.width < target) return line.stretch > 0 ? (target - line.width) / line.stretch : Infinity;
+		if (line.width > target) return line.shrink > 0 ? (target - line.width) / line.shrink : -Infinity;
+		return 0;
+	};
+	const lineDemerits = (r, penaltyAtBreak, lastItemPenalty) => {
+		const badness = 100 * Math.pow(Math.abs(r), 3);
+		let d;
+		if (penaltyAtBreak >= 0 && penaltyAtBreak < FORBIDDEN_BREAK) d = Math.pow(LINE_PENALTY + badness + penaltyAtBreak, 2);
+		else if (penaltyAtBreak > FORCED_BREAK && penaltyAtBreak < 0) d = Math.pow(LINE_PENALTY + badness, 2) - penaltyAtBreak * penaltyAtBreak;
+		else d = Math.pow(LINE_PENALTY + badness, 2);
+		return d;
+	};
+	for (let i = 0; i < items.length; i++) {
+		if (!isFeasibleBreakpoint(i)) continue;
+		const item = items[i];
+		const penaltyAtBreak = item.type === "penalty" ? item.penalty : 0;
+		const survivingActive = [];
+		const candidates = /* @__PURE__ */ new Map();
+		for (const a of active) {
+			const target = widthFor(a.line);
+			const r = computeRatio(measureLine(a, i), target);
+			const isForced = penaltyAtBreak <= FORCED_BREAK;
+			if (r < -1 && !isForced) continue;
+			if (!isForced) survivingActive.push(a);
+			const effectiveR = r < -1 ? -1 : isForced && r > TOLERANCE_RATIO ? TOLERANCE_RATIO : r;
+			const fc = fitnessClass(effectiveR);
+			let demerits = lineDemerits(effectiveR, penaltyAtBreak, null);
+			if (Math.abs(fc - a.fitness) > 1) demerits += FITNESS_PENALTY;
+			if (item.type === "penalty" && item.flagged) {
+				const prevItem = a.itemIndex >= 0 ? items[a.itemIndex] : null;
+				if (prevItem && prevItem.type === "penalty" && prevItem.flagged) demerits += FLAGGED_PENALTY;
+			}
+			demerits += a.totalDemerits;
+			const key = `${a.line + 1}:${fc}`;
+			const existing = candidates.get(key);
+			if (!existing || demerits < existing.totalDemerits) candidates.set(key, {
+				itemIndex: i,
+				line: a.line + 1,
+				fitness: fc,
+				totalWidth: widthBeforeItem[i + 1],
+				totalStretch: stretchBeforeItem[i + 1],
+				totalShrink: shrinkBeforeItem[i + 1],
+				totalDemerits: demerits,
+				previous: a
+			});
+		}
+		active = survivingActive;
+		for (const c of candidates.values()) active.push(c);
+		if (active.length === 0) active = [{
+			itemIndex: i,
+			line: 1,
+			fitness: FIT_TIGHT,
+			totalWidth: widthBeforeItem[i + 1],
+			totalStretch: stretchBeforeItem[i + 1],
+			totalShrink: shrinkBeforeItem[i + 1],
+			totalDemerits: 0,
+			previous: startNode
+		}];
+		else if (active.length > MAX_ACTIVE_NODES) {
+			active.sort((p, q) => p.totalDemerits - q.totalDemerits);
+			active.length = MAX_ACTIVE_NODES;
+		}
+	}
+	let best = null;
+	for (const a of active) if (!best || a.totalDemerits < best.totalDemerits) best = a;
+	if (!best) return {
+		breaks: [],
+		ratios: []
+	};
+	const breaks = [];
+	const ratios = [];
+	let node = best;
+	while (node.previous) {
+		breaks.unshift(node.itemIndex);
+		const prev = node.previous;
+		const target = widthFor(prev.line);
+		const r = computeRatio(measureLine(prev, node.itemIndex), target);
+		ratios.unshift(r < -1 ? -1 : r);
+		node = prev;
+	}
+	return {
+		breaks,
+		ratios
+	};
+}
+//#endregion
+export { breakLines };

package/dist/esm/numbering/index.d.ts

@@ -0,0 +1 @@
+export { NumberingState, formatLevelMarker } from './state.js';

package/dist/esm/numbering/state.d.ts

@@ -0,0 +1,6 @@
+import { AbstractNumbering, Numbering, NumberingLevel, NumberingReference } from '../document-model/index.js';
+export declare class NumberingState {
+    private readonly counters;
+    resolveMarker(numbering: Numbering, ref: NumberingReference): string | null;
+}
+export declare function formatLevelMarker(abstractNum: AbstractNumbering, currentLevel: NumberingLevel, counters: ReadonlyArray<number>): string;

package/dist/esm/numbering/state.js

@@ -0,0 +1,83 @@
+//#region src/numbering/state.ts
+var NumberingState = class {
+	counters = /* @__PURE__ */ new Map();
+	resolveMarker(numbering, ref) {
+		const instance = numbering.numInstances.get(ref.numId);
+		if (!instance) return null;
+		const abstractNum = numbering.abstractNums.get(instance.abstractNumId);
+		if (!abstractNum) return null;
+		const level = abstractNum.levels.get(ref.ilvl);
+		if (!level) return null;
+		let arr = this.counters.get(ref.numId);
+		if (!arr) {
+			arr = new Array(9).fill(0);
+			this.counters.set(ref.numId, arr);
+		}
+		for (let k = ref.ilvl + 1; k < arr.length; k++) arr[k] = 0;
+		if (arr[ref.ilvl] === 0) arr[ref.ilvl] = level.start;
+		else arr[ref.ilvl] += 1;
+		return formatLevelMarker(abstractNum, level, arr);
+	}
+};
+function formatLevelMarker(abstractNum, currentLevel, counters) {
+	if (currentLevel.format === "bullet") return normalizeBullet(currentLevel.lvlText);
+	return currentLevel.lvlText.replace(/%(\d)/g, (_match, n) => {
+		const lvlIdx = Number(n) - 1;
+		const level = abstractNum.levels.get(lvlIdx);
+		const counter = counters[lvlIdx] ?? 0;
+		return formatCounter(level?.format ?? "decimal", counter);
+	});
+}
+function formatCounter(format, n) {
+	if (n <= 0) return "";
+	switch (format) {
+		case "decimal": return String(n);
+		case "lowerLetter": return toLetters(n).toLowerCase();
+		case "upperLetter": return toLetters(n);
+		case "lowerRoman": return toRoman(n).toLowerCase();
+		case "upperRoman": return toRoman(n);
+		default: return "";
+	}
+}
+function toLetters(n) {
+	let s = "";
+	let v = n;
+	while (v > 0) {
+		v--;
+		s = String.fromCharCode(65 + v % 26) + s;
+		v = Math.floor(v / 26);
+	}
+	return s;
+}
+function toRoman(n) {
+	const map = [
+		[1e3, "M"],
+		[900, "CM"],
+		[500, "D"],
+		[400, "CD"],
+		[100, "C"],
+		[90, "XC"],
+		[50, "L"],
+		[40, "XL"],
+		[10, "X"],
+		[9, "IX"],
+		[5, "V"],
+		[4, "IV"],
+		[1, "I"]
+	];
+	let s = "";
+	let v = n;
+	for (const [value, ch] of map) while (v >= value) {
+		s += ch;
+		v -= value;
+	}
+	return s;
+}
+function normalizeBullet(lvlText) {
+	if (lvlText.length === 0) return "•";
+	const cp = lvlText.codePointAt(0);
+	if (cp >= 57344 && cp <= 63743) return "•";
+	return lvlText;
+}
+//#endregion
+export { NumberingState };

package/dist/esm/ooxml/drawingml/chart-parser.d.ts

@@ -0,0 +1,3 @@
+import { Chart } from '../../document-model/index.js';
+import { ColorResolver } from './colors.js';
+export declare function parseChart(chartXml: Uint8Array, resolveColor: ColorResolver): Chart | null;

package/dist/esm/ooxml/drawingml/chart-parser.js

@@ -0,0 +1,218 @@
+import { poAttr, poChildren, poFindByPath, poFindDescendant, poIntAttr, poIs, poTag, poText, poVal } from "../wordproc/po-helpers.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/drawingml/chart-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	preserveOrder: true,
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var TYPE_OF_TAG = {
+	"c:barChart": "bar",
+	"c:bar3DChart": "bar",
+	"c:lineChart": "line",
+	"c:line3DChart": "line",
+	"c:pieChart": "pie",
+	"c:pie3DChart": "pie",
+	"c:doughnutChart": "pie",
+	"c:areaChart": "area",
+	"c:area3DChart": "area",
+	"c:scatterChart": "scatter"
+};
+function parseChart(chartXml, resolveColor) {
+	const chart = poFindByPath(parser.parse(decoder.decode(chartXml)), ["c:chartSpace", "c:chart"]);
+	if (!chart) return null;
+	const plotArea = poChildren(chart).find((c) => poIs(c, "c:plotArea"));
+	if (!plotArea) return null;
+	const group = poChildren(plotArea).find((c) => (poTag(c) ?? "") in TYPE_OF_TAG);
+	const type = group ? TYPE_OF_TAG[poTag(group)] ?? "unknown" : "unknown";
+	const serNodes = group ? poChildren(group).filter((c) => poIs(c, "c:ser")) : [];
+	const series = serNodes.map((s) => parseSeries(s, resolveColor));
+	let categories = [];
+	for (const s of serNodes) {
+		const cat = poChildren(s).find((c) => poIs(c, "c:cat"));
+		if (cat) {
+			categories = denseStrings(cat);
+			break;
+		}
+	}
+	const barDir = group ? poVal(poChildren(group).find((c) => poIs(c, "c:barDir"))) : void 0;
+	const grouping = group ? poVal(poChildren(group).find((c) => poIs(c, "c:grouping"))) : void 0;
+	const doughnut = group ? poIs(group, "c:doughnutChart") : false;
+	const showValues = group ? chartShowsValues(group) : false;
+	const catAxisTitle = axisTitle(plotArea, "c:catAx");
+	const valAxisTitle = axisTitle(plotArea, "c:valAx");
+	const legend = poChildren(chart).find((c) => poIs(c, "c:legend"));
+	const legendPos = legend ? poVal(poChildren(legend).find((c) => poIs(c, "c:legendPos"))) : void 0;
+	const title = chartTitle(chart);
+	return {
+		type,
+		...title ? { title } : {},
+		categories,
+		series,
+		hasLegend: legend !== void 0,
+		...isLegendPos(legendPos) ? { legendPos } : {},
+		...barDir === "col" || barDir === "bar" ? { barDir } : {},
+		...isGrouping(grouping) ? { grouping } : {},
+		...doughnut ? { doughnut: true } : {},
+		...showValues ? { showValues: true } : {},
+		...catAxisTitle ? { catAxisTitle } : {},
+		...valAxisTitle ? { valAxisTitle } : {}
+	};
+}
+function parseSeries(ser, resolveColor) {
+	const valNode = poChildren(ser).find((c) => poIs(c, "c:val")) ?? poChildren(ser).find((c) => poIs(c, "c:yVal"));
+	const values = valNode ? denseNumbers(valNode) : [];
+	const xValNode = poChildren(ser).find((c) => poIs(c, "c:xVal"));
+	const xValues = xValNode ? denseNumbers(xValNode) : void 0;
+	const name = seriesName(ser);
+	const colorHex = fillColorOf(poChildren(ser).find((c) => poIs(c, "c:spPr")), resolveColor);
+	const pointColors = dataPointColors(ser, resolveColor);
+	return {
+		values,
+		...xValues && xValues.length > 0 ? { xValues } : {},
+		...name ? { name } : {},
+		...colorHex ? { colorHex } : {},
+		...pointColors.length > 0 ? { pointColors } : {}
+	};
+}
+function seriesName(ser) {
+	const tx = poChildren(ser).find((c) => poIs(c, "c:tx"));
+	if (!tx) return void 0;
+	const direct = poChildren(tx).find((c) => poIs(c, "c:v"));
+	if (direct) return poText(direct) || void 0;
+	return readPts(tx)[0]?.v || void 0;
+}
+function dataPointColors(ser, resolveColor) {
+	const out = [];
+	for (const dPt of poChildren(ser)) {
+		if (!poIs(dPt, "c:dPt")) continue;
+		const idxNode = poChildren(dPt).find((c) => poIs(c, "c:idx"));
+		const idx = idxNode ? poIntAttr(idxNode, "val") ?? 0 : 0;
+		const colorHex = fillColorOf(poChildren(dPt).find((c) => poIs(c, "c:spPr")), resolveColor);
+		if (colorHex) out.push({
+			idx,
+			colorHex
+		});
+	}
+	return out;
+}
+function fillColorOf(spPr, resolveColor) {
+	if (!spPr) return void 0;
+	const directFill = poChildren(spPr).find((c) => poIs(c, "a:solidFill"));
+	const fromFill = directFill ? colorFromSolidFill(directFill, resolveColor) : void 0;
+	if (fromFill) return fromFill;
+	const ln = poChildren(spPr).find((c) => poIs(c, "a:ln"));
+	const lnFill = ln ? poChildren(ln).find((c) => poIs(c, "a:solidFill")) : void 0;
+	return lnFill ? colorFromSolidFill(lnFill, resolveColor) : void 0;
+}
+function colorMods(colorNode) {
+	const mods = [];
+	for (const c of poChildren(colorNode)) for (const kind of [
+		"lumMod",
+		"lumOff",
+		"shade",
+		"tint",
+		"alpha"
+	]) if (poIs(c, `a:${kind}`)) {
+		const v = poIntAttr(c, "val");
+		if (v !== void 0) mods.push({
+			kind,
+			val: v / 1e5
+		});
+	}
+	return mods;
+}
+function colorFromSolidFill(solid, resolveColor) {
+	for (const c of poChildren(solid)) {
+		const isSrgb = poIs(c, "a:srgbClr");
+		if (!isSrgb && !poIs(c, "a:schemeClr")) continue;
+		const v = poAttr(c, "val");
+		if (!v) continue;
+		const mods = colorMods(c);
+		const raw = isSrgb ? { srgb: v } : { scheme: v };
+		return resolveColor(mods.length > 0 ? {
+			...raw,
+			mods
+		} : raw);
+	}
+}
+function collectAT(node) {
+	let text = "";
+	const walk = (n) => {
+		for (const c of poChildren(n)) if (poIs(c, "a:t")) text += poText(c);
+		else walk(c);
+	};
+	walk(node);
+	return text;
+}
+function chartTitle(chart) {
+	const title = poChildren(chart).find((c) => poIs(c, "c:title"));
+	return title ? collectAT(title) || void 0 : void 0;
+}
+function axisTitle(plotArea, axTag) {
+	const ax = poChildren(plotArea).find((c) => poIs(c, axTag));
+	const title = ax ? poChildren(ax).find((c) => poIs(c, "c:title")) : void 0;
+	return title ? collectAT(title) || void 0 : void 0;
+}
+function dLblsShowVal(dLbls) {
+	if (!dLbls) return false;
+	const v = poVal(poChildren(dLbls).find((c) => poIs(c, "c:showVal")));
+	return v === "1" || v === "true";
+}
+function chartShowsValues(group) {
+	if (dLblsShowVal(poChildren(group).find((c) => poIs(c, "c:dLbls")))) return true;
+	for (const ser of poChildren(group)) if (poIs(ser, "c:ser") && dLblsShowVal(poChildren(ser).find((c) => poIs(c, "c:dLbls")))) return true;
+	return false;
+}
+function readPts(container) {
+	const cache = poFindDescendant(container, "c:numCache") ?? poFindDescendant(container, "c:strCache");
+	if (!cache) return [];
+	const out = [];
+	for (const pt of poChildren(cache)) {
+		if (!poIs(pt, "c:pt")) continue;
+		const idx = poIntAttr(pt, "idx") ?? 0;
+		const vNode = poChildren(pt).find((c) => poIs(c, "c:v"));
+		out.push({
+			idx,
+			v: vNode ? poText(vNode) : ""
+		});
+	}
+	return out;
+}
+function ptCountOf(container) {
+	const cache = poFindDescendant(container, "c:numCache") ?? poFindDescendant(container, "c:strCache");
+	const pc = cache ? poChildren(cache).find((c) => poIs(c, "c:ptCount")) : void 0;
+	return pc ? poIntAttr(pc, "val") ?? 0 : 0;
+}
+function denseLength(container, pts) {
+	let max = ptCountOf(container);
+	for (const p of pts) max = Math.max(max, p.idx + 1);
+	return max;
+}
+function denseNumbers(container) {
+	const pts = readPts(container);
+	const arr = new Array(denseLength(container, pts)).fill(0);
+	for (const p of pts) {
+		const n = Number(p.v);
+		if (Number.isFinite(n)) arr[p.idx] = n;
+	}
+	return arr;
+}
+function denseStrings(container) {
+	const pts = readPts(container);
+	const arr = new Array(denseLength(container, pts)).fill("");
+	for (const p of pts) arr[p.idx] = p.v;
+	return arr;
+}
+function isLegendPos(v) {
+	return v === "r" || v === "l" || v === "t" || v === "b";
+}
+function isGrouping(v) {
+	return v === "clustered" || v === "stacked" || v === "percentStacked" || v === "standard";
+}
+//#endregion
+export { parseChart };

package/dist/esm/ooxml/drawingml/colors.d.ts

@@ -0,0 +1,17 @@
+export interface ColorMod {
+    readonly kind: 'lumMod' | 'lumOff' | 'shade' | 'tint' | 'alpha';
+    readonly val: number;
+}
+export type RawColor = {
+    readonly srgb: string;
+    readonly mods?: ReadonlyArray<ColorMod>;
+} | {
+    readonly scheme: string;
+    readonly mods?: ReadonlyArray<ColorMod>;
+};
+export type ColorResolver = (raw: RawColor) => string | undefined;
+export declare function applyColorMods(hex: string, mods: ReadonlyArray<ColorMod>): string;
+export declare const DEFAULT_THEME_PALETTE: ReadonlyMap<string, string>;
+export declare function resolveSchemeName(name: string): string;
+export declare function makeColorResolver(palette: ReadonlyMap<string, string>): ColorResolver;
+export declare const defaultColorResolver: ColorResolver;

package/dist/esm/ooxml/drawingml/colors.js

@@ -0,0 +1,125 @@
+//#region src/ooxml/drawingml/colors.ts
+function clamp01(x) {
+	return x < 0 ? 0 : x > 1 ? 1 : x;
+}
+function rgbToHsl(r, g, b) {
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (max + min) / 2;
+	const d = max - min;
+	if (d === 0) return [
+		0,
+		0,
+		l
+	];
+	const s = d / (1 - Math.abs(2 * l - 1));
+	let h;
+	if (max === r) h = (g - b) / d % 6;
+	else if (max === g) h = (b - r) / d + 2;
+	else h = (r - g) / d + 4;
+	h *= 60;
+	if (h < 0) h += 360;
+	return [
+		h,
+		s,
+		l
+	];
+}
+function hslToRgb(h, s, l) {
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+	const m = l - c / 2;
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (h < 60) [r, g, b] = [
+		c,
+		x,
+		0
+	];
+	else if (h < 120) [r, g, b] = [
+		x,
+		c,
+		0
+	];
+	else if (h < 180) [r, g, b] = [
+		0,
+		c,
+		x
+	];
+	else if (h < 240) [r, g, b] = [
+		0,
+		x,
+		c
+	];
+	else if (h < 300) [r, g, b] = [
+		x,
+		0,
+		c
+	];
+	else [r, g, b] = [
+		c,
+		0,
+		x
+	];
+	return [
+		r + m,
+		g + m,
+		b + m
+	];
+}
+function applyColorMods(hex, mods) {
+	if (mods.length === 0) return hex;
+	const n = parseInt(hex, 16);
+	let r = (n >> 16 & 255) / 255;
+	let g = (n >> 8 & 255) / 255;
+	let b = (n & 255) / 255;
+	for (const m of mods) if (m.kind === "shade") {
+		r *= m.val;
+		g *= m.val;
+		b *= m.val;
+	} else if (m.kind === "tint") {
+		r = r * m.val + (1 - m.val);
+		g = g * m.val + (1 - m.val);
+		b = b * m.val + (1 - m.val);
+	} else if (m.kind === "lumMod" || m.kind === "lumOff") {
+		const [h, s, l] = rgbToHsl(r, g, b);
+		const l2 = m.kind === "lumMod" ? l * m.val : clamp01(l + m.val);
+		[r, g, b] = hslToRgb(h, s, l2);
+	}
+	const toHex = (x) => Math.round(clamp01(x) * 255).toString(16).padStart(2, "0");
+	return (toHex(r) + toHex(g) + toHex(b)).toUpperCase();
+}
+var DEFAULT_THEME_PALETTE = new Map([
+	["dk1", "000000"],
+	["lt1", "FFFFFF"],
+	["dk2", "44546A"],
+	["lt2", "E7E6E6"],
+	["accent1", "4472C4"],
+	["accent2", "ED7D31"],
+	["accent3", "A5A5A5"],
+	["accent4", "FFC000"],
+	["accent5", "5B9BD5"],
+	["accent6", "70AD47"],
+	["hlink", "0563C1"],
+	["folHlink", "954F72"]
+]);
+var SCHEME_ALIAS = {
+	tx1: "dk1",
+	bg1: "lt1",
+	tx2: "dk2",
+	bg2: "lt2"
+};
+function resolveSchemeName(name) {
+	return SCHEME_ALIAS[name] ?? name;
+}
+function makeColorResolver(palette) {
+	return (raw) => {
+		const base = "srgb" in raw ? raw.srgb.toUpperCase() : palette.get(resolveSchemeName(raw.scheme));
+		if (base === void 0) return void 0;
+		return raw.mods && raw.mods.length > 0 ? applyColorMods(base, raw.mods) : base;
+	};
+}
+var defaultColorResolver = makeColorResolver(DEFAULT_THEME_PALETTE);
+//#endregion
+export { DEFAULT_THEME_PALETTE, defaultColorResolver, makeColorResolver };

package/dist/esm/ooxml/drawingml/theme-parser.d.ts

@@ -0,0 +1 @@
+export declare function parseTheme(themeXml: Uint8Array): Map<string, string>;

package/dist/esm/ooxml/drawingml/theme-parser.js

@@ -0,0 +1,55 @@
+import { poAttr, poChildren, poFindByPath, poIs, poTag } from "../wordproc/po-helpers.js";
+import { XMLParser } from "fast-xml-parser";
+//#region src/ooxml/drawingml/theme-parser.ts
+var decoder = new TextDecoder("utf-8");
+var parser = new XMLParser({
+	ignoreAttributes: false,
+	attributeNamePrefix: "@_",
+	preserveOrder: true,
+	parseAttributeValue: false,
+	parseTagValue: false,
+	trimValues: false
+});
+var SCHEME_SLOTS = new Set([
+	"dk1",
+	"lt1",
+	"dk2",
+	"lt2",
+	"accent1",
+	"accent2",
+	"accent3",
+	"accent4",
+	"accent5",
+	"accent6",
+	"hlink",
+	"folHlink"
+]);
+function parseTheme(themeXml) {
+	const out = /* @__PURE__ */ new Map();
+	const clrScheme = poFindByPath(parser.parse(decoder.decode(themeXml)), [
+		"a:theme",
+		"a:themeElements",
+		"a:clrScheme"
+	]);
+	if (!clrScheme) return out;
+	for (const slot of poChildren(clrScheme)) {
+		const tag = poTag(slot);
+		if (!tag || !tag.startsWith("a:")) continue;
+		const name = tag.slice(2);
+		if (!SCHEME_SLOTS.has(name)) continue;
+		const hex = colorOf(slot);
+		if (hex) out.set(name, hex);
+	}
+	return out;
+}
+function colorOf(slot) {
+	for (const c of poChildren(slot)) if (poIs(c, "a:srgbClr")) {
+		const v = poAttr(c, "val");
+		if (v) return v.toUpperCase();
+	} else if (poIs(c, "a:sysClr")) {
+		const v = poAttr(c, "lastClr");
+		if (v) return v.toUpperCase();
+	}
+}
+//#endregion
+export { parseTheme };

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

@@ -0,0 +1 @@
+export * as wordproc from './wordproc/index.js';

package/dist/esm/ooxml/math/omml-parser.d.ts

@@ -0,0 +1,4 @@
+import { MathNode } from '../../document-model/index.js';
+import { PoNode } from '../wordproc/po-helpers.js';
+export declare function parseOMath(oMath: PoNode): MathNode;
+export declare function childRow(parent: PoNode, tag: string): MathNode;