reamkit 1.13.0 → 1.15.0

package/dist/esm/word/doc/doc-text.js

@@ -0,0 +1,706 @@
+import { openCfb } from "../../core/ole/cfb.js";
+//#region src/word/doc/doc-text.ts
+var WIDENT = 42476;
+var OFF_FLAGS1 = 10;
+var OFF_CCPTEXT = 76;
+var OFF_CCPFTN = 80;
+var OFF_CCPHDD = 84;
+var OFF_FCPLCFHDD = 242;
+var OFF_LCBPLCFHDD = 246;
+var OFF_FCPLCFBTECHPX = 250;
+var OFF_LCBPLCFBTECHPX = 254;
+var OFF_FCPLCFBTEPAPX = 258;
+var OFF_LCBPLCFBTEPAPX = 262;
+var OFF_FCCLX = 418;
+var OFF_LCBCLX = 422;
+var OFF_FCPLFLST = 738;
+var OFF_LCBPLFLST = 742;
+var OFF_FCPLFLFO = 746;
+var FLAG_ENCRYPTED = 256;
+var FLAG_WHICH_TBL = 512;
+var FC_COMPRESSED = 1073741824;
+var FC_MASK = 1073741823;
+var FKP_SIZE = 512;
+var PN_MASK = 4194303;
+var CR = 13;
+var SPRM_C_FBOLD = 2101;
+var SPRM_C_FITALIC = 2102;
+var SPRM_C_KUL = 10814;
+var SPRM_C_HPS = 19011;
+var SPRM_C_FSPEC = 2133;
+var SPRM_C_PIC_LOCATION = 27139;
+var PIC_CHAR = 1;
+var SPRM_P_JC = 9219;
+var SPRM_P_DXA_RIGHT = 33806;
+var SPRM_P_DXA_LEFT = 33807;
+var SPRM_P_DXA_LEFT1 = 33809;
+var SPRM_P_DYA_BEFORE = 42003;
+var SPRM_P_DYA_AFTER = 42004;
+var SPRM_P_F_IN_TABLE = 9238;
+var SPRM_P_F_TTP = 9239;
+var SPRM_T_DEF_TABLE = 54792;
+var SPRM_T_DEF_TABLE_SHD = 54802;
+var MAX_ROW_CELLS = 256;
+var SPRM_P_ILVL = 9738;
+var SPRM_P_ILFO = 17931;
+var SPRA_LEN = [
+	1,
+	1,
+	2,
+	4,
+	2,
+	2,
+	0,
+	3
+];
+var SPRM_LONG_OPERAND = new Set([54792, 50701]);
+var CELL_MARK = 7;
+var FIELD_BEGIN = 19;
+var FIELD_SEPARATOR = 20;
+var FIELD_END = 21;
+var MAX_TEXT = 1 << 24;
+var EMPTY = {
+	paragraphs: [],
+	encrypted: false
+};
+function extractDocContent(bytes) {
+	const cfb = openCfb(bytes);
+	const wd = cfb.readStream("WordDocument");
+	if (!wd || wd.length < OFF_LCBCLX + 4) return EMPTY;
+	if (u16(wd, 0) !== WIDENT) return EMPTY;
+	const flags = u16(wd, OFF_FLAGS1);
+	if ((flags & FLAG_ENCRYPTED) !== 0) return {
+		paragraphs: [],
+		encrypted: true
+	};
+	const primary = (flags & FLAG_WHICH_TBL) !== 0 ? "1Table" : "0Table";
+	const table = cfb.readStream(primary) ?? cfb.readStream(primary === "1Table" ? "0Table" : "1Table");
+	if (!table) return EMPTY;
+	const fcClx = u32(wd, OFF_FCCLX);
+	const lcbClx = u32(wd, OFF_LCBCLX);
+	if (lcbClx === 0 || fcClx + lcbClx > table.length) return EMPTY;
+	const plcPcd = findPlcPcd(table.subarray(fcClx, fcClx + lcbClx));
+	if (!plcPcd) return EMPTY;
+	const pieces = parsePieces(plcPcd);
+	const chpx = parsePlcBte(wd, table, OFF_FCPLCFBTECHPX, OFF_LCBPLCFBTECHPX, parseChpxFkp);
+	const papx = parsePlcBte(wd, table, OFF_FCPLCFBTEPAPX, OFF_LCBPLCFBTEPAPX, parsePapxFkp);
+	const ccpText = u32(wd, OFF_CCPTEXT);
+	const data = cfb.readStream("Data");
+	const main = buildParagraphs(wd, pieces, chpx, papx, 0, ccpText, data);
+	const headerFooters = extractHeaderFooters(wd, table, pieces, chpx, papx, data, ccpText);
+	const listTables = parseListTables(wd, table);
+	return {
+		paragraphs: main,
+		...headerFooters ? { headerFooters } : {},
+		...listTables ? { listTables } : {},
+		encrypted: false
+	};
+}
+function parseListTables(wd, table) {
+	const lstFc = u32(wd, OFF_FCPLFLST);
+	const lstLcb = u32(wd, OFF_LCBPLFLST);
+	if (lstLcb === 0 || lstFc + 2 > table.length) return void 0;
+	const lfoLsids = [];
+	const lfoFc = u32(wd, OFF_FCPLFLFO);
+	if (lfoFc + 4 <= table.length) {
+		const lfoMac = u32(table, lfoFc);
+		for (let i = 0; i < lfoMac && lfoFc + 4 + i * 16 + 4 <= table.length; i++) lfoLsids.push(u32(table, lfoFc + 4 + i * 16) | 0);
+	}
+	const cLst = i16(table, lstFc);
+	if (cLst <= 0 || cLst > 65535) return void 0;
+	const lstfs = [];
+	for (let i = 0; i < cLst && lstFc + 2 + i * 28 + 28 <= table.length; i++) {
+		const base = lstFc + 2 + i * 28;
+		lstfs.push({
+			lsid: u32(table, base) | 0,
+			simple: (table[base + 26] & 1) !== 0
+		});
+	}
+	const lists = /* @__PURE__ */ new Map();
+	let p = lstFc + lstLcb;
+	for (const lstf of lstfs) {
+		const levels = [];
+		for (let l = 0; l < (lstf.simple ? 1 : 9); l++) {
+			const lvl = readLvl(table, p);
+			if (!lvl) {
+				p = table.length;
+				break;
+			}
+			levels.push(lvl.info);
+			p = lvl.next;
+		}
+		if (!lists.has(lstf.lsid)) lists.set(lstf.lsid, {
+			simple: lstf.simple,
+			levels
+		});
+	}
+	return lfoLsids.length > 0 || lists.size > 0 ? {
+		lfoLsids,
+		lists
+	} : void 0;
+}
+function readLvl(d, off) {
+	if (off + 28 > d.length) return void 0;
+	const iStartAt = u32(d, off) | 0;
+	const nfc = d[off + 4];
+	const cbChpx = d[off + 24];
+	const cbPapx = d[off + 25];
+	let p = off + 28 + cbPapx + cbChpx;
+	if (p + 2 > d.length) return void 0;
+	const cch = u16(d, p);
+	p += 2;
+	const xst = [];
+	for (let i = 0; i < cch && p + 2 <= d.length; i++) {
+		xst.push(u16(d, p));
+		p += 2;
+	}
+	return {
+		info: {
+			nfc,
+			iStartAt,
+			xst
+		},
+		next: p
+	};
+}
+var ICO_RGB = [
+	"000000",
+	"000000",
+	"0000FF",
+	"00FFFF",
+	"00FF00",
+	"FF00FF",
+	"FF0000",
+	"FFFF00",
+	"FFFFFF",
+	"000080",
+	"008080",
+	"008000",
+	"800080",
+	"800000",
+	"808000",
+	"808080",
+	"C0C0C0"
+];
+function parseTc80(d, off) {
+	const vm = u16(d, off) >> 5 & 3;
+	const top = parseBrc80(d, off + 4);
+	const left = parseBrc80(d, off + 8);
+	const bottom = parseBrc80(d, off + 12);
+	const right = parseBrc80(d, off + 16);
+	const borders = {
+		...top ? { top } : {},
+		...left ? { left } : {},
+		...bottom ? { bottom } : {},
+		...right ? { right } : {}
+	};
+	return {
+		...Object.keys(borders).length > 0 ? { borders } : {},
+		...vm === 3 ? { vMerge: "restart" } : {},
+		...vm === 1 ? { vMerge: "continue" } : {}
+	};
+}
+function parseBrc80(d, off) {
+	if (off + 4 > d.length) return void 0;
+	const width = d[off];
+	const brcType = d[off + 1];
+	if (brcType === 0 || brcType === 255 || width === 0) return void 0;
+	return {
+		widthPt: Math.max(2, width) / 8,
+		colorHex: ICO_RGB[d[off + 2]] ?? "000000",
+		...brcType === 3 ? { double: true } : {}
+	};
+}
+function colorHex(r, g, b) {
+	return [
+		r,
+		g,
+		b
+	].map((c) => c.toString(16).padStart(2, "0")).join("").toUpperCase();
+}
+function extractHeaderFooters(wd, table, pieces, chpx, papx, data, ccpText) {
+	if (u32(wd, OFF_CCPHDD) === 0) return void 0;
+	const fc = u32(wd, OFF_FCPLCFHDD);
+	const lcb = u32(wd, OFF_LCBPLCFHDD);
+	if (lcb < 8 || fc + lcb > table.length) return void 0;
+	const plc = table.subarray(fc, fc + lcb);
+	const n = Math.floor(lcb / 4);
+	const hddStart = ccpText + u32(wd, OFF_CCPFTN);
+	const story = (i) => {
+		if (i + 1 >= n) return void 0;
+		const a = hddStart + u32(plc, i * 4);
+		const b = hddStart + u32(plc, (i + 1) * 4);
+		if (b <= a) return void 0;
+		const paras = buildParagraphs(wd, pieces, chpx, papx, a, b, data);
+		return paras.some((p) => p.runs.some((r) => r.text.length > 0 || r.picture)) ? paras : void 0;
+	};
+	const evenHeader = story(6);
+	const defaultHeader = story(7);
+	const evenFooter = story(8);
+	const defaultFooter = story(9);
+	const firstHeader = story(10);
+	const firstFooter = story(11);
+	const hf = {
+		...defaultHeader ? { defaultHeader } : {},
+		...defaultFooter ? { defaultFooter } : {},
+		...firstHeader ? { firstHeader } : {},
+		...firstFooter ? { firstFooter } : {},
+		...evenHeader ? { evenHeader } : {},
+		...evenFooter ? { evenFooter } : {}
+	};
+	return Object.keys(hf).length > 0 ? hf : void 0;
+}
+function findPlcPcd(clx) {
+	let p = 0;
+	while (p < clx.length) {
+		const clxt = clx[p];
+		if (clxt === 1) {
+			if (p + 3 > clx.length) return void 0;
+			p += 3 + u16(clx, p + 1);
+		} else if (clxt === 2) {
+			if (p + 5 > clx.length) return void 0;
+			const lcb = u32(clx, p + 1);
+			const start = p + 5;
+			if (start + lcb > clx.length) return void 0;
+			return clx.subarray(start, start + lcb);
+		} else return;
+	}
+}
+function parsePieces(plc) {
+	if (plc.length < 12) return [];
+	const n = Math.floor((plc.length - 4) / 12);
+	if (n <= 0) return [];
+	const pcdBase = (n + 1) * 4;
+	const pieces = [];
+	for (let i = 0; i < n; i++) {
+		const fcRaw = u32(plc, pcdBase + i * 8 + 2);
+		const compressed = (fcRaw & FC_COMPRESSED) !== 0;
+		pieces.push({
+			cpStart: u32(plc, i * 4),
+			cpEnd: u32(plc, (i + 1) * 4),
+			fc: compressed ? (fcRaw & FC_MASK) >>> 1 : fcRaw & FC_MASK,
+			compressed
+		});
+	}
+	return pieces;
+}
+function parsePlcBte(wd, table, fcOff, lcbOff, parsePage) {
+	const fcPlc = u32(wd, fcOff);
+	const lcbPlc = u32(wd, lcbOff);
+	if (lcbPlc < 8 || fcPlc + lcbPlc > table.length) return [];
+	const plc = table.subarray(fcPlc, fcPlc + lcbPlc);
+	const n = Math.floor((plc.length - 4) / 8);
+	if (n <= 0) return [];
+	const pnBase = (n + 1) * 4;
+	const out = [];
+	for (let i = 0; i < n; i++) {
+		const pageOff = (u32(plc, pnBase + i * 4) & PN_MASK) * FKP_SIZE;
+		if (pageOff + FKP_SIZE > wd.length) continue;
+		parsePage(wd.subarray(pageOff, pageOff + FKP_SIZE), out);
+	}
+	out.sort((a, b) => a.fcStart - b.fcStart);
+	return out;
+}
+function parseChpxFkp(page, out) {
+	const crun = page[FKP_SIZE - 1];
+	if (crun === 0 || (crun + 1) * 4 + crun > FKP_SIZE - 1) return;
+	for (let i = 0; i < crun; i++) {
+		const fcStart = u32(page, i * 4);
+		const fcEnd = u32(page, (i + 1) * 4);
+		if (fcEnd <= fcStart) continue;
+		let props = {};
+		const wordOff = page[(crun + 1) * 4 + i];
+		if (wordOff !== 0) {
+			const chpxOff = wordOff * 2;
+			const cb = chpxOff < FKP_SIZE ? page[chpxOff] : 0;
+			if (cb > 0 && chpxOff + 1 + cb <= FKP_SIZE) props = decodeChpxGrpprl(page.subarray(chpxOff + 1, chpxOff + 1 + cb));
+		}
+		out.push({
+			fcStart,
+			fcEnd,
+			props
+		});
+	}
+}
+function parsePapxFkp(page, out) {
+	const cpara = page[FKP_SIZE - 1];
+	if (cpara === 0 || (cpara + 1) * 4 + cpara * 13 > FKP_SIZE - 1) return;
+	const bxBase = (cpara + 1) * 4;
+	for (let i = 0; i < cpara; i++) {
+		const fcStart = u32(page, i * 4);
+		const fcEnd = u32(page, (i + 1) * 4);
+		if (fcEnd <= fcStart) continue;
+		let props = {};
+		const papxOff = page[bxBase + i * 13] * 2;
+		if (papxOff !== 0 && papxOff < FKP_SIZE) {
+			const cb = page[papxOff];
+			const size = cb !== 0 ? 2 * cb - 1 : 2 * (page[papxOff + 1] ?? 0);
+			const start = cb !== 0 ? papxOff + 1 : papxOff + 2;
+			if (size >= 2 && start + size <= FKP_SIZE) props = decodePapxGrpprl(page.subarray(start + 2, start + size));
+		}
+		out.push({
+			fcStart,
+			fcEnd,
+			props
+		});
+	}
+}
+function decodeChpxGrpprl(d) {
+	let bold;
+	let italic;
+	let underlineKul;
+	let sizeHalfPts;
+	let fSpec;
+	let picOffset;
+	for (const s of sprms(d)) switch (s.sprm) {
+		case SPRM_C_FBOLD:
+			bold = toggleBool(d[s.op]);
+			break;
+		case SPRM_C_FITALIC:
+			italic = toggleBool(d[s.op]);
+			break;
+		case SPRM_C_KUL:
+			underlineKul = d[s.op];
+			break;
+		case SPRM_C_HPS:
+			sizeHalfPts = u16(d, s.op);
+			break;
+		case SPRM_C_FSPEC:
+			fSpec = d[s.op] !== 0;
+			break;
+		case SPRM_C_PIC_LOCATION:
+			picOffset = u32(d, s.op);
+			break;
+	}
+	return {
+		...bold !== void 0 ? { bold } : {},
+		...italic !== void 0 ? { italic } : {},
+		...underlineKul !== void 0 ? { underlineKul } : {},
+		...sizeHalfPts !== void 0 ? { sizeHalfPts } : {},
+		...fSpec ? { fSpec } : {},
+		...picOffset !== void 0 ? { picOffset } : {}
+	};
+}
+function decodePapxGrpprl(d) {
+	let jc;
+	let indentLeftTwips;
+	let indentRightTwips;
+	let indentFirstTwips;
+	let spaceBeforeTwips;
+	let spaceAfterTwips;
+	let inTable;
+	let rowEnd;
+	let cellEdgesTwips;
+	let cellDescriptors;
+	let cellShadings;
+	let listIlfo;
+	let listIlvl;
+	for (const s of sprms(d)) switch (s.sprm) {
+		case SPRM_P_JC:
+			jc = d[s.op];
+			break;
+		case SPRM_P_DXA_LEFT:
+			indentLeftTwips = i16(d, s.op);
+			break;
+		case SPRM_P_DXA_RIGHT:
+			indentRightTwips = i16(d, s.op);
+			break;
+		case SPRM_P_DXA_LEFT1:
+			indentFirstTwips = i16(d, s.op);
+			break;
+		case SPRM_P_DYA_BEFORE:
+			spaceBeforeTwips = u16(d, s.op);
+			break;
+		case SPRM_P_DYA_AFTER:
+			spaceAfterTwips = u16(d, s.op);
+			break;
+		case SPRM_P_F_IN_TABLE:
+			inTable = d[s.op] !== 0;
+			break;
+		case SPRM_P_F_TTP:
+			rowEnd = d[s.op] !== 0;
+			break;
+		case SPRM_T_DEF_TABLE: {
+			const cols = d[s.op] ?? 0;
+			const edges = [];
+			for (let i = 0; i <= cols && s.op + 1 + i * 2 + 2 <= d.length; i++) edges.push(i16(d, s.op + 1 + i * 2));
+			if (edges.length >= 2) cellEdgesTwips = edges;
+			const tcBase = s.op + 1 + (cols + 1) * 2;
+			const descriptors = [];
+			for (let i = 0; i < cols && tcBase + i * 20 + 20 <= d.length; i++) descriptors.push(parseTc80(d, tcBase + i * 20));
+			if (descriptors.length > 0) cellDescriptors = descriptors;
+			break;
+		}
+		case SPRM_P_ILVL:
+			listIlvl = d[s.op];
+			break;
+		case SPRM_T_DEF_TABLE_SHD: {
+			const shd = [];
+			for (let i = 0; s.op + i * 10 + 10 <= d.length && i < MAX_ROW_CELLS; i++) {
+				const o = s.op + i * 10 + 4;
+				shd.push(d[o + 3] === 0 ? colorHex(d[o], d[o + 1], d[o + 2]) : void 0);
+			}
+			if (shd.length > 0) cellShadings = shd;
+			break;
+		}
+		case SPRM_P_ILFO:
+			listIlfo = u16(d, s.op);
+			break;
+	}
+	return {
+		...jc !== void 0 ? { jc } : {},
+		...indentLeftTwips !== void 0 ? { indentLeftTwips } : {},
+		...indentRightTwips !== void 0 ? { indentRightTwips } : {},
+		...indentFirstTwips !== void 0 ? { indentFirstTwips } : {},
+		...spaceBeforeTwips !== void 0 ? { spaceBeforeTwips } : {},
+		...spaceAfterTwips !== void 0 ? { spaceAfterTwips } : {},
+		...inTable ? { inTable } : {},
+		...rowEnd ? { rowEnd } : {},
+		...cellEdgesTwips ? { cellEdgesTwips } : {},
+		...cellDescriptors ? { cellDescriptors } : {},
+		...cellShadings ? { cellShadings } : {},
+		...listIlfo !== void 0 ? { listIlfo } : {},
+		...listIlvl !== void 0 ? { listIlvl } : {}
+	};
+}
+function* sprms(d) {
+	let p = 0;
+	while (p + 2 <= d.length) {
+		const sprm = u16(d, p);
+		p += 2;
+		const spra = sprm >> 13;
+		let op = p;
+		let len = SPRA_LEN[spra];
+		if (spra === 6) if (SPRM_LONG_OPERAND.has(sprm)) {
+			if (p + 2 > d.length) break;
+			const cb = u16(d, p);
+			if (cb < 1) break;
+			len = cb - 1;
+			op = p + 2;
+		} else {
+			if (p >= d.length) break;
+			len = d[p];
+			op = p + 1;
+		}
+		if (op + len > d.length) break;
+		yield {
+			sprm,
+			op
+		};
+		p = op + len;
+	}
+}
+function toggleBool(v) {
+	if (v === 0) return false;
+	if (v === 1 || v === 129) return true;
+}
+function extractPicture(data, fcPic) {
+	if (fcPic < 0 || fcPic + 36 > data.length) return void 0;
+	const lcb = u32(data, fcPic);
+	const cbHeader = u16(data, fcPic + 4);
+	if (cbHeader < 46 || lcb <= cbHeader || fcPic + lcb > data.length) return void 0;
+	const dxaGoal = u16(data, fcPic + 28);
+	const dyaGoal = u16(data, fcPic + 30);
+	const mx = u16(data, fcPic + 32) || 1e3;
+	const my = u16(data, fcPic + 34) || 1e3;
+	const bytes = scanImage(data.subarray(fcPic + cbHeader, fcPic + lcb));
+	if (!bytes) return void 0;
+	return {
+		bytes,
+		widthTwips: Math.round(dxaGoal * mx / 1e3),
+		heightTwips: Math.round(dyaGoal * my / 1e3)
+	};
+}
+var IMAGE_MAGICS = [
+	[
+		137,
+		80,
+		78,
+		71
+	],
+	[
+		255,
+		216,
+		255
+	],
+	[
+		71,
+		73,
+		70,
+		56
+	],
+	[66, 77],
+	[
+		73,
+		73,
+		42,
+		0
+	],
+	[
+		77,
+		77,
+		0,
+		42
+	]
+];
+function scanImage(region) {
+	const limit = Math.min(region.length, 512);
+	for (let off = 0; off < limit; off++) for (const magic of IMAGE_MAGICS) if (off + magic.length <= region.length && magicAt(region, off, magic)) return region.subarray(off);
+}
+function magicAt(d, off, magic) {
+	for (let i = 0; i < magic.length; i++) if (d[off + i] !== magic[i]) return false;
+	return true;
+}
+function buildParagraphs(wd, pieces, chpx, papx, cpStart, cpEnd, data) {
+	const end = Math.min(cpEnd, cpStart + MAX_TEXT);
+	const paragraphs = [];
+	let runs = [];
+	let cur = "";
+	let curProps = {};
+	let lastFc = 0;
+	let fieldDepth = 0;
+	let codeDepth = 0;
+	const flushRun = () => {
+		if (cur.length > 0) {
+			runs.push({
+				text: cur,
+				props: curProps
+			});
+			cur = "";
+		}
+	};
+	const endParagraph = (fc, cellMark) => {
+		flushRun();
+		paragraphs.push({
+			runs,
+			props: lookup(papx, fc) ?? {},
+			...cellMark ? { cellMark: true } : {}
+		});
+		runs = [];
+	};
+	for (const piece of pieces) {
+		if (piece.cpStart >= end) break;
+		if (piece.cpEnd <= cpStart) continue;
+		const step = piece.compressed ? 1 : 2;
+		const kStart = Math.max(0, cpStart - piece.cpStart);
+		const kEnd = Math.min(piece.cpEnd - piece.cpStart, end - piece.cpStart);
+		for (let k = kStart; k < kEnd; k++) {
+			const fc = piece.fc + k * step;
+			lastFc = fc;
+			const code = piece.compressed ? byteCode(wd, fc) : unitCode(wd, fc);
+			if (code < 0) continue;
+			if (code === CR || code === CELL_MARK) {
+				endParagraph(fc, code === CELL_MARK);
+				continue;
+			}
+			if (code === FIELD_BEGIN) {
+				fieldDepth++;
+				codeDepth++;
+				continue;
+			}
+			if (code === FIELD_SEPARATOR) {
+				if (codeDepth > 0) codeDepth--;
+				continue;
+			}
+			if (code === FIELD_END) {
+				if (fieldDepth > 0) fieldDepth--;
+				if (codeDepth > fieldDepth) codeDepth = fieldDepth;
+				continue;
+			}
+			if (codeDepth > 0) continue;
+			if (code === PIC_CHAR) {
+				const props = lookup(chpx, fc) ?? {};
+				const picture = data && props.fSpec && props.picOffset !== void 0 ? extractPicture(data, props.picOffset) : void 0;
+				if (picture) {
+					flushRun();
+					runs.push({
+						text: "",
+						props: {},
+						picture
+					});
+				}
+				continue;
+			}
+			const ch = code === 9 || code === 11 ? " " : code < 32 ? "" : String.fromCharCode(code);
+			if (ch.length === 0) continue;
+			const props = lookup(chpx, fc) ?? {};
+			if (cur.length === 0) curProps = props;
+			else if (!sameProps(props, curProps)) {
+				flushRun();
+				curProps = props;
+			}
+			cur += ch;
+		}
+	}
+	if (cur.length > 0 || runs.length > 0) endParagraph(lastFc, false);
+	return paragraphs;
+}
+function lookup(runs, fc) {
+	let lo = 0;
+	let hi = runs.length - 1;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const r = runs[mid];
+		if (fc < r.fcStart) hi = mid - 1;
+		else if (fc >= r.fcEnd) lo = mid + 1;
+		else return r.props;
+	}
+}
+function sameProps(a, b) {
+	return a.bold === b.bold && a.italic === b.italic && a.underlineKul === b.underlineKul && a.sizeHalfPts === b.sizeHalfPts;
+}
+var CP1252_HIGH = [
+	8364,
+	129,
+	8218,
+	402,
+	8222,
+	8230,
+	8224,
+	8225,
+	710,
+	8240,
+	352,
+	8249,
+	338,
+	141,
+	381,
+	143,
+	144,
+	8216,
+	8217,
+	8220,
+	8221,
+	8226,
+	8211,
+	8212,
+	732,
+	8482,
+	353,
+	8250,
+	339,
+	157,
+	382,
+	376
+];
+function byteCode(d, fc) {
+	const b = d[fc];
+	if (b === void 0) return -1;
+	return b >= 128 && b <= 159 ? CP1252_HIGH[b - 128] : b;
+}
+function unitCode(d, fc) {
+	if (fc + 1 >= d.length) return -1;
+	return d[fc] | d[fc + 1] << 8;
+}
+function u16(d, off) {
+	return (d[off] ?? 0) | (d[off + 1] ?? 0) << 8;
+}
+function i16(d, off) {
+	const v = u16(d, off);
+	return v >= 32768 ? v - 65536 : v;
+}
+function u32(d, off) {
+	return ((d[off] ?? 0) | (d[off + 1] ?? 0) << 8 | (d[off + 2] ?? 0) << 16 | (d[off + 3] ?? 0) << 24) >>> 0;
+}
+//#endregion
+export { extractDocContent };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reamkit",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Ream — convert DOCX, XLSX, PPTX and PDF to PDF, SVG, HTML, DOCX and XLSX, built from scratch on the ECMA-376 and ISO 32000 specifications. Parse once, convert anywhere.",
   "license": "MIT",
   "author": "Alex Krassavin <info@reamkit.dev>",