doc-codec 0.0.0 → 1.0.0

package/dist/prop/pap.d.ts

@@ -0,0 +1,25 @@
+import { Prl } from "./sprm.js";
+import { Alignment } from "document-schema.js";
+//#region src/prop/pap.d.ts
+interface ParagraphProperties {
+  istd?: number;
+  alignment?: Alignment;
+  indentLeftPt?: number;
+  indentRightPt?: number;
+  indentFirstLinePt?: number;
+  spacingBeforePt?: number;
+  spacingAfterPt?: number;
+  lineSpacing?: number;
+  pageBreakBefore?: boolean;
+  /** sprmPOutLvl's zero-based level, present only when the paragraph is genuinely in an outline level rather than body text. */
+  outlineLevel?: number;
+  inTable?: boolean;
+  /** True on the cell mark that terminates a table row. */
+  tableRowEnd?: boolean;
+  listLevel?: number;
+  /** The list identifier (sprmPIlfo), present only when the paragraph is in a list at all. */
+  listId?: number;
+}
+declare function applyParagraphSprms(prls: readonly Prl[], into: ParagraphProperties): ParagraphProperties;
+//#endregion
+export { ParagraphProperties, applyParagraphSprms };

package/dist/prop/pap.js

@@ -0,0 +1,133 @@
+import { readInt16LE, readUint16LE, readUint8 } from "../bytes.js";
+import { SGC } from "./sprm.js";
+//#region src/prop/pap.ts
+/** sprmPIstd: the istd of the paragraph style. */
+const SPRM_P_ISTD = 17920;
+/** sprmPJc80: physical justification, six values. */
+const SPRM_P_JC_80 = 9219;
+/** sprmPJc: logical justification, ten values aligned with ECMA-376's ST_Jc. */
+const SPRM_P_JC = 9313;
+/** sprmPFPageBreakBefore: a Bool8. */
+const SPRM_P_F_PAGE_BREAK_BEFORE = 9223;
+/** sprmPDxaLeft80 / sprmPDxaLeft: the left indent in twips. */
+const SPRM_P_DXA_LEFT_80 = 33807;
+const SPRM_P_DXA_LEFT = 33886;
+/** sprmPDxaRight80 / sprmPDxaRight: the right indent in twips. */
+const SPRM_P_DXA_RIGHT_80 = 33806;
+const SPRM_P_DXA_RIGHT = 33885;
+/** sprmPDxaLeft180 / sprmPDxaLeft1: the first line's indent relative to the rest of the paragraph. */
+const SPRM_P_DXA_LEFT1_80 = 33809;
+const SPRM_P_DXA_LEFT1 = 33888;
+/** sprmPDyaBefore / sprmPDyaAfter: spacing in twips. */
+const SPRM_P_DYA_BEFORE = 42003;
+const SPRM_P_DYA_AFTER = 42004;
+/** sprmPDyaLine: an LSPD. */
+const SPRM_P_DYA_LINE = 25618;
+/** sprmPOutLvl: the zero-based outline level, or 0x9 for body text. */
+const SPRM_P_OUT_LVL = 9792;
+/** sprmPFInTable: a Bool8 that "MUST be 1 any time the table depth is greater than zero". */
+const SPRM_P_F_IN_TABLE = 9238;
+/** sprmPFTtp: marks a cell mark as a table-terminating-paragraph mark, i.e. the end of a row. */
+const SPRM_P_F_TTP = 9239;
+/** sprmPIlvl: the zero-based list level, or 0xC for a paragraph the list skips. */
+const SPRM_P_ILVL = 9738;
+/** sprmPIlfo: which list the paragraph is in, as an index into PlfLfo.rgLfo. */
+const SPRM_P_ILFO = 17931;
+const TWIPS_PER_POINT = 20;
+/** LSPD: "The spacing multiplier is dyaLine/240." */
+const LSPD_MULTIPLE_DIVISOR = 240;
+/** LSPD.dyaLine's multiplier form applies only "when dyaLine is between 0x0000 and 0x7BC0". */
+const LSPD_MAX_MULTIPLE_DYA_LINE = 31680;
+/** sprmPOutLvl's "0x9 - The paragraph at any outline level; instead, the paragraph is body text." */
+const OUT_LVL_BODY_TEXT = 9;
+/** sprmPIlvl's "0xC - The list skips this paragraph and does not include it in its numbering." */
+const ILVL_SKIPPED = 12;
+/** sprmPIlfo's two "not in a list" values: "0x0000 - This paragraph is not in a list" and "0xF801 - This paragraph is not in a list." */
+const ILFO_NOT_IN_LIST = 0;
+const ILFO_NOT_IN_LIST_ALT = -2047;
+function twipsToPoints(twips) {
+	return twips / TWIPS_PER_POINT;
+}
+function alignmentFromJc(value) {
+	switch (value) {
+		case 0: return "left";
+		case 1: return "center";
+		case 2: return "right";
+		case 3:
+		case 4:
+		case 5:
+		case 7:
+		case 8:
+		case 9: return "justify";
+		default: return;
+	}
+}
+function lineSpacingFromLspd(operand) {
+	const dyaLine = readInt16LE(operand, 0);
+	if (readUint16LE(operand, 2) !== 1) return void 0;
+	if (dyaLine < 0 || dyaLine > LSPD_MAX_MULTIPLE_DYA_LINE) return void 0;
+	const multiple = dyaLine / LSPD_MULTIPLE_DIVISOR;
+	return multiple > 0 ? multiple : void 0;
+}
+function applyParagraphSprms(prls, into) {
+	for (const prl of prls) {
+		if (prl.sprm.sgc !== SGC.paragraph) continue;
+		switch (prl.sprm.value) {
+			case SPRM_P_ISTD:
+				into.istd = readUint16LE(prl.operand, 0);
+				break;
+			case SPRM_P_JC_80:
+			case SPRM_P_JC:
+				into.alignment = alignmentFromJc(readUint8(prl.operand, 0));
+				break;
+			case SPRM_P_F_PAGE_BREAK_BEFORE:
+				into.pageBreakBefore = readUint8(prl.operand, 0) !== 0;
+				break;
+			case SPRM_P_DXA_LEFT_80:
+			case SPRM_P_DXA_LEFT:
+				into.indentLeftPt = twipsToPoints(readInt16LE(prl.operand, 0));
+				break;
+			case SPRM_P_DXA_RIGHT_80:
+			case SPRM_P_DXA_RIGHT:
+				into.indentRightPt = twipsToPoints(readInt16LE(prl.operand, 0));
+				break;
+			case SPRM_P_DXA_LEFT1_80:
+			case SPRM_P_DXA_LEFT1:
+				into.indentFirstLinePt = twipsToPoints(readInt16LE(prl.operand, 0));
+				break;
+			case SPRM_P_DYA_BEFORE:
+				into.spacingBeforePt = twipsToPoints(readUint16LE(prl.operand, 0));
+				break;
+			case SPRM_P_DYA_AFTER:
+				into.spacingAfterPt = twipsToPoints(readUint16LE(prl.operand, 0));
+				break;
+			case SPRM_P_DYA_LINE:
+				into.lineSpacing = lineSpacingFromLspd(prl.operand);
+				break;
+			case SPRM_P_OUT_LVL: {
+				const level = readUint8(prl.operand, 0);
+				into.outlineLevel = level === OUT_LVL_BODY_TEXT ? void 0 : level;
+				break;
+			}
+			case SPRM_P_F_IN_TABLE:
+				into.inTable = readUint8(prl.operand, 0) !== 0;
+				break;
+			case SPRM_P_F_TTP:
+				into.tableRowEnd = readUint8(prl.operand, 0) !== 0;
+				break;
+			case SPRM_P_ILVL: {
+				const level = readUint8(prl.operand, 0);
+				into.listLevel = level === ILVL_SKIPPED ? void 0 : level;
+				break;
+			}
+			case SPRM_P_ILFO: {
+				const ilfo = readInt16LE(prl.operand, 0);
+				into.listId = ilfo === ILFO_NOT_IN_LIST || ilfo === ILFO_NOT_IN_LIST_ALT ? void 0 : Math.abs(ilfo);
+				break;
+			}
+		}
+	}
+	return into;
+}
+//#endregion
+export { applyParagraphSprms };

package/dist/prop/sprm.cjs

@@ -0,0 +1,68 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors.cjs");
+const require_bytes = require("../bytes.cjs");
+//#region src/prop/sprm.ts
+/** Sprm.sgc, [MS-DOC] 2.6.1 -- which property family the opcode belongs to. */
+const SGC = {
+	paragraph: 1,
+	character: 2,
+	picture: 3,
+	section: 4,
+	table: 5
+};
+const SPRM_T_DEF_TABLE = 54792;
+const SPRM_P_CHG_TABS = 50709;
+/** PChgTabsOperand.cb: "A value of 255 specifies that this instance of sprmPChgTabs MAY be ignored and that the size of the remainder of this operand ... is calculated by using the following formula". */
+const P_CHG_TABS_COMPUTED_SIZE = 255;
+function decodeSprm(value) {
+	return {
+		value,
+		ispmd: value & 511,
+		fSpec: (value >> 9 & 1) === 1 ? 1 : 0,
+		sgc: value >> 10 & 7,
+		spra: value >> 13 & 7
+	};
+}
+function operandSize(sprm, bytes, offset) {
+	switch (sprm.spra) {
+		case 0:
+		case 1: return 1;
+		case 2:
+		case 4:
+		case 5: return 2;
+		case 3: return 4;
+		case 7: return 3;
+		case 6: return variableOperandSize(sprm, bytes, offset);
+		default: throw new require_errors.DocFormatError(`sprm 0x${sprm.value.toString(16)} has spra ${sprm.spra}, which is outside the 0..7 range a 3-bit field can hold`);
+	}
+}
+function variableOperandSize(sprm, bytes, offset) {
+	if (sprm.value === SPRM_T_DEF_TABLE) {
+		const cb = require_bytes.readUint16LE(bytes, offset);
+		if (cb < 1) throw new require_errors.DocFormatError(`sprmTDefTable declares cb ${cb}, which cannot be a remainder length incremented by 1`);
+		return cb + 1;
+	}
+	const cb = require_bytes.readUint8(bytes, offset);
+	if (sprm.value === SPRM_P_CHG_TABS && cb === P_CHG_TABS_COMPUTED_SIZE) throw new require_errors.DocUnsupportedError("this paragraph carries a sprmPChgTabs whose cb is the 255 sentinel, so its operand length is computed from tab-stop counts doc-codec does not yet parse; the grpprl cannot be walked past it without guessing");
+	return 1 + cb;
+}
+function readGrpprl(bytes) {
+	const prls = [];
+	let cursor = 0;
+	while (cursor < bytes.length) {
+		if (cursor + 2 > bytes.length) throw new require_errors.DocFormatError(`grpprl has ${bytes.length - cursor} trailing byte(s) at offset ${cursor}, too few for a sprm's own two`);
+		const sprm = decodeSprm(require_bytes.readUint16LE(bytes, cursor));
+		const size = operandSize(sprm, bytes, cursor + 2);
+		prls.push({
+			sprm,
+			operand: require_bytes.slice(bytes, cursor + 2, size, `operand of sprm 0x${sprm.value.toString(16)} at grpprl offset ${cursor}`)
+		});
+		cursor += 2 + size;
+	}
+	return prls;
+}
+//#endregion
+exports.SGC = SGC;
+exports.decodeSprm = decodeSprm;
+exports.operandSize = operandSize;
+exports.readGrpprl = readGrpprl;

package/dist/prop/sprm.d.cts

@@ -0,0 +1,26 @@
+//#region src/prop/sprm.d.ts
+interface Sprm {
+  /** The raw 16-bit opcode, which is what the property tables in [MS-DOC] 2.6.1-2.6.5 are keyed on. */
+  readonly value: number;
+  readonly ispmd: number;
+  readonly fSpec: 0 | 1;
+  readonly sgc: number;
+  readonly spra: number;
+}
+interface Prl {
+  readonly sprm: Sprm;
+  readonly operand: Uint8Array;
+}
+/** Sprm.sgc, [MS-DOC] 2.6.1 -- which property family the opcode belongs to. */
+declare const SGC: {
+  readonly paragraph: 1;
+  readonly character: 2;
+  readonly picture: 3;
+  readonly section: 4;
+  readonly table: 5;
+};
+declare function decodeSprm(value: number): Sprm;
+declare function operandSize(sprm: Sprm, bytes: Uint8Array, offset: number): number;
+declare function readGrpprl(bytes: Uint8Array): Prl[];
+//#endregion
+export { Prl, SGC, Sprm, decodeSprm, operandSize, readGrpprl };

package/dist/prop/sprm.d.ts

@@ -0,0 +1,26 @@
+//#region src/prop/sprm.d.ts
+interface Sprm {
+  /** The raw 16-bit opcode, which is what the property tables in [MS-DOC] 2.6.1-2.6.5 are keyed on. */
+  readonly value: number;
+  readonly ispmd: number;
+  readonly fSpec: 0 | 1;
+  readonly sgc: number;
+  readonly spra: number;
+}
+interface Prl {
+  readonly sprm: Sprm;
+  readonly operand: Uint8Array;
+}
+/** Sprm.sgc, [MS-DOC] 2.6.1 -- which property family the opcode belongs to. */
+declare const SGC: {
+  readonly paragraph: 1;
+  readonly character: 2;
+  readonly picture: 3;
+  readonly section: 4;
+  readonly table: 5;
+};
+declare function decodeSprm(value: number): Sprm;
+declare function operandSize(sprm: Sprm, bytes: Uint8Array, offset: number): number;
+declare function readGrpprl(bytes: Uint8Array): Prl[];
+//#endregion
+export { Prl, SGC, Sprm, decodeSprm, operandSize, readGrpprl };

package/dist/prop/sprm.js

@@ -0,0 +1,64 @@
+import { DocFormatError, DocUnsupportedError } from "../errors.js";
+import { readUint16LE, readUint8, slice } from "../bytes.js";
+//#region src/prop/sprm.ts
+/** Sprm.sgc, [MS-DOC] 2.6.1 -- which property family the opcode belongs to. */
+const SGC = {
+	paragraph: 1,
+	character: 2,
+	picture: 3,
+	section: 4,
+	table: 5
+};
+const SPRM_T_DEF_TABLE = 54792;
+const SPRM_P_CHG_TABS = 50709;
+/** PChgTabsOperand.cb: "A value of 255 specifies that this instance of sprmPChgTabs MAY be ignored and that the size of the remainder of this operand ... is calculated by using the following formula". */
+const P_CHG_TABS_COMPUTED_SIZE = 255;
+function decodeSprm(value) {
+	return {
+		value,
+		ispmd: value & 511,
+		fSpec: (value >> 9 & 1) === 1 ? 1 : 0,
+		sgc: value >> 10 & 7,
+		spra: value >> 13 & 7
+	};
+}
+function operandSize(sprm, bytes, offset) {
+	switch (sprm.spra) {
+		case 0:
+		case 1: return 1;
+		case 2:
+		case 4:
+		case 5: return 2;
+		case 3: return 4;
+		case 7: return 3;
+		case 6: return variableOperandSize(sprm, bytes, offset);
+		default: throw new DocFormatError(`sprm 0x${sprm.value.toString(16)} has spra ${sprm.spra}, which is outside the 0..7 range a 3-bit field can hold`);
+	}
+}
+function variableOperandSize(sprm, bytes, offset) {
+	if (sprm.value === SPRM_T_DEF_TABLE) {
+		const cb = readUint16LE(bytes, offset);
+		if (cb < 1) throw new DocFormatError(`sprmTDefTable declares cb ${cb}, which cannot be a remainder length incremented by 1`);
+		return cb + 1;
+	}
+	const cb = readUint8(bytes, offset);
+	if (sprm.value === SPRM_P_CHG_TABS && cb === P_CHG_TABS_COMPUTED_SIZE) throw new DocUnsupportedError("this paragraph carries a sprmPChgTabs whose cb is the 255 sentinel, so its operand length is computed from tab-stop counts doc-codec does not yet parse; the grpprl cannot be walked past it without guessing");
+	return 1 + cb;
+}
+function readGrpprl(bytes) {
+	const prls = [];
+	let cursor = 0;
+	while (cursor < bytes.length) {
+		if (cursor + 2 > bytes.length) throw new DocFormatError(`grpprl has ${bytes.length - cursor} trailing byte(s) at offset ${cursor}, too few for a sprm's own two`);
+		const sprm = decodeSprm(readUint16LE(bytes, cursor));
+		const size = operandSize(sprm, bytes, cursor + 2);
+		prls.push({
+			sprm,
+			operand: slice(bytes, cursor + 2, size, `operand of sprm 0x${sprm.value.toString(16)} at grpprl offset ${cursor}`)
+		});
+		cursor += 2 + size;
+	}
+	return prls;
+}
+//#endregion
+export { SGC, decodeSprm, operandSize, readGrpprl };

package/dist/read.cjs

@@ -0,0 +1,171 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("./errors.cjs");
+const require_bytes = require("./bytes.cjs");
+const require_detect = require("./detect.cjs");
+const require_fib_fib = require("./fib/fib.cjs");
+const require_text_piece_table = require("./text/piece-table.cjs");
+const require_text_characters = require("./text/characters.cjs");
+const require_text_special = require("./text/special.cjs");
+const require_prop_sprm = require("./prop/sprm.cjs");
+const require_prop_fkp = require("./prop/fkp.cjs");
+const require_prop_chp = require("./prop/chp.cjs");
+const require_prop_pap = require("./prop/pap.cjs");
+const require_style_stsh = require("./style/stsh.cjs");
+let archive_codec = require("archive-codec");
+//#region src/read.ts
+/** The page geometry every section is given, because this reader does not yet read a document's own. US Letter with one-inch margins is Word's own default for a new document; a document that states otherwise is not yet consulted, so this is a placeholder the schema requires rather than a fact read from the file. */
+const DEFAULT_PAGE_SIZE = {
+	widthPt: 612,
+	heightPt: 792
+};
+const DEFAULT_MARGINS = {
+	topPt: 72,
+	rightPt: 72,
+	bottomPt: 72,
+	leftPt: 72
+};
+function readDocStreams(bytes) {
+	const streams = (0, archive_codec.readCompoundFile)(bytes);
+	const wordDocument = streams.find((stream) => stream.path === require_detect.WORD_DOCUMENT_STREAM);
+	if (wordDocument === void 0) throw new require_errors.DocFormatError(`this compound file has no "${require_detect.WORD_DOCUMENT_STREAM}" stream, so it is not a Word Binary File (it holds: ${streams.map((stream) => stream.path).join(", ")})`);
+	const fib = require_fib_fib.parseFib(wordDocument.bytes);
+	const wanted = require_fib_fib.tableStreamName(fib);
+	const table = streams.find((stream) => stream.path === wanted);
+	if (table === void 0) throw new require_errors.DocFormatError(`FibBase.fWhichTblStm selects the "${wanted}" stream, which this compound file does not contain`);
+	return {
+		wordDocument: wordDocument.bytes,
+		table: table.bytes,
+		fib
+	};
+}
+function readDocContent(bytes) {
+	const { wordDocument, table, fib } = readDocStreams(bytes);
+	const pieceTable = require_text_piece_table.parseClx(require_bytes.slice(table, fib.fcClx, fib.lcbClx, "Clx in the Table stream"));
+	const styles = fib.lcbStshf > 0 ? require_style_stsh.parseStsh(require_bytes.slice(table, fib.fcStshf, fib.lcbStshf, "STSH in the Table stream")) : void 0;
+	const chpxTable = new require_prop_fkp.PropertyBinTable(wordDocument, require_bytes.slice(table, fib.fcPlcfBteChpx, fib.lcbPlcfBteChpx, "PlcBteChpx in the Table stream"), "PlcBteChpx");
+	const papxTable = new require_prop_fkp.PropertyBinTable(wordDocument, require_bytes.slice(table, fib.fcPlcfBtePapx, fib.lcbPlcfBtePapx, "PlcBtePapx in the Table stream"), "PlcBtePapx");
+	const range = require_text_characters.readTextRange(wordDocument, pieceTable, 0, fib.ccpText);
+	const blocks = readParagraphs(range.text, range.fcs, {
+		chpxTable,
+		papxTable,
+		styles,
+		characterProperties: /* @__PURE__ */ new Map()
+	});
+	return {
+		kind: "wordprocessing",
+		metadata: {},
+		sections: [{
+			pageSize: DEFAULT_PAGE_SIZE,
+			margins: DEFAULT_MARGINS,
+			blocks
+		}]
+	};
+}
+function readParagraphs(text, fcs, context) {
+	const blocks = [];
+	let start = 0;
+	for (let index = 0; index < text.length; index += 1) {
+		const code = text.charCodeAt(index);
+		if (!require_text_special.endsParagraph(code)) continue;
+		const markFc = fcs[index];
+		if (markFc === void 0) throw new require_errors.DocFormatError(`character ${index} has no byte offset, so its paragraph's properties cannot be located`);
+		blocks.push(buildParagraph(text.slice(start, index), fcs.slice(start, index), markFc, context));
+		start = index + 1;
+	}
+	if (start < text.length) {
+		const firstFc = fcs[start];
+		if (firstFc === void 0) throw new require_errors.DocFormatError(`character ${start} has no byte offset, so the trailing paragraph's properties cannot be located`);
+		blocks.push(buildParagraph(text.slice(start), fcs.slice(start), firstFc, context));
+	}
+	return blocks;
+}
+function buildParagraph(text, fcs, propertyFc, context) {
+	const papx = context.papxTable.papx(propertyFc);
+	const properties = {};
+	if (papx !== void 0) {
+		properties.istd = papx.istd;
+		require_prop_pap.applyParagraphSprms(require_prop_sprm.readGrpprl(papx.grpprl), properties);
+	}
+	return {
+		kind: "paragraph",
+		runs: buildRuns(text, fcs, context),
+		...paragraphAttributes(properties, context)
+	};
+}
+function paragraphAttributes(properties, context) {
+	const attributes = {};
+	const istd = properties.istd;
+	if (istd !== void 0) {
+		const style = context.styles?.styles[istd];
+		if (style !== void 0 && style.name !== "") attributes.styleId = style.name;
+		const headingLevel = require_style_stsh.headingLevelFromIstd(istd);
+		if (headingLevel !== void 0) attributes.headingLevel = headingLevel;
+	}
+	if (attributes.headingLevel === void 0 && properties.outlineLevel !== void 0) attributes.headingLevel = properties.outlineLevel + 1;
+	if (properties.alignment !== void 0) attributes.alignment = properties.alignment;
+	if (properties.spacingBeforePt !== void 0) attributes.spacingBeforePt = properties.spacingBeforePt;
+	if (properties.spacingAfterPt !== void 0) attributes.spacingAfterPt = properties.spacingAfterPt;
+	if (properties.lineSpacing !== void 0) attributes.lineSpacing = properties.lineSpacing;
+	if (properties.indentLeftPt !== void 0) attributes.indentLeftPt = properties.indentLeftPt;
+	if (properties.indentFirstLinePt !== void 0) attributes.indentFirstLinePt = properties.indentFirstLinePt;
+	if (properties.pageBreakBefore === true) attributes.pageBreakBefore = true;
+	if (properties.listId !== void 0) attributes.list = {
+		numId: String(properties.listId),
+		level: properties.listLevel ?? 0
+	};
+	return attributes;
+}
+function buildRuns(text, fcs, context) {
+	const runs = [];
+	let currentKey;
+	let currentText = "";
+	let currentProperties = {};
+	const enclosingInstruction = [];
+	let inInstruction = false;
+	const flush = () => {
+		if (currentText !== "") runs.push({
+			text: currentText,
+			...currentProperties
+		});
+		currentText = "";
+	};
+	for (let index = 0; index < text.length; index += 1) {
+		const code = text.charCodeAt(index);
+		if (code === 19) {
+			flush();
+			enclosingInstruction.push(inInstruction);
+			inInstruction = true;
+			continue;
+		}
+		if (code === 20) {
+			inInstruction = false;
+			continue;
+		}
+		if (code === 21) {
+			inInstruction = enclosingInstruction.pop() ?? inInstruction;
+			continue;
+		}
+		if (inInstruction || require_text_special.isAnchorOnly(code)) continue;
+		const fc = fcs[index];
+		if (fc === void 0) throw new require_errors.DocFormatError(`character ${index} of a paragraph has no byte offset, so its formatting cannot be located`);
+		const grpprl = context.chpxTable.chpxGrpprl(fc);
+		const key = grpprl === void 0 ? "none" : `${grpprl.byteOffset}:${grpprl.byteLength}`;
+		if (key !== currentKey) {
+			flush();
+			currentKey = key;
+			let properties = context.characterProperties.get(key);
+			if (properties === void 0) {
+				properties = {};
+				if (grpprl !== void 0) require_prop_chp.applyCharacterSprms(require_prop_sprm.readGrpprl(grpprl), properties);
+				context.characterProperties.set(key, properties);
+			}
+			currentProperties = properties;
+		}
+		currentText += String.fromCharCode(code === 11 ? 10 : code);
+	}
+	flush();
+	return runs;
+}
+//#endregion
+exports.readDocContent = readDocContent;
+exports.readDocStreams = readDocStreams;

package/dist/read.d.cts

@@ -0,0 +1,12 @@
+import { Fib } from "./fib/fib.cjs";
+import { ContentDocument } from "document-schema.js";
+//#region src/read.d.ts
+interface DocStreams {
+  readonly wordDocument: Uint8Array;
+  readonly table: Uint8Array;
+  readonly fib: Fib;
+}
+declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>): DocStreams;
+declare function readDocContent(bytes: Uint8Array<ArrayBuffer>): ContentDocument;
+//#endregion
+export { DocStreams, readDocContent, readDocStreams };

package/dist/read.d.ts

@@ -0,0 +1,12 @@
+import { Fib } from "./fib/fib.js";
+import { ContentDocument } from "document-schema.js";
+//#region src/read.d.ts
+interface DocStreams {
+  readonly wordDocument: Uint8Array;
+  readonly table: Uint8Array;
+  readonly fib: Fib;
+}
+declare function readDocStreams(bytes: Uint8Array<ArrayBuffer>): DocStreams;
+declare function readDocContent(bytes: Uint8Array<ArrayBuffer>): ContentDocument;
+//#endregion
+export { DocStreams, readDocContent, readDocStreams };