doc-codec 1.0.2 → 1.1.1

package/dist/list/numbering.js

@@ -0,0 +1,205 @@
+import { DocFormatError } from "../errors.js";
+import { readInt16LE, readInt32LE, readUint16LE, readUint8, slice } from "../bytes.js";
+//#region src/list/numbering.ts
+const LSTF_SIZE = 28;
+const LVLF_SIZE = 28;
+const LFO_SIZE = 16;
+/** LSTF's own flags byte ([MS-DOC] 2.9.191), bit 0: "this LSTF represents a simple (one-level) list that has one corresponding LVL. Otherwise... a multi-level list that has nine corresponding LVLs." */
+const LSTF_FLAG_SIMPLE_LIST = 1;
+/** MSONFC ([MS-OSHARED] 2.2.1.3), mapped to its own documented ST_NumberFormat equivalent -- the identical vocabulary ooxml.js's NumberingLevel.format carries verbatim from word/numbering.xml's own w:numFmt/@w:val. Every member through msonfcUCRus (0x3B) is a real numbered/lettered/ideograph format; 0x17 (msonfcBullet) is handled separately below since PlfLfo also treats it as the "no number sequence, but has bullets" case LVLF's own field text calls out by name. */
+const NUMBER_FORMAT_BY_NFC = {
+	0: "decimal",
+	1: "upperRoman",
+	2: "lowerRoman",
+	3: "upperLetter",
+	4: "lowerLetter",
+	5: "ordinal",
+	6: "cardinalText",
+	7: "ordinalText",
+	8: "hex",
+	9: "chicago",
+	10: "ideographDigital",
+	11: "japaneseCounting",
+	12: "Aiueo",
+	13: "Iroha",
+	14: "decimalFullWidth",
+	15: "decimalHalfWidth",
+	16: "japaneseLegal",
+	17: "japaneseDigitalTenThousand",
+	18: "decimalEnclosedCircle",
+	19: "decimalFullWidth2",
+	20: "aiueoFullWidth",
+	21: "irohaFullWidth",
+	22: "decimalZero",
+	23: "bullet",
+	24: "ganada",
+	25: "chosung",
+	26: "decimalEnclosedFullstop",
+	27: "decimalEnclosedParen",
+	28: "decimalEnclosedCircleChinese",
+	29: "ideographEnclosedCircle",
+	30: "ideographTraditional",
+	31: "ideographZodiac",
+	32: "ideographZodiacTraditional",
+	33: "taiwaneseCounting",
+	34: "ideographLegalTraditional",
+	35: "taiwaneseCountingThousand",
+	36: "taiwaneseDigital",
+	37: "chineseCounting",
+	38: "chineseLegalSimplified",
+	39: "chineseCountingThousand",
+	40: "decimal",
+	41: "koreanDigital",
+	42: "koreanCounting",
+	43: "koreanLegal",
+	44: "koreanDigital2",
+	45: "hebrew1",
+	46: "arabicAlpha",
+	47: "hebrew2",
+	48: "arabicAbjad",
+	49: "hindiVowels",
+	50: "hindiConsonants",
+	51: "hindiNumbers",
+	52: "hindiCounting",
+	53: "thaiLetters",
+	54: "thaiNumbers",
+	55: "thaiCounting",
+	56: "vietnameseCounting",
+	57: "numberInDash",
+	58: "russianLower",
+	59: "russianUpper"
+};
+/** MSONFC's own "Specifies that the sequence will not display any numbering" sentinel -- not itself an ST_NumberFormat value, so this reader's own spelling for it ("none") is a deliberate literal rather than a value MSONFC's table states. */
+const NFC_NONE = 255;
+function numberFormatFor(nfc) {
+	if (nfc === NFC_NONE) return "none";
+	const format = NUMBER_FORMAT_BY_NFC[nfc];
+	if (format === void 0) throw new DocFormatError(`LVLF.nfc is 0x${nfc.toString(16).padStart(2, "0")}, not a recognised MSONFC value ([MS-OSHARED] 2.2.1.3)`);
+	return format;
+}
+/** LSTF ([MS-DOC] 2.9.191): lsid(4) + tplc(4, ignored -- UI-only) + rgistdPara(18, ignored -- this reader has no per-level style cascade to link into) + a flags byte (only fSimpleList, bit 0, acted on) + grfhic(1, ignored -- HTML-export-only incompatibility flags). Fixed 28 bytes. */
+function readLstf(bytes, offset) {
+	return {
+		lsid: readInt32LE(bytes, offset),
+		fSimpleList: (readUint8(bytes, offset + 26) & LSTF_FLAG_SIMPLE_LIST) !== 0
+	};
+}
+/** Xst ([MS-DOC] 2.9.343): cch(2 bytes) then that many raw 16-bit code units, prefixed-length and not null-terminated. Decoded as a plain UTF-16 string -- readLevelText below re-inspects specific character positions afterward for placeholders, which round-trips exactly through String.fromCharCode/charCodeAt since every placeholder value (0-8) sits well within one UTF-16 code unit and never needs a surrogate pair. Returns the decoded text and the byte length consumed, since the caller must advance past it to reach grpprlPapx/grpprlChpx or the next LVL. */
+function readXst(bytes, offset) {
+	const cch = readUint16LE(bytes, offset);
+	let text = "";
+	for (let index = 0; index < cch; index += 1) text += String.fromCharCode(readUint16LE(bytes, offset + 2 + index * 2));
+	return {
+		text,
+		byteLength: 2 + cch * 2
+	};
+}
+/** rgbxchNums ([MS-DOC] 2.9.148's own LVLF field): nine 8-bit one-based character offsets into the LVL's own xst.rgtchar, zero-terminated (a 0 entry, or the end of the fixed 9-byte array, ends the list). Each offset it names is a POSITION in the string, not a value -- readLevelText is what turns a position into the placeholder it names. */
+function readRgbxchNums(bytes, offset) {
+	const positions = [];
+	for (let index = 0; index < 9; index += 1) {
+		const value = readUint8(bytes, offset + index);
+		if (value === 0) break;
+		positions.push(value);
+	}
+	return positions;
+}
+/** Turns an Xst's own decoded text plus its rgbxchNums positions into the '%1.'-style placeholder text NumberingLevel.text states -- the mirror of readXst/readRgbxchNums together. [MS-DOC]'s own Xst field text: "Each placeholder is an unsigned 2-byte integer that specifies the zero-based level that the placeholder is for" -- so the character AT a named position is not a literal code point at all, but a raw level index (0-8) String.fromCharCode/charCodeAt round-trips losslessly; every other position is decoded as ordinary text. A one-based placeholder ('%1' for level 0) matches ooxml.js's own w:lvlText convention, so a consumer already resolving '%1.'/'%2)' style docx templates resolves this reader's templates identically. */
+function readLevelText(xstText, placeholderPositions) {
+	const placeholders = new Set(placeholderPositions);
+	let result = "";
+	for (let index = 0; index < xstText.length; index += 1) {
+		const oneBasedPosition = index + 1;
+		if (placeholders.has(oneBasedPosition)) {
+			const levelIndex = xstText.charCodeAt(index);
+			result += `%${levelIndex + 1}`;
+		} else result += xstText.charAt(index);
+	}
+	return result;
+}
+/** LVL ([MS-DOC] 2.9.196): a 28-byte LVLF, then grpprlPapx (cbGrpprlPapx bytes, skipped -- see this module's own top comment), grpprlChpx (cbGrpprlChpx bytes, skipped), then the level's own Xst. Every LVL is variable-length, so the caller must use byteLength to advance to the next one in the array -- there is no outer length field to skip by instead. */
+function readLvl(bytes, offset) {
+	if (offset + LVLF_SIZE > bytes.length) throw new DocFormatError(`PlfLst's own appended LVL array runs past the end of its ${bytes.length}-byte buffer at offset ${offset}, ${LVLF_SIZE} bytes short of one LVLF`);
+	const iStartAt = readInt32LE(bytes, offset);
+	const nfc = readUint8(bytes, offset + 4);
+	const fNoRestart = (readUint8(bytes, offset + 5) & 2) !== 0;
+	const rgbxchNums = readRgbxchNums(bytes, offset + 6);
+	const cbGrpprlChpx = readUint8(bytes, offset + 24);
+	const cbGrpprlPapx = readUint8(bytes, offset + 25);
+	const ilvlRestartLim = readUint8(bytes, offset + 26);
+	const { text: xstText, byteLength: xstByteLength } = readXst(bytes, offset + LVLF_SIZE + cbGrpprlPapx + cbGrpprlChpx);
+	const level = {
+		format: numberFormatFor(nfc),
+		text: readLevelText(xstText, rgbxchNums),
+		startAt: iStartAt
+	};
+	return {
+		level: fNoRestart ? {
+			...level,
+			restart: ilvlRestartLim
+		} : level,
+		byteLength: LVLF_SIZE + cbGrpprlPapx + cbGrpprlChpx + xstByteLength
+	};
+}
+/** PlfLst ([MS-DOC] 2.9.226): cLst(2 bytes, signed) then that many 28-byte LSTF entries -- followed IMMEDIATELY by the appended LVL array FibRgFcLcb97's own fcPlfLst field describes, which lcbPlfLst does not account for and which this function therefore reads past the declared PlfLst length to reach. */
+function parsePlfLst(table, fc, lcb) {
+	const plfLst = slice(table, fc, lcb, "PlfLst");
+	const cLst = readInt16LE(plfLst, 0);
+	if (cLst < 0) throw new DocFormatError(`PlfLst.cLst is ${cLst}, a negative LSTF count [MS-DOC] 2.9.226 never permits`);
+	const lstfs = [];
+	for (let index = 0; index < cLst; index += 1) lstfs.push(readLstf(plfLst, 2 + index * LSTF_SIZE));
+	let cursor = fc + lcb;
+	const levelsByLstf = [];
+	for (const lstf of lstfs) {
+		const count = lstf.fSimpleList ? 1 : 9;
+		const levels = [];
+		for (let index = 0; index < count; index += 1) {
+			const { level, byteLength } = readLvl(table, cursor);
+			levels.push(level);
+			cursor += byteLength;
+		}
+		levelsByLstf.push(levels);
+	}
+	return {
+		lstfs,
+		levelsByLstf
+	};
+}
+/** PlfLfo ([MS-DOC] 2.9.225): lfoMac(4 bytes) then that many 16-byte LFO entries (rgLfo), then rgLfoData -- this reader's own scope stops at rgLfo, since resolving ilfo to a list needs only each LFO's own lsid (rgLfoData carries LFOLVL overrides this reader deliberately does not apply; see this module's own top comment). rgLfo sits entirely before rgLfoData in the stream, so not reading rgLfoData at all is a real, not merely partial, saving -- no cursor needs to walk past it. */
+function parseLfoLsids(table, fc, lcb) {
+	const plfLfo = slice(table, fc, lcb, "PlfLfo");
+	const lfoMac = readInt32LE(plfLfo, 0);
+	if (lfoMac < 0) throw new DocFormatError(`PlfLfo.lfoMac is ${lfoMac}, a negative LFO count [MS-DOC] 2.9.225 never permits`);
+	const lsids = [];
+	for (let index = 0; index < lfoMac; index += 1) {
+		const offset = 4 + index * LFO_SIZE;
+		if (offset + LFO_SIZE > plfLfo.length) throw new DocFormatError(`PlfLfo declares lfoMac=${lfoMac} LFO entries, but its own ${plfLfo.length}-byte buffer has room for only ${Math.floor((plfLfo.length - 4) / LFO_SIZE)}`);
+		lsids.push(readInt32LE(plfLfo, offset));
+	}
+	return lsids;
+}
+/** Resolves PlfLst and PlfLfo into NumberingDefinitions, keyed by the one-based ilfo every listId already is (prop/pap.ts's own Math.abs(ilfo)) -- absent entirely when the file carries neither (fcPlfLst/fcPlfLfo both 0, a document with no lists at all, the common case this reader must not fail on). */
+function readNumberingDefinitions(table, fib) {
+	if (fib.lcbPlfLst === 0 || fib.lcbPlfLfo === 0) return {};
+	const { lstfs, levelsByLstf } = parsePlfLst(table, fib.fcPlfLst, fib.lcbPlfLst);
+	const lsids = parseLfoLsids(table, fib.fcPlfLfo, fib.lcbPlfLfo);
+	const levelsByLsid = /* @__PURE__ */ new Map();
+	lstfs.forEach((lstf, index) => {
+		const levels = levelsByLstf[index];
+		if (levels !== void 0) levelsByLsid.set(lstf.lsid, levels);
+	});
+	const definitions = {};
+	lsids.forEach((lsid, index) => {
+		const levels = levelsByLsid.get(lsid);
+		if (levels === void 0) return;
+		const ilfo = index + 1;
+		const byLevel = {};
+		levels.forEach((level, levelIndex) => {
+			byLevel[String(levelIndex)] = level;
+		});
+		definitions[String(ilfo)] = { levels: byLevel };
+	});
+	return definitions;
+}
+//#endregion
+export { readNumberingDefinitions };

package/dist/metadata.cjs

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("./errors.cjs");
+let archive_codec = require("archive-codec");
+//#region src/metadata.ts
+function requireValidIsoDate(value, field) {
+	if (value !== void 0 && Number.isNaN(new Date(value).getTime())) throw new require_errors.DocFormatError(`LayoutMetadata.${field} "${value}" is not a valid date string, so it cannot be written as a SummaryInformation FILETIME property`);
+}
+function layoutMetadataToSummaryInformation(metadata) {
+	requireValidIsoDate(metadata.createdIso, "createdIso");
+	requireValidIsoDate(metadata.modifiedIso, "modifiedIso");
+	return (0, archive_codec.layoutMetadataToSummaryInformation)(metadata);
+}
+//#endregion
+exports.layoutMetadataToSummaryInformation = layoutMetadataToSummaryInformation;

package/dist/metadata.d.cts

@@ -0,0 +1,6 @@
+import { LayoutMetadata } from "document-schema.js";
+import { SummaryInformationProperties } from "archive-codec";
+//#region src/metadata.d.ts
+declare function layoutMetadataToSummaryInformation(metadata: LayoutMetadata): SummaryInformationProperties;
+//#endregion
+export { layoutMetadataToSummaryInformation };

package/dist/metadata.d.ts

@@ -0,0 +1,6 @@
+import { SummaryInformationProperties } from "archive-codec";
+import { LayoutMetadata } from "document-schema.js";
+//#region src/metadata.d.ts
+declare function layoutMetadataToSummaryInformation(metadata: LayoutMetadata): SummaryInformationProperties;
+//#endregion
+export { layoutMetadataToSummaryInformation };

package/dist/metadata.js

@@ -0,0 +1,13 @@
+import { DocFormatError } from "./errors.js";
+import { layoutMetadataToSummaryInformation as layoutMetadataToSummaryInformation$1 } from "archive-codec";
+//#region src/metadata.ts
+function requireValidIsoDate(value, field) {
+	if (value !== void 0 && Number.isNaN(new Date(value).getTime())) throw new DocFormatError(`LayoutMetadata.${field} "${value}" is not a valid date string, so it cannot be written as a SummaryInformation FILETIME property`);
+}
+function layoutMetadataToSummaryInformation(metadata) {
+	requireValidIsoDate(metadata.createdIso, "createdIso");
+	requireValidIsoDate(metadata.modifiedIso, "modifiedIso");
+	return layoutMetadataToSummaryInformation$1(metadata);
+}
+//#endregion
+export { layoutMetadataToSummaryInformation };

package/dist/numbering-Cir-uGdc.d.cts

@@ -0,0 +1,22 @@
+import { t as Fib } from "./fib-CtsLtF96.cjs";
+//#region src/list/numbering.d.ts
+interface NumberingLevel {
+  /** The ST_NumberFormat-equivalent string MSONFC's own value maps to ("decimal", "upperRoman", "bullet", ...), or "none" for a level with no number sequence at all ([MS-DOC] 2.9.148's own nfc field text: "If this is equal to 0xFF..., this level does not have a number sequence"). */
+  readonly format: string;
+  /** The level's own text template: a placeholder pattern like '%1.' or '%2)' for a numbered format (the digit names which zero-based level's own counter substitutes at that position, one-based in the placeholder itself) -- the identical convention ooxml.js's own NumberingLevel.text carries verbatim from w:lvlText/@w:val -- or a literal bullet glyph string for format 'bullet'. Decoded from the level's own Xst (a raw UTF-16 string) plus its rgbxchNums array, which names which character POSITIONS in that string are placeholders rather than literal text -- see readLevelText below. */
+  readonly text: string;
+  /** iStartAt: the value this level's counter begins from. Meaningless (and not read as anything but 1) for a level with no number sequence. */
+  readonly startAt: number;
+  /** ilvlRestartLim ([MS-DOC] 2.9.148), only when fNoRestart is set: the first (most-significant) zero-based level after which this level's own number sequence does NOT restart. Absent (undefined) is the spec's own default behaviour -- "restarts when a more significant level is encountered" -- not "never restarts". */
+  readonly restart?: number;
+}
+interface NumberingDefinition {
+  /** Keyed by the level's own zero-based ilvl, stringified -- the identical zero-based numbering ContentListMembership.level already uses, so `definitions[membership.numId]?.levels[String(membership.level)]` is the direct lookup path from a paragraph's own membership to its rendering definition. A record rather than a fixed-length array/tuple: a simple (fSimpleList) LSTF states only level 0. */
+  readonly levels: Readonly<Record<string, NumberingLevel>>;
+}
+/** Keyed by a paragraph's own listId (ContentListMembership.numId, stringified) -- prop/pap.ts's own sprmPIlfo, a one-based index into PlfLfo.rgLfo. */
+type NumberingDefinitions = Readonly<Record<string, NumberingDefinition>>;
+/** Resolves PlfLst and PlfLfo into NumberingDefinitions, keyed by the one-based ilfo every listId already is (prop/pap.ts's own Math.abs(ilfo)) -- absent entirely when the file carries neither (fcPlfLst/fcPlfLfo both 0, a document with no lists at all, the common case this reader must not fail on). */
+declare function readNumberingDefinitions(table: Uint8Array, fib: Fib): NumberingDefinitions;
+//#endregion
+export { readNumberingDefinitions as i, NumberingDefinitions as n, NumberingLevel as r, NumberingDefinition as t };

package/dist/numbering-DF1z1PyG.d.ts

@@ -0,0 +1,22 @@
+import { t as Fib } from "./fib-CtsLtF96.js";
+//#region src/list/numbering.d.ts
+interface NumberingLevel {
+  /** The ST_NumberFormat-equivalent string MSONFC's own value maps to ("decimal", "upperRoman", "bullet", ...), or "none" for a level with no number sequence at all ([MS-DOC] 2.9.148's own nfc field text: "If this is equal to 0xFF..., this level does not have a number sequence"). */
+  readonly format: string;
+  /** The level's own text template: a placeholder pattern like '%1.' or '%2)' for a numbered format (the digit names which zero-based level's own counter substitutes at that position, one-based in the placeholder itself) -- the identical convention ooxml.js's own NumberingLevel.text carries verbatim from w:lvlText/@w:val -- or a literal bullet glyph string for format 'bullet'. Decoded from the level's own Xst (a raw UTF-16 string) plus its rgbxchNums array, which names which character POSITIONS in that string are placeholders rather than literal text -- see readLevelText below. */
+  readonly text: string;
+  /** iStartAt: the value this level's counter begins from. Meaningless (and not read as anything but 1) for a level with no number sequence. */
+  readonly startAt: number;
+  /** ilvlRestartLim ([MS-DOC] 2.9.148), only when fNoRestart is set: the first (most-significant) zero-based level after which this level's own number sequence does NOT restart. Absent (undefined) is the spec's own default behaviour -- "restarts when a more significant level is encountered" -- not "never restarts". */
+  readonly restart?: number;
+}
+interface NumberingDefinition {
+  /** Keyed by the level's own zero-based ilvl, stringified -- the identical zero-based numbering ContentListMembership.level already uses, so `definitions[membership.numId]?.levels[String(membership.level)]` is the direct lookup path from a paragraph's own membership to its rendering definition. A record rather than a fixed-length array/tuple: a simple (fSimpleList) LSTF states only level 0. */
+  readonly levels: Readonly<Record<string, NumberingLevel>>;
+}
+/** Keyed by a paragraph's own listId (ContentListMembership.numId, stringified) -- prop/pap.ts's own sprmPIlfo, a one-based index into PlfLfo.rgLfo. */
+type NumberingDefinitions = Readonly<Record<string, NumberingDefinition>>;
+/** Resolves PlfLst and PlfLfo into NumberingDefinitions, keyed by the one-based ilfo every listId already is (prop/pap.ts's own Math.abs(ilfo)) -- absent entirely when the file carries neither (fcPlfLst/fcPlfLfo both 0, a document with no lists at all, the common case this reader must not fail on). */
+declare function readNumberingDefinitions(table: Uint8Array, fib: Fib): NumberingDefinitions;
+//#endregion
+export { readNumberingDefinitions as i, NumberingDefinitions as n, NumberingLevel as r, NumberingDefinition as t };

package/dist/pap-BkFo8dZO.d.ts

@@ -0,0 +1,29 @@
+import { t as Prl } from "./sprm-Djg5RNiq.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;
+  /** sprmPItap's own table depth, present only when the sprm is; a value greater than 1 marks a table nested inside a table cell. */
+  tableDepth?: number;
+  /** True when sprmPFInnerTableCell or sprmPFInnerTtp is set -- a nested table's own cell/row-ending mark, carried purely as a refusal signal since this package's table support does not descend into a nested table. */
+  nestedTableMark?: boolean;
+}
+declare function applyParagraphSprms(prls: readonly Prl[], into: ParagraphProperties): ParagraphProperties;
+//#endregion
+export { applyParagraphSprms as n, ParagraphProperties as t };

package/dist/pap-BmelEYEP.d.cts

@@ -0,0 +1,29 @@
+import { t as Prl } from "./sprm-Djg5RNiq.cjs";
+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;
+  /** sprmPItap's own table depth, present only when the sprm is; a value greater than 1 marks a table nested inside a table cell. */
+  tableDepth?: number;
+  /** True when sprmPFInnerTableCell or sprmPFInnerTtp is set -- a nested table's own cell/row-ending mark, carried purely as a refusal signal since this package's table support does not descend into a nested table. */
+  nestedTableMark?: boolean;
+}
+declare function applyParagraphSprms(prls: readonly Prl[], into: ParagraphProperties): ParagraphProperties;
+//#endregion
+export { applyParagraphSprms as n, ParagraphProperties as t };

package/dist/prop/chp-write.cjs

@@ -0,0 +1,47 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_errors = require("../errors.cjs");
+const require_color = require("../color.cjs");
+//#region src/prop/chp-write.ts
+/** sprmCFBold, sprmCFItalic, sprmCFStrike: a 1-byte ToggleOperand, [MS-DOC] 2.9.336. 0x00 and 0x01 are the only values this writer emits -- 0x80/0x81 (inherit/invert relative to a style) have no meaning here, since this package writes no style sheet for a run's character properties to inherit from. */
+const SPRM_C_F_BOLD = 2101;
+const SPRM_C_F_ITALIC = 2102;
+const SPRM_C_F_STRIKE = 2103;
+/** sprmCKul: a 1-byte Kul value. 0x00 is "none"; 0x01 is kulSingle, the only underline style ContentRun.underline can express (a plain boolean, not a style enum). */
+const SPRM_C_KUL = 10814;
+const KUL_NONE = 0;
+const KUL_SINGLE = 1;
+/** sprmCHps: a 2-byte unsigned half-point size. */
+const SPRM_C_HPS = 19011;
+/** sprmCCv: a 4-byte COLORREF (r, g, b, fAuto). fAuto 0x00 means "use these components", the only form this writer emits. */
+const SPRM_C_CV = 26736;
+/** sprmCRgFtc0: a 2-byte signed index into the font table, [MS-DOC] 2.6.2 -- see style/fonts.ts. */
+const SPRM_C_RG_FTC_0 = 19023;
+const HALF_POINTS_PER_POINT = 2;
+/** sprmCHps's own operand range: an unsigned 2-byte half-point value. */
+const MAX_HPS = 65535;
+function pushSprm(bytes, opcode, operand) {
+	bytes.push(opcode & 255, opcode >> 8 & 255, ...operand);
+}
+function toggle(value) {
+	return [value ? 1 : 0];
+}
+function uint16(value) {
+	return [value & 255, value >> 8 & 255];
+}
+function encodeCharacterGrpprl(run, fontIndexOf) {
+	const bytes = [];
+	if (run.bold !== void 0) pushSprm(bytes, SPRM_C_F_BOLD, toggle(run.bold));
+	if (run.italic !== void 0) pushSprm(bytes, SPRM_C_F_ITALIC, toggle(run.italic));
+	if (run.strike !== void 0) pushSprm(bytes, SPRM_C_F_STRIKE, toggle(run.strike));
+	if (run.underline !== void 0) pushSprm(bytes, SPRM_C_KUL, [run.underline ? KUL_SINGLE : KUL_NONE]);
+	if (run.sizePt !== void 0) {
+		const halfPoints = Math.round(run.sizePt * HALF_POINTS_PER_POINT);
+		if (halfPoints < 0 || halfPoints > MAX_HPS) throw new require_errors.DocFormatError(`run sizePt ${run.sizePt} is ${halfPoints} half-points, outside the 0..${MAX_HPS} range sprmCHps's unsigned 2-byte operand can hold`);
+		pushSprm(bytes, SPRM_C_HPS, uint16(halfPoints));
+	}
+	if (run.color !== void 0) pushSprm(bytes, SPRM_C_CV, require_color.colorRefBytes(run.color));
+	if (run.fontFamily !== void 0) pushSprm(bytes, SPRM_C_RG_FTC_0, uint16(fontIndexOf(run.fontFamily)));
+	return bytes;
+}
+//#endregion
+exports.encodeCharacterGrpprl = encodeCharacterGrpprl;

package/dist/prop/chp-write.d.cts

@@ -0,0 +1,5 @@
+import { ContentRun } from "document-schema.js";
+//#region src/prop/chp-write.d.ts
+declare function encodeCharacterGrpprl(run: Pick<ContentRun, "bold" | "italic" | "underline" | "strike" | "sizePt" | "color" | "fontFamily">, fontIndexOf: (name: string) => number): number[];
+//#endregion
+export { encodeCharacterGrpprl };

package/dist/prop/chp-write.d.ts

@@ -0,0 +1,5 @@
+import { ContentRun } from "document-schema.js";
+//#region src/prop/chp-write.d.ts
+declare function encodeCharacterGrpprl(run: Pick<ContentRun, "bold" | "italic" | "underline" | "strike" | "sizePt" | "color" | "fontFamily">, fontIndexOf: (name: string) => number): number[];
+//#endregion
+export { encodeCharacterGrpprl };

package/dist/prop/chp-write.js

@@ -0,0 +1,46 @@
+import { DocFormatError } from "../errors.js";
+import { colorRefBytes } from "../color.js";
+//#region src/prop/chp-write.ts
+/** sprmCFBold, sprmCFItalic, sprmCFStrike: a 1-byte ToggleOperand, [MS-DOC] 2.9.336. 0x00 and 0x01 are the only values this writer emits -- 0x80/0x81 (inherit/invert relative to a style) have no meaning here, since this package writes no style sheet for a run's character properties to inherit from. */
+const SPRM_C_F_BOLD = 2101;
+const SPRM_C_F_ITALIC = 2102;
+const SPRM_C_F_STRIKE = 2103;
+/** sprmCKul: a 1-byte Kul value. 0x00 is "none"; 0x01 is kulSingle, the only underline style ContentRun.underline can express (a plain boolean, not a style enum). */
+const SPRM_C_KUL = 10814;
+const KUL_NONE = 0;
+const KUL_SINGLE = 1;
+/** sprmCHps: a 2-byte unsigned half-point size. */
+const SPRM_C_HPS = 19011;
+/** sprmCCv: a 4-byte COLORREF (r, g, b, fAuto). fAuto 0x00 means "use these components", the only form this writer emits. */
+const SPRM_C_CV = 26736;
+/** sprmCRgFtc0: a 2-byte signed index into the font table, [MS-DOC] 2.6.2 -- see style/fonts.ts. */
+const SPRM_C_RG_FTC_0 = 19023;
+const HALF_POINTS_PER_POINT = 2;
+/** sprmCHps's own operand range: an unsigned 2-byte half-point value. */
+const MAX_HPS = 65535;
+function pushSprm(bytes, opcode, operand) {
+	bytes.push(opcode & 255, opcode >> 8 & 255, ...operand);
+}
+function toggle(value) {
+	return [value ? 1 : 0];
+}
+function uint16(value) {
+	return [value & 255, value >> 8 & 255];
+}
+function encodeCharacterGrpprl(run, fontIndexOf) {
+	const bytes = [];
+	if (run.bold !== void 0) pushSprm(bytes, SPRM_C_F_BOLD, toggle(run.bold));
+	if (run.italic !== void 0) pushSprm(bytes, SPRM_C_F_ITALIC, toggle(run.italic));
+	if (run.strike !== void 0) pushSprm(bytes, SPRM_C_F_STRIKE, toggle(run.strike));
+	if (run.underline !== void 0) pushSprm(bytes, SPRM_C_KUL, [run.underline ? KUL_SINGLE : KUL_NONE]);
+	if (run.sizePt !== void 0) {
+		const halfPoints = Math.round(run.sizePt * HALF_POINTS_PER_POINT);
+		if (halfPoints < 0 || halfPoints > MAX_HPS) throw new DocFormatError(`run sizePt ${run.sizePt} is ${halfPoints} half-points, outside the 0..${MAX_HPS} range sprmCHps's unsigned 2-byte operand can hold`);
+		pushSprm(bytes, SPRM_C_HPS, uint16(halfPoints));
+	}
+	if (run.color !== void 0) pushSprm(bytes, SPRM_C_CV, colorRefBytes(run.color));
+	if (run.fontFamily !== void 0) pushSprm(bytes, SPRM_C_RG_FTC_0, uint16(fontIndexOf(run.fontFamily)));
+	return bytes;
+}
+//#endregion
+export { encodeCharacterGrpprl };

package/dist/prop/chp.cjs

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_errors = require("../errors.cjs");
 const require_bytes = require("../bytes.cjs");
+const require_color = require("../color.cjs");
 const require_prop_sprm = require("./sprm.cjs");
 //#region src/prop/chp.ts
 /** sprmCFBold: a ToggleOperand switching bold. */
@@ -15,100 +16,18 @@ const SPRM_C_KUL = 10814;
 const SPRM_C_HPS = 19011;
 /** sprmCIstd: the istd of a character style to apply. */
 const SPRM_C_ISTD = 18992;
-/** sprmCIco: an Ico value, an index into [MS-DOC] 2.9.126's fixed 17-entry palette. */
+/** sprmCIco: an Ico value, an index into [MS-DOC] 2.9.119's fixed 17-entry palette. */
 const SPRM_C_ICO = 10818;
 /** sprmCCv: a COLORREF, the richer colour sprm that supersedes sprmCIco where both appear. */
 const SPRM_C_CV = 26736;
+/** sprmCRgFtc0: a 2-byte signed index into the font table (SttbfFfn) naming the font used "only if the conditions for using [sprmCRgFtc1/sprmCRgFtc2/sprmCFtcBi] do not apply" -- the default (non-East-Asian, non-complex-script) font, which is the only one this package reads or writes. */
+const SPRM_C_RG_FTC_0 = 19023;
 /** ToggleOperand, [MS-DOC] 2.9.336. 0x80 and 0x81 are relative to the style's own value rather than absolute. */
 const TOGGLE_OFF = 0;
 const TOGGLE_ON = 1;
 const TOGGLE_INHERIT_FROM_STYLE = 128;
 const TOGGLE_INVERT_STYLE = 129;
 const HALF_POINTS_PER_POINT = 2;
-const COLOR_COMPONENT_MAX = 255;
-const ICO_PALETTE = [
-	void 0,
-	[
-		0,
-		0,
-		0
-	],
-	[
-		0,
-		0,
-		255
-	],
-	[
-		0,
-		255,
-		255
-	],
-	[
-		0,
-		255,
-		0
-	],
-	[
-		255,
-		0,
-		255
-	],
-	[
-		255,
-		0,
-		0
-	],
-	[
-		255,
-		255,
-		0
-	],
-	[
-		255,
-		255,
-		255
-	],
-	[
-		0,
-		0,
-		128
-	],
-	[
-		0,
-		128,
-		128
-	],
-	[
-		0,
-		128,
-		0
-	],
-	[
-		128,
-		0,
-		128
-	],
-	[
-		128,
-		0,
-		128
-	],
-	[
-		128,
-		128,
-		0
-	],
-	[
-		128,
-		128,
-		128
-	],
-	[
-		192,
-		192,
-		192
-	]
-];
 function toggle(operand, current) {
 	const value = require_bytes.readUint8(operand, 0);
 	switch (value) {
@@ -119,26 +38,7 @@ function toggle(operand, current) {
 		default: throw new require_errors.DocFormatError(`ToggleOperand value 0x${value.toString(16)} is none of the four [MS-DOC] 2.9.336 defines (0x00, 0x01, 0x80, 0x81)`);
 	}
 }
-function icoColor(value) {
-	if (value >= ICO_PALETTE.length) throw new require_errors.DocFormatError(`Ico value 0x${value.toString(16)} is not less than 0x11, the bound [MS-DOC] 2.9.126 places on the palette`);
-	const entry = ICO_PALETTE[value];
-	if (entry === void 0) return void 0;
-	const [r, g, b] = entry;
-	return {
-		r: r / COLOR_COMPONENT_MAX,
-		g: g / COLOR_COMPONENT_MAX,
-		b: b / COLOR_COMPONENT_MAX
-	};
-}
-function colorRefColor(operand) {
-	if (require_bytes.readUint8(operand, 3) !== 0) return void 0;
-	return {
-		r: require_bytes.readUint8(operand, 0) / COLOR_COMPONENT_MAX,
-		g: require_bytes.readUint8(operand, 1) / COLOR_COMPONENT_MAX,
-		b: require_bytes.readUint8(operand, 2) / COLOR_COMPONENT_MAX
-	};
-}
-function applyCharacterSprms(prls, into) {
+function applyCharacterSprms(prls, into, fonts) {
 	for (const prl of prls) {
 		if (prl.sprm.sgc !== require_prop_sprm.SGC.character) continue;
 		switch (prl.sprm.value) {
@@ -161,9 +61,17 @@ function applyCharacterSprms(prls, into) {
 				into.istd = require_bytes.readUint16LE(prl.operand, 0);
 				break;
 			case SPRM_C_ICO:
-				into.color = icoColor(require_bytes.readUint8(prl.operand, 0));
+				into.color = require_color.icoColor(require_bytes.readUint8(prl.operand, 0));
+				break;
+			case SPRM_C_CV:
+				into.color = require_color.readColorRef(prl.operand, 0);
+				break;
+			case SPRM_C_RG_FTC_0: {
+				const index = require_bytes.readInt16LE(prl.operand, 0);
+				const name = fonts?.[index];
+				if (name !== void 0) into.fontFamily = name;
 				break;
-			case SPRM_C_CV: into.color = colorRefColor(prl.operand);
+			}
 		}
 	}
 	return into;

package/dist/prop/chp.d.cts

@@ -1,4 +1,4 @@
-import { Prl } from "./sprm.cjs";
+import { t as Prl } from "../sprm-Djg5RNiq.cjs";
 import { Color } from "document-schema.js";
 //#region src/prop/chp.d.ts
 interface CharacterProperties {
@@ -8,9 +8,10 @@ interface CharacterProperties {
   strike?: boolean;
   sizePt?: number;
   color?: Color;
+  fontFamily?: string;
   /** The istd of a character style applied by sprmCIstd, carried so a caller can resolve the style's own name. */
   istd?: number;
 }
-declare function applyCharacterSprms(prls: readonly Prl[], into: CharacterProperties): CharacterProperties;
+declare function applyCharacterSprms(prls: readonly Prl[], into: CharacterProperties, fonts?: readonly string[]): CharacterProperties;
 //#endregion
 export { CharacterProperties, applyCharacterSprms };