@file-viewer/doc 2.1.10

package/dist/core/cfb.js

@@ -0,0 +1,286 @@
+import { BinaryReader, toUint8Array } from './binary.js';
+import { pushWarning } from './utils.js';
+const CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+const FREESECT = 0xffffffff;
+const ENDOFCHAIN = 0xfffffffe;
+const FATSECT = 0xfffffffd;
+const DIFSECT = 0xfffffffc;
+const MAX_CHAIN_SECTORS = 1 << 20;
+const MINI_STREAM_CUTOFF = 4096;
+function isSpecialSectorId(sid) {
+    return sid === FREESECT || sid === ENDOFCHAIN || sid === FATSECT || sid === DIFSECT;
+}
+function readSectorAbsolute(bytes, sectorSize, sid) {
+    const start = 512 + sid * sectorSize;
+    const end = start + sectorSize;
+    if (start < 0 || start >= bytes.length) {
+        throw new Error(`Sector ${sid} is out of bounds`);
+    }
+    if (end <= bytes.length)
+        return bytes.subarray(start, end);
+    const sector = new Uint8Array(sectorSize);
+    sector.set(bytes.subarray(start));
+    return sector;
+}
+function collectChain(startSid, nextSectorFn, limit = MAX_CHAIN_SECTORS) {
+    const chain = [];
+    const seen = new Set();
+    let sid = startSid;
+    let guard = 0;
+    while (sid !== ENDOFCHAIN && sid !== FREESECT && sid >= 0) {
+        if (seen.has(sid))
+            throw new Error(`Detected sector loop at ${sid}`);
+        seen.add(sid);
+        chain.push(sid);
+        sid = nextSectorFn(sid);
+        guard += 1;
+        if (guard > limit)
+            throw new Error('Sector chain exceeds safe limit');
+    }
+    return chain;
+}
+function readChainBytes(bytes, sectorSize, startSid, fat, expectedSize = null) {
+    if (startSid === ENDOFCHAIN || startSid === FREESECT || startSid < 0) {
+        return new Uint8Array(0);
+    }
+    const chain = collectChain(startSid, (sid) => fat[sid] ?? ENDOFCHAIN);
+    const out = new Uint8Array(chain.length * sectorSize);
+    let offset = 0;
+    for (const sid of chain) {
+        out.set(readSectorAbsolute(bytes, sectorSize, sid), offset);
+        offset += sectorSize;
+    }
+    return expectedSize == null ? out : out.subarray(0, Math.min(expectedSize, out.length));
+}
+function parseDirectoryTree(entries) {
+    function walkSiblings(entryId, out) {
+        if (entryId < 0 || entryId >= entries.length)
+            return;
+        const entry = entries[entryId];
+        if (!entry)
+            return;
+        walkSiblings(entry.leftSiblingId, out);
+        out.push(entryId);
+        walkSiblings(entry.rightSiblingId, out);
+    }
+    function attachChildren(storageId) {
+        const storage = entries[storageId];
+        if (!storage || storage.childId < 0)
+            return;
+        const childIds = [];
+        walkSiblings(storage.childId, childIds);
+        storage.children = childIds;
+        for (const childId of childIds) {
+            const child = entries[childId];
+            if (!child)
+                continue;
+            child.parentId = storageId;
+            attachChildren(childId);
+        }
+    }
+    const root = entries.find((entry) => entry.objectType === 5);
+    if (!root)
+        throw new Error('CFB root storage not found');
+    attachChildren(root.id);
+    return root;
+}
+function buildPathMap(entries) {
+    const map = new Map();
+    for (const entry of entries) {
+        if (!entry || !entry.name)
+            continue;
+        const parts = [];
+        let current = entry;
+        while (current) {
+            if (current.objectType !== 5)
+                parts.push(current.name);
+            current = current.parentId != null ? entries[current.parentId] ?? null : null;
+        }
+        const path = `/${parts.reverse().join('/')}`;
+        entry.path = path === '/' ? `/${entry.name}` : path;
+        map.set(entry.path, entry);
+    }
+    return map;
+}
+function normalizeName(name) {
+    return name.replace(/\u0000+$/, '');
+}
+/**
+ * Parses the CFB/OLE container that wraps a legacy `.doc` file.
+ * The returned object exposes stream helpers so higher layers can focus on
+ * Word-specific structures instead of low-level sector navigation.
+ */
+export function parseCFB(input, _options = {}) {
+    const bytes = toUint8Array(input);
+    const reader = new BinaryReader(bytes);
+    const warnings = [];
+    for (let i = 0; i < CFB_SIGNATURE.length; i += 1) {
+        if (reader.u8(i) !== CFB_SIGNATURE[i]) {
+            throw new Error('Not a Compound File Binary document');
+        }
+    }
+    const majorVersion = reader.u16(26);
+    const sectorShift = reader.u16(30);
+    const miniSectorShift = reader.u16(32);
+    const sectorSize = 1 << sectorShift;
+    const miniSectorSize = 1 << miniSectorShift;
+    const numDirSectors = reader.u32(40);
+    const numFatSectors = reader.u32(44);
+    const firstDirSector = reader.i32(48);
+    const transactionSignature = reader.u32(52);
+    const miniStreamCutoffSize = reader.u32(56);
+    const firstMiniFatSector = reader.i32(60);
+    const numMiniFatSectors = reader.u32(64);
+    const firstDifatSector = reader.i32(68);
+    const numDifatSectors = reader.u32(72);
+    if (miniStreamCutoffSize !== MINI_STREAM_CUTOFF) {
+        pushWarning(warnings, `Unexpected mini stream cutoff size ${miniStreamCutoffSize}`);
+    }
+    const headerDifat = [];
+    for (let i = 0; i < 109; i += 1) {
+        const sid = reader.i32(76 + i * 4);
+        if (!isSpecialSectorId(sid) && sid >= 0)
+            headerDifat.push(sid);
+    }
+    const difat = [...headerDifat];
+    let difatSid = firstDifatSector;
+    let difatCount = 0;
+    while (difatSid !== ENDOFCHAIN && difatSid !== FREESECT && difatSid >= 0) {
+        const sector = readSectorAbsolute(bytes, sectorSize, difatSid);
+        const sectorReader = new BinaryReader(sector);
+        const entriesPerDifatSector = sectorSize / 4 - 1;
+        for (let i = 0; i < entriesPerDifatSector; i += 1) {
+            const sid = sectorReader.i32(i * 4);
+            if (!isSpecialSectorId(sid) && sid >= 0)
+                difat.push(sid);
+        }
+        difatSid = sectorReader.i32(sectorSize - 4);
+        difatCount += 1;
+        if (difatCount > numDifatSectors + 4) {
+            pushWarning(warnings, 'DIFAT chain exceeded declared sector count; stopping early');
+            break;
+        }
+    }
+    if (numFatSectors && difat.length < numFatSectors) {
+        pushWarning(warnings, `FAT sector count mismatch: header says ${numFatSectors}, found ${difat.length}`);
+    }
+    const fat = [];
+    for (const fatSid of difat) {
+        const fatSector = readSectorAbsolute(bytes, sectorSize, fatSid);
+        const fatReader = new BinaryReader(fatSector);
+        for (let i = 0; i < sectorSize / 4; i += 1) {
+            fat.push(fatReader.i32(i * 4));
+        }
+    }
+    const directoryBytes = readChainBytes(bytes, sectorSize, firstDirSector, fat);
+    const directoryReader = new BinaryReader(directoryBytes);
+    const entries = [];
+    for (let offset = 0, id = 0; offset + 128 <= directoryBytes.length; offset += 128, id += 1) {
+        const nameLength = directoryReader.u16(offset + 64);
+        const name = normalizeName(directoryReader.utf16le(offset, Math.max(0, nameLength - 2)));
+        if (!name && directoryReader.u8(offset + 66) === 0)
+            continue;
+        entries.push({
+            id,
+            name,
+            objectType: directoryReader.u8(offset + 66),
+            colorFlag: directoryReader.u8(offset + 67),
+            leftSiblingId: directoryReader.i32(offset + 68),
+            rightSiblingId: directoryReader.i32(offset + 72),
+            childId: directoryReader.i32(offset + 76),
+            clsid: directoryReader.slice(offset + 80, 16),
+            stateBits: directoryReader.u32(offset + 96),
+            creationTime: directoryReader.u64(offset + 100),
+            modifiedTime: directoryReader.u64(offset + 108),
+            startSector: directoryReader.i32(offset + 116),
+            streamSize: majorVersion === 3 ? directoryReader.u32(offset + 120) : directoryReader.u64(offset + 120),
+            children: [],
+            parentId: null,
+        });
+    }
+    const root = parseDirectoryTree(entries);
+    const pathMap = buildPathMap(entries);
+    const miniFat = [];
+    if (numMiniFatSectors && firstMiniFatSector >= 0) {
+        const miniFatBytes = readChainBytes(bytes, sectorSize, firstMiniFatSector, fat);
+        const miniFatReader = new BinaryReader(miniFatBytes);
+        for (let i = 0; i + 4 <= miniFatBytes.length; i += 4) {
+            miniFat.push(miniFatReader.i32(i));
+        }
+    }
+    const rootStreamBytes = readChainBytes(bytes, sectorSize, root.startSector, fat, root.streamSize);
+    function readMiniStream(entry) {
+        if (entry.startSector < 0)
+            return new Uint8Array(0);
+        const chain = collectChain(entry.startSector, (sid) => miniFat[sid] ?? ENDOFCHAIN);
+        const out = new Uint8Array(chain.length * miniSectorSize);
+        let offset = 0;
+        for (const miniSid of chain) {
+            const start = miniSid * miniSectorSize;
+            const end = start + miniSectorSize;
+            if (end > rootStreamBytes.length)
+                throw new Error(`Mini sector ${miniSid} is out of bounds`);
+            out.set(rootStreamBytes.subarray(start, end), offset);
+            offset += miniSectorSize;
+        }
+        return out.subarray(0, Math.min(entry.streamSize, out.length));
+    }
+    function getStream(identifier) {
+        const entry = typeof identifier === 'string' ? pathMap.get(identifier) ?? null : identifier;
+        if (!entry)
+            return null;
+        if (entry.objectType !== 2 && entry.objectType !== 5)
+            return null;
+        if (entry.objectType === 5)
+            return rootStreamBytes;
+        if (entry.streamSize < miniStreamCutoffSize && entry.startSector >= 0 && miniFat.length) {
+            return readMiniStream(entry);
+        }
+        return readChainBytes(bytes, sectorSize, entry.startSector, fat, entry.streamSize);
+    }
+    function listChildren(path) {
+        const entry = typeof path === 'string' ? pathMap.get(path) ?? null : path;
+        if (!entry)
+            return [];
+        return (entry.children || []).map((id) => entries[id]).filter((child) => Boolean(child));
+    }
+    return {
+        bytes,
+        majorVersion,
+        sectorSize,
+        miniSectorSize,
+        numDirSectors,
+        numFatSectors,
+        firstDirSector,
+        transactionSignature,
+        miniStreamCutoffSize,
+        warnings,
+        entries,
+        root,
+        pathMap,
+        getEntry(path) {
+            return pathMap.get(path) ?? null;
+        },
+        getStream,
+        listChildren,
+        findByName(name, startPath = '/') {
+            const start = startPath === '/' ? root : pathMap.get(startPath) ?? null;
+            if (!start)
+                return null;
+            const stack = [start];
+            while (stack.length) {
+                const entry = stack.pop();
+                if (!entry)
+                    continue;
+                if (entry.name === name)
+                    return entry;
+                for (const childId of entry.children || []) {
+                    const child = entries[childId];
+                    if (child)
+                        stack.push(child);
+                }
+            }
+            return null;
+        },
+    };
+}

package/dist/core/utils.d.ts

@@ -0,0 +1,19 @@
+import type { BinaryInput, CssStyleObject, MsDocWarning } from '../types.js';
+export declare function clamp(value: number, min: number, max: number): number;
+export declare function escapeHtml(text: unknown): string;
+export declare function uniqueId(prefix?: string): string;
+export declare function alignEven(value: number): number;
+export declare function bytesToHex(bytes: BinaryInput, max?: number): string;
+export declare function bytesToBase64(bytes: BinaryInput): string;
+export declare function dataUrlFromBytes(bytes: BinaryInput, mime?: string): string;
+export declare function slugify(text: unknown): string;
+export declare function shallowEqual<T extends Record<string, unknown>>(a: T | null | undefined, b: T | null | undefined): boolean;
+export declare function mergeObjects<T extends Record<string, unknown>>(...parts: Array<Partial<T> | null | undefined>): Partial<T>;
+export declare function mapObject<TInput, TOutput>(obj: Record<string, TInput> | null | undefined, mapper: (value: TInput, key: string) => TOutput): Record<string, TOutput>;
+export declare function pushWarning<TExtra extends Record<string, unknown> | undefined>(target: MsDocWarning[], message: string, extra?: TExtra): MsDocWarning;
+export declare function twipsToPx(twips: number | null | undefined, pxPerInch?: number): number | undefined;
+export declare function pointsToPx(points: number | null | undefined, pxPerInch?: number): number | undefined;
+export declare function cleanTextControlChars(text: unknown): string;
+export declare function groupConsecutive<T>(items: Iterable<T>, belongsTogether: (left: T, right: T) => boolean): T[][];
+export declare function textDecoder(label?: string): TextDecoder;
+export type { CssStyleObject };

package/dist/core/utils.js

@@ -0,0 +1,129 @@
+const globalBuffer = globalThis.Buffer;
+let uniqueIdCounter = 0;
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export function escapeHtml(text) {
+    return String(text)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+export function uniqueId(prefix = 'id') {
+    uniqueIdCounter += 1;
+    return `${prefix}-${uniqueIdCounter}`;
+}
+export function alignEven(value) {
+    return value % 2 === 0 ? value : value + 1;
+}
+function asUint8Array(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    if (input instanceof ArrayBuffer)
+        return new Uint8Array(input);
+    return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+}
+export function bytesToHex(bytes, max = 32) {
+    const slice = asUint8Array(bytes).subarray(0, max);
+    return Array.from(slice, (b) => b.toString(16).padStart(2, '0')).join(' ');
+}
+export function bytesToBase64(bytes) {
+    const view = bytes instanceof Uint8Array ? bytes : bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (globalBuffer) {
+        return globalBuffer.from(view).toString('base64');
+    }
+    let binary = '';
+    const chunk = 0x8000;
+    for (let i = 0; i < view.length; i += chunk) {
+        binary += String.fromCharCode(...view.subarray(i, Math.min(i + chunk, view.length)));
+    }
+    return btoa(binary);
+}
+export function dataUrlFromBytes(bytes, mime = 'application/octet-stream') {
+    return `data:${mime};base64,${bytesToBase64(bytes)}`;
+}
+export function slugify(text) {
+    return String(text ?? '')
+        .toLowerCase()
+        .replace(/[^a-z0-9\u4e00-\u9fa5]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'item';
+}
+export function shallowEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (a[key] !== b[key])
+            return false;
+    }
+    return true;
+}
+export function mergeObjects(...parts) {
+    const out = {};
+    for (const part of parts) {
+        if (!part || typeof part !== 'object')
+            continue;
+        for (const [key, value] of Object.entries(part)) {
+            if (value === undefined)
+                continue;
+            out[key] = value;
+        }
+    }
+    return out;
+}
+export function mapObject(obj, mapper) {
+    const out = {};
+    for (const [key, value] of Object.entries(obj ?? {})) {
+        out[key] = mapper(value, key);
+    }
+    return out;
+}
+export function pushWarning(target, message, extra) {
+    const warning = extra ? { message, ...extra } : { message };
+    target.push(warning);
+    return warning;
+}
+export function twipsToPx(twips, pxPerInch = 96) {
+    if (twips == null || Number.isNaN(twips))
+        return undefined;
+    return (twips / 1440) * pxPerInch;
+}
+export function pointsToPx(points, pxPerInch = 96) {
+    if (points == null || Number.isNaN(points))
+        return undefined;
+    return (points / 72) * pxPerInch;
+}
+export function cleanTextControlChars(text) {
+    return String(text ?? '')
+        .replace(/\u000b/g, '\n')
+        .replace(/\u000c/g, '\n');
+}
+export function groupConsecutive(items, belongsTogether) {
+    const groups = [];
+    let current = [];
+    for (const item of items) {
+        if (current.length === 0) {
+            current.push(item);
+            continue;
+        }
+        if (belongsTogether(current[current.length - 1], item)) {
+            current.push(item);
+            continue;
+        }
+        groups.push(current);
+        current = [item];
+    }
+    if (current.length)
+        groups.push(current);
+    return groups;
+}
+export function textDecoder(label = 'utf-8') {
+    return new TextDecoder(label, { fatal: false });
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { parseMsDoc } from './msdoc/parser.js';
+export { renderMsDoc, defaultMsDocCss } from './render/html.js';
+export { createMsDocViewer, mountMsDoc, parseMsDocToHtml } from './viewer.js';
+export { MsDocWorkerClient } from './worker-client.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { parseMsDoc } from './msdoc/parser.js';
+export { renderMsDoc, defaultMsDocCss } from './render/html.js';
+export { createMsDocViewer, mountMsDoc, parseMsDocToHtml } from './viewer.js';
+export { MsDocWorkerClient } from './worker-client.js';

package/dist/msdoc/clx.d.ts

@@ -0,0 +1,18 @@
+import type { FibRgFcLcb, ParsedClx, PieceDescriptor, PieceTable } from '../types.js';
+export declare function parseClx(tableBytes: Uint8Array, fibRgFcLcb: FibRgFcLcb): ParsedClx;
+export declare function parsePlcPcd(bytes: Uint8Array): PieceTable;
+export declare function extractDocumentText(wordBytes: Uint8Array, clx: ParsedClx): string;
+export declare function extractPieceText(wordBytes: Uint8Array, piece: PieceDescriptor): string;
+export declare function buildPieceTextCache(wordBytes: Uint8Array, clx: ParsedClx): string[];
+export declare function cpToFileOffset(clx: ParsedClx, cp: number): {
+    piece: PieceDescriptor;
+    offset: number;
+    compressed: boolean;
+} | null;
+export declare function fcToCp(clx: ParsedClx, fcRawOrActual: number, explicitCompressed?: boolean | null): number | null;
+export declare function getTextByCp(_wordBytes: Uint8Array, clx: ParsedClx, pieceTexts: string[], cpStart: number, cpEnd: number): string;
+export declare function splitParagraphRanges(documentText: string): Array<{
+    cpStart: number;
+    cpEnd: number;
+    terminator: string;
+}>;

package/dist/msdoc/clx.js

@@ -0,0 +1,172 @@
+import { BinaryReader } from '../core/binary.js';
+const REPLACEMENTS = {
+    '\x82': '\u201A', '\x83': '\u0192', '\x84': '\u201E', '\x85': '\u2026', '\x86': '\u2020', '\x87': '\u2021',
+    '\x88': '\u02C6', '\x89': '\u2030', '\x8A': '\u0160', '\x8B': '\u2039', '\x8C': '\u0152', '\x91': '\u2018',
+    '\x92': '\u2019', '\x93': '\u201C', '\x94': '\u201D', '\x95': '\u2022', '\x96': '\u2013', '\x97': '\u2014',
+    '\x98': '\u02DC', '\x99': '\u2122', '\x9A': '\u0161', '\x9B': '\u203A', '\x9C': '\u0153', '\x9F': '\u0178',
+};
+function fixCompressedText(str) {
+    return str.replace(/[\x82-\x8C\x91-\x9C\x9F]/g, (ch) => REPLACEMENTS[ch] || ch);
+}
+function decodeCompressed(bytes) {
+    let text = '';
+    for (let i = 0; i < bytes.length; i += 1)
+        text += String.fromCharCode(bytes[i] ?? 0);
+    return fixCompressedText(text);
+}
+function decodeUnicode(bytes) {
+    return new TextDecoder('utf-16le').decode(bytes);
+}
+export function parseClx(tableBytes, fibRgFcLcb) {
+    const fcClx = fibRgFcLcb.fcClx;
+    const lcbClx = fibRgFcLcb.lcbClx;
+    if (fcClx == null || lcbClx == null || lcbClx <= 0) {
+        throw new Error('FIB does not point to a CLX structure');
+    }
+    const clxBytes = tableBytes.subarray(fcClx, fcClx + lcbClx);
+    const reader = new BinaryReader(clxBytes);
+    let offset = 0;
+    const prcs = [];
+    while (offset < clxBytes.length && reader.u8(offset) === 0x01) {
+        const cbGrpprl = reader.u16(offset + 1);
+        prcs.push({ type: 1, cbGrpprl, bytes: reader.slice(offset + 3, cbGrpprl) });
+        offset += 3 + cbGrpprl;
+    }
+    if (reader.u8(offset) !== 0x02) {
+        throw new Error('CLX does not contain a Pcdt marker');
+    }
+    const lcb = reader.u32(offset + 1);
+    const plcPcdBytes = reader.slice(offset + 5, lcb);
+    const pieceTable = parsePlcPcd(plcPcdBytes);
+    return { prcs, pcdt: { lcb, pieceTable } };
+}
+export function parsePlcPcd(bytes) {
+    if (!bytes.length)
+        throw new Error('Empty PlcPcd');
+    const reader = new BinaryReader(bytes);
+    const pcdCount = (bytes.length - 4) / 12;
+    if (!Number.isInteger(pcdCount) || pcdCount < 0) {
+        throw new Error('Invalid PlcPcd size');
+    }
+    const cps = [];
+    for (let i = 0; i < pcdCount + 1; i += 1)
+        cps.push(reader.u32(i * 4));
+    const pieces = [];
+    let offset = (pcdCount + 1) * 4;
+    for (let i = 0; i < pcdCount; i += 1) {
+        const descriptor = reader.u16(offset);
+        const fcRaw = reader.u32(offset + 2) >>> 0;
+        const prm = reader.u16(offset + 6);
+        const compressed = Boolean(fcRaw & 0x40000000);
+        const fc = fcRaw & 0x3fffffff;
+        const cpStart = cps[i] ?? 0;
+        const cpEnd = cps[i + 1] ?? cpStart;
+        const actualByteStart = compressed ? Math.floor(fc / 2) : fc;
+        const byteLength = compressed ? (cpEnd - cpStart) : (cpEnd - cpStart) * 2;
+        pieces.push({
+            index: i,
+            descriptor,
+            fNoParaLast: Boolean(descriptor & 0x0001),
+            fRaw: Boolean(descriptor & 0x0002),
+            prm,
+            compressed,
+            fcRaw,
+            fc,
+            cpStart,
+            cpEnd,
+            actualByteStart,
+            byteLength,
+            actualByteEnd: actualByteStart + byteLength,
+        });
+        offset += 8;
+    }
+    return { cps, pieces };
+}
+export function extractDocumentText(wordBytes, clx) {
+    return clx.pcdt.pieceTable.pieces.map((piece) => extractPieceText(wordBytes, piece)).join('');
+}
+export function extractPieceText(wordBytes, piece) {
+    const bytes = wordBytes.subarray(piece.actualByteStart, piece.actualByteEnd);
+    return piece.compressed ? decodeCompressed(bytes) : decodeUnicode(bytes);
+}
+export function buildPieceTextCache(wordBytes, clx) {
+    return clx.pcdt.pieceTable.pieces.map((piece) => extractPieceText(wordBytes, piece));
+}
+export function cpToFileOffset(clx, cp) {
+    const pieces = clx.pcdt.pieceTable.pieces;
+    let lo = 0;
+    let hi = pieces.length - 1;
+    while (lo <= hi) {
+        const mid = (lo + hi) >> 1;
+        const piece = pieces[mid];
+        if (cp < piece.cpStart)
+            hi = mid - 1;
+        else if (cp >= piece.cpEnd)
+            lo = mid + 1;
+        else {
+            return {
+                piece,
+                offset: piece.actualByteStart + (cp - piece.cpStart) * (piece.compressed ? 1 : 2),
+                compressed: piece.compressed,
+            };
+        }
+    }
+    return null;
+}
+export function fcToCp(clx, fcRawOrActual, explicitCompressed = null) {
+    const pieces = clx.pcdt.pieceTable.pieces;
+    const hintedCompressed = explicitCompressed == null ? Boolean(fcRawOrActual & 0x40000000) : explicitCompressed;
+    const fc = explicitCompressed == null ? (fcRawOrActual & 0x3fffffff) : fcRawOrActual;
+    const actual = hintedCompressed ? Math.floor(fc / 2) : fc;
+    for (const piece of pieces) {
+        if (actual < piece.actualByteStart)
+            continue;
+        if (actual > piece.actualByteEnd)
+            continue;
+        const delta = actual - piece.actualByteStart;
+        const cp = piece.cpStart + Math.floor(delta / (piece.compressed ? 1 : 2));
+        if (cp >= piece.cpStart && cp <= piece.cpEnd)
+            return cp;
+    }
+    for (const piece of pieces) {
+        if (fcRawOrActual < piece.actualByteStart)
+            continue;
+        if (fcRawOrActual > piece.actualByteEnd)
+            continue;
+        const delta = fcRawOrActual - piece.actualByteStart;
+        const cp = piece.cpStart + Math.floor(delta / (piece.compressed ? 1 : 2));
+        if (cp >= piece.cpStart && cp <= piece.cpEnd)
+            return cp;
+    }
+    return null;
+}
+export function getTextByCp(_wordBytes, clx, pieceTexts, cpStart, cpEnd) {
+    if (cpEnd <= cpStart)
+        return '';
+    const out = [];
+    for (let i = 0; i < clx.pcdt.pieceTable.pieces.length; i += 1) {
+        const piece = clx.pcdt.pieceTable.pieces[i];
+        if (piece.cpEnd <= cpStart)
+            continue;
+        if (piece.cpStart >= cpEnd)
+            break;
+        const localStart = Math.max(cpStart, piece.cpStart) - piece.cpStart;
+        const localEnd = Math.min(cpEnd, piece.cpEnd) - piece.cpStart;
+        out.push((pieceTexts[i] ?? '').slice(localStart, localEnd));
+    }
+    return out.join('');
+}
+export function splitParagraphRanges(documentText) {
+    const ranges = [];
+    let start = 0;
+    for (let i = 0; i < documentText.length; i += 1) {
+        const ch = documentText[i];
+        if (ch === '\r' || ch === '\u0007') {
+            ranges.push({ cpStart: start, cpEnd: i + 1, terminator: ch });
+            start = i + 1;
+        }
+    }
+    if (start < documentText.length)
+        ranges.push({ cpStart: start, cpEnd: documentText.length, terminator: '' });
+    return ranges;
+}