@file-viewer/doc 2.1.10

package/dist/msdoc/constants.d.ts

@@ -0,0 +1,73 @@
+export declare const DOC_CONTROL: {
+    paragraph: string;
+    cellMark: string;
+    picture: string;
+    fieldStart: string;
+    fieldSeparator: string;
+    fieldEnd: string;
+    annotationRef: string;
+    hardLineBreak: string;
+    pageBreak: string;
+    nonBreakingHyphen: string;
+    nonRequiredHyphen: string;
+};
+export declare const UNDERLINE_MAP: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    9: string;
+    10: string;
+    11: string;
+    16: string;
+    17: string;
+    18: string;
+    19: string;
+    20: string;
+    21: string;
+    22: string;
+    23: string;
+};
+export declare const JC_MAP: {
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+};
+export declare const VERTICAL_ALIGN_MAP: {
+    0: string;
+    1: string;
+    2: string;
+};
+export declare const HIGHLIGHT_COLORS: {
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+    7: string;
+    8: string;
+    9: string;
+    10: string;
+    11: string;
+    12: string;
+    13: string;
+    14: string;
+    15: string;
+    16: string;
+};
+export declare const DEFAULT_FONT_FAMILIES: {
+    0: string;
+};
+export declare const FIELD_TYPES: {
+    HYPERLINK: string;
+    INCLUDEPICTURE: string;
+    EMBED: string;
+    LINK: string;
+};

package/dist/msdoc/constants.js

@@ -0,0 +1,73 @@
+export const DOC_CONTROL = {
+    paragraph: '\u000d',
+    cellMark: '\u0007',
+    picture: '\u0001',
+    fieldStart: '\u0013',
+    fieldSeparator: '\u0014',
+    fieldEnd: '\u0015',
+    annotationRef: '\u0005',
+    hardLineBreak: '\u000b',
+    pageBreak: '\u000c',
+    nonBreakingHyphen: '\u001e',
+    nonRequiredHyphen: '\u001f',
+};
+export const UNDERLINE_MAP = {
+    0: 'none',
+    1: 'single',
+    2: 'word',
+    3: 'double',
+    4: 'dotted',
+    5: 'hidden',
+    6: 'thick',
+    7: 'dash',
+    9: 'dot-dash',
+    10: 'dot-dot-dash',
+    11: 'wave',
+    16: 'dotted-heavy',
+    17: 'dashed-heavy',
+    18: 'dash-long',
+    19: 'dash-long-heavy',
+    20: 'dot-dash-heavy',
+    21: 'dot-dot-dash-heavy',
+    22: 'wavy-heavy',
+    23: 'wavy-double',
+};
+export const JC_MAP = {
+    0: 'left',
+    1: 'center',
+    2: 'right',
+    3: 'justify',
+    4: 'distributed',
+};
+export const VERTICAL_ALIGN_MAP = {
+    0: 'top',
+    1: 'center',
+    2: 'bottom',
+};
+export const HIGHLIGHT_COLORS = {
+    1: '#000000',
+    2: '#0000ff',
+    3: '#00ffff',
+    4: '#00ff00',
+    5: '#ff00ff',
+    6: '#ff0000',
+    7: '#ffff00',
+    8: '#ffffff',
+    9: '#000080',
+    10: '#008080',
+    11: '#008000',
+    12: '#800080',
+    13: '#800000',
+    14: '#808000',
+    15: '#808080',
+    16: '#c0c0c0',
+};
+export const DEFAULT_FONT_FAMILIES = {
+    0: 'serif',
+};
+export const FIELD_TYPES = {
+    HYPERLINK: 'hyperlink',
+    INCLUDEPICTURE: 'includePicture',
+    EMBED: 'embed',
+    LINK: 'link',
+};

package/dist/msdoc/fib.d.ts

@@ -0,0 +1,4 @@
+import { BinaryReader } from '../core/binary.js';
+import type { FibBase, ParsedFib } from '../types.js';
+export declare function parseFib(wordBytes: Uint8Array): ParsedFib;
+export declare function parseFibBase(reader: BinaryReader): FibBase;

package/dist/msdoc/fib.js

@@ -0,0 +1,125 @@
+import { BinaryReader } from '../core/binary.js';
+const FIB_FC_LCB_NAMES = [
+    'StshfOrig', 'Stshf', 'PlcffndRef', 'PlcffndTxt', 'PlcfandRef', 'PlcfandTxt',
+    'PlcfSed', 'PlcPad', 'PlcfPhe', 'SttbfGlsy', 'PlcfGlsy', 'PlcfHdd', 'PlcfBteChpx',
+    'PlcfBtePapx', 'PlcfSea', 'SttbfFfn', 'PlcfFldMom', 'PlcfFldHdr', 'PlcfFldFtn',
+    'PlcfFldAtn', 'PlcfFldMcr', 'SttbfBkmk', 'PlcfBkf', 'PlcfBkl', 'Cmds', 'Unused1',
+    'SttbfMcr', 'PrDrvr', 'PrEnvPort', 'PrEnvLand', 'Wss', 'Dop', 'SttbfAssoc', 'Clx',
+    'PlcfPgdFtn', 'AutosaveSource', 'GrpXstAtnOwners', 'SttbfAtnBkmk', 'Unused2',
+    'Unused3', 'PlcSpaMom', 'PlcSpaHdr', 'PlcfAtnBkf', 'PlcfAtnBkl', 'Pms',
+    'FormFldSttbs', 'PlcfendRef', 'PlcfendTxt', 'PlcfFldEdn', 'Unused4', 'DggInfo',
+    'SttbfRMark', 'SttbfCaption', 'SttbfAutoCaption', 'PlcfWkb', 'PlcfSpl',
+    'PlcftxbxTxt', 'PlcfFldTxbx', 'PlcfHdrtxbxTxt', 'PlcffldHdrTxbx', 'StwUser',
+    'SttbTtmbd', 'CookieData', 'PgdMotherOldOld', 'BkdMotherOldOld', 'PgdFtnOldOld',
+    'BkdFtnOldOld', 'PgdEdnOldOld', 'BkdEdnOldOld', 'SttbfIntlFld', 'RouteSlip',
+    'SttbSavedBy', 'SttbFnm', 'PlfLst', 'PlfLfo', 'PlcfTxbxBkd', 'PlcfTxbxHdrBkd',
+    'DocUndoWord9', 'RgbUse', 'Usp', 'Uskf', 'PlcupcRgbUse', 'PlcupcUsp', 'SttbGlsyStyle',
+    'Plgosl', 'Plcocx', 'PlcfBteLvc', 'dwLowDateTime', 'dwHighDateTime', 'PlcfLvcPre10',
+    'PlcfAsumy', 'PlcfGram', 'SttbListNames', 'SttbfUssr',
+];
+export function parseFib(wordBytes) {
+    const reader = new BinaryReader(wordBytes);
+    const base = parseFibBase(reader);
+    let offset = 32;
+    const csw = reader.u16(offset);
+    offset += 2;
+    const fibRgWBytes = reader.slice(offset, csw * 2);
+    offset += csw * 2;
+    const cslw = reader.u16(offset);
+    offset += 2;
+    const fibRgLwBytes = reader.slice(offset, cslw * 4);
+    offset += cslw * 4;
+    const cbRgFcLcb = reader.u16(offset);
+    offset += 2;
+    const fibRgFcLcbBytes = reader.slice(offset, cbRgFcLcb * 8);
+    offset += cbRgFcLcb * 8;
+    const cswNew = reader.ensure(offset, 2) ? reader.u16(offset) : 0;
+    if (reader.ensure(offset, 2))
+        offset += 2;
+    const fibRgCswNewBytes = cswNew ? reader.slice(offset, cswNew * 2) : new Uint8Array(0);
+    const fibRgLw = parseFibRgLw(fibRgLwBytes);
+    const fibRgFcLcb = parseFibRgFcLcb(fibRgFcLcbBytes, cbRgFcLcb);
+    const nFibNew = cswNew ? new BinaryReader(fibRgCswNewBytes).u16(0) : 0;
+    return {
+        base,
+        csw,
+        cslw,
+        cbRgFcLcb,
+        cswNew,
+        nFibNew,
+        fibRgWBytes,
+        fibRgLwBytes,
+        fibRgFcLcbBytes,
+        fibRgCswNewBytes,
+        fibRgLw,
+        fibRgFcLcb,
+    };
+}
+export function parseFibBase(reader) {
+    const wIdent = reader.u16(0);
+    const nFib = reader.u16(2);
+    const lid = reader.u16(6);
+    const pnNext = reader.u16(8);
+    const flags = reader.u16(10);
+    const envFlags = reader.u16(18);
+    return {
+        wIdent,
+        nFib,
+        lid,
+        pnNext,
+        flags,
+        envFlags,
+        fDot: Boolean(flags & 0x0001),
+        fGlsy: Boolean(flags & 0x0002),
+        fComplex: Boolean(flags & 0x0004),
+        fHasPic: Boolean(flags & 0x0008),
+        cQuickSaves: (flags >> 4) & 0x0f,
+        fEncrypted: Boolean(flags & 0x0100),
+        fWhichTblStm: Boolean(flags & 0x0200) ? 1 : 0,
+        fReadOnlyRecommended: Boolean(flags & 0x0400),
+        fWriteReservation: Boolean(flags & 0x0800),
+        fExtChar: Boolean(flags & 0x1000),
+        fLoadOverride: Boolean(flags & 0x2000),
+        fFarEast: Boolean(flags & 0x4000),
+        fObfuscated: Boolean(flags & 0x8000),
+        nFibBack: reader.u16(12),
+        lKey: reader.u32(14),
+        envr: reader.u8(18),
+        fMac: Boolean(envFlags & 0x0001),
+        fEmptySpecial: Boolean(envFlags & 0x0002),
+        fLoadOverridePage: Boolean(envFlags & 0x0004),
+    };
+}
+function parseFibRgLw(bytes) {
+    const reader = new BinaryReader(bytes);
+    const dwords = [];
+    for (let i = 0; i + 4 <= bytes.length; i += 4)
+        dwords.push(reader.i32(i));
+    return {
+        raw: dwords,
+        cbMac: dwords[0] ?? 0,
+        ccpText: dwords[3] ?? 0,
+        ccpFtn: dwords[4] ?? 0,
+        ccpHdd: dwords[5] ?? 0,
+        ccpMcr: dwords[6] ?? 0,
+        ccpAtn: dwords[7] ?? 0,
+        ccpEdn: dwords[8] ?? 0,
+        ccpTxbx: dwords[9] ?? 0,
+        ccpHdrTxbx: dwords[10] ?? 0,
+    };
+}
+function parseFibRgFcLcb(bytes, count) {
+    const reader = new BinaryReader(bytes);
+    const fields = { _pairs: [] };
+    const pairs = [];
+    for (let i = 0; i < count && i * 8 + 8 <= bytes.length; i += 1) {
+        const fc = reader.u32(i * 8);
+        const lcb = reader.u32(i * 8 + 4);
+        const name = FIB_FC_LCB_NAMES[i] || `Field${i}`;
+        fields[`fc${name}`] = fc;
+        fields[`lcb${name}`] = lcb;
+        pairs.push({ name, fc, lcb, index: i });
+    }
+    fields._pairs = pairs;
+    return fields;
+}

package/dist/msdoc/fkp.d.ts

@@ -0,0 +1,19 @@
+import type { DecodedProperty, ParsedClx, ParsedFib } from '../types.js';
+export interface ChpxRun {
+    cpStart: number;
+    cpEnd: number;
+    fcStart: number;
+    fcEnd: number;
+    properties: DecodedProperty[];
+}
+export interface PapxRun extends ChpxRun {
+    styleId: number;
+    rawOffset: number;
+}
+export declare function readChpxRuns(wordBytes: Uint8Array, tableBytes: Uint8Array, fib: ParsedFib, clx: ParsedClx): ChpxRun[];
+export declare function readPapxRuns(wordBytes: Uint8Array, tableBytes: Uint8Array, fib: ParsedFib, clx: ParsedClx, dataBytes?: Uint8Array): PapxRun[];
+export declare function readChpxProperties(wordBytes: Uint8Array, offset: number | null | undefined): DecodedProperty[];
+export declare function readPapxProperties(wordBytes: Uint8Array, offset: number | null | undefined, dataBytes?: Uint8Array): {
+    styleId: number;
+    properties: DecodedProperty[];
+};

package/dist/msdoc/fkp.js

@@ -0,0 +1,184 @@
+import { BinaryReader } from '../core/binary.js';
+import { decodeGrpprl, SprmCodes } from './sprm.js';
+import { fcToCp } from './clx.js';
+function u32(bytes, offset = 0) {
+    if (offset + 4 > bytes.length)
+        return 0;
+    return ((bytes[offset] ?? 0)
+        | ((bytes[offset + 1] ?? 0) << 8)
+        | ((bytes[offset + 2] ?? 0) << 16)
+        | (((bytes[offset + 3] ?? 0) << 24) >>> 0)) >>> 0;
+}
+function readPlcBte(tableBytes, fc, lcb) {
+    if (fc == null || lcb == null || lcb <= 0)
+        return { aFC: [], pages: [] };
+    const bytes = tableBytes.subarray(fc, fc + lcb);
+    const reader = new BinaryReader(bytes);
+    const count = Math.floor((lcb - 4) / 8);
+    if (count <= 0)
+        return { aFC: [], pages: [] };
+    const aFC = [];
+    for (let i = 0; i <= count; i += 1)
+        aFC.push(reader.u32(i * 4) >>> 0);
+    const pages = [];
+    const pnOffset = (count + 1) * 4;
+    for (let i = 0; i < count; i += 1)
+        pages.push(reader.u32(pnOffset + i * 4) & 0x3fffff);
+    return { aFC, pages };
+}
+function readChpxFkp(wordBytes, pn) {
+    const offset = pn * 512;
+    const page = wordBytes.subarray(offset, offset + 512);
+    if (page.length < 512)
+        return null;
+    const reader = new BinaryReader(page);
+    const crun = reader.u8(511);
+    if (!crun || crun > 100)
+        return null;
+    const rgfc = [];
+    for (let i = 0; i <= crun; i += 1)
+        rgfc.push(reader.u32(i * 4) >>> 0);
+    const rgb = [];
+    const chpxOffsets = [];
+    const rgbStart = (crun + 1) * 4;
+    for (let i = 0; i < crun; i += 1) {
+        const b = reader.u8(rgbStart + i);
+        rgb.push(b);
+        chpxOffsets.push(b ? offset + b * 2 : 0);
+    }
+    return { crun, rgfc, rgb, chpxOffsets };
+}
+function readPapxFkp(wordBytes, pn) {
+    const offset = pn * 512;
+    const page = wordBytes.subarray(offset, offset + 512);
+    if (page.length < 512)
+        return null;
+    const reader = new BinaryReader(page);
+    const cpara = reader.u8(511);
+    if (cpara > 0x1d)
+        return null;
+    const rgfc = [];
+    for (let i = 0; i <= cpara; i += 1)
+        rgfc.push(reader.u32(i * 4) >>> 0);
+    const bxStart = (cpara + 1) * 4;
+    const bOffsets = [];
+    const papxOffsets = [];
+    for (let i = 0; i < cpara; i += 1) {
+        const bOffset = reader.u8(bxStart + i * 13);
+        bOffsets.push(bOffset);
+        papxOffsets.push(bOffset ? offset + bOffset * 2 : 0);
+    }
+    return { cpara, rgfc, bOffsets, papxOffsets };
+}
+export function readChpxRuns(wordBytes, tableBytes, fib, clx) {
+    const fcPlcfBteChpx = fib.fibRgFcLcb.fcPlcfBteChpx;
+    const lcbPlcfBteChpx = fib.fibRgFcLcb.lcbPlcfBteChpx;
+    const plc = readPlcBte(tableBytes, fcPlcfBteChpx, lcbPlcfBteChpx);
+    const runs = [];
+    for (const pn of plc.pages) {
+        const fkp = readChpxFkp(wordBytes, pn);
+        if (!fkp)
+            continue;
+        for (let i = 0; i < fkp.crun; i += 1) {
+            const fcStart = fkp.rgfc[i] ?? 0;
+            const fcEnd = fkp.rgfc[i + 1] ?? fcStart;
+            const cpStart = fcToCp(clx, fcStart);
+            const cpEnd = fcToCp(clx, fcEnd);
+            if (cpStart == null || cpEnd == null || cpEnd <= cpStart)
+                continue;
+            const properties = fkp.chpxOffsets[i] ? readChpxProperties(wordBytes, fkp.chpxOffsets[i]) : [];
+            runs.push({ cpStart, cpEnd, fcStart, fcEnd, properties });
+        }
+    }
+    runs.sort((a, b) => a.cpStart - b.cpStart || a.cpEnd - b.cpEnd);
+    return runs;
+}
+export function readPapxRuns(wordBytes, tableBytes, fib, clx, dataBytes) {
+    const fcPlcfBtePapx = fib.fibRgFcLcb.fcPlcfBtePapx;
+    const lcbPlcfBtePapx = fib.fibRgFcLcb.lcbPlcfBtePapx;
+    const plc = readPlcBte(tableBytes, fcPlcfBtePapx, lcbPlcfBtePapx);
+    const runs = [];
+    for (const pn of plc.pages) {
+        const fkp = readPapxFkp(wordBytes, pn);
+        if (!fkp)
+            continue;
+        for (let i = 0; i < fkp.cpara; i += 1) {
+            const fcStart = fkp.rgfc[i] ?? 0;
+            const fcEnd = fkp.rgfc[i + 1] ?? fcStart;
+            const cpStart = fcToCp(clx, fcStart);
+            const cpEnd = fcToCp(clx, fcEnd);
+            if (cpStart == null || cpEnd == null || cpEnd < cpStart)
+                continue;
+            const papx = fkp.papxOffsets[i]
+                ? readPapxProperties(wordBytes, fkp.papxOffsets[i], dataBytes)
+                : { styleId: 0, properties: [] };
+            runs.push({ cpStart, cpEnd, fcStart, fcEnd, styleId: papx.styleId, properties: papx.properties, rawOffset: fkp.papxOffsets[i] ?? 0 });
+        }
+    }
+    runs.sort((a, b) => a.cpStart - b.cpStart || a.cpEnd - b.cpEnd);
+    return runs;
+}
+export function readChpxProperties(wordBytes, offset) {
+    if (offset == null || offset < 0 || offset >= wordBytes.length)
+        return [];
+    const cb = wordBytes[offset] ?? 0;
+    if (!cb)
+        return [];
+    const start = offset + 1;
+    const end = Math.min(wordBytes.length, start + cb);
+    return decodeGrpprl(wordBytes, start, end);
+}
+function readHugePapxProperties(dataBytes, offset) {
+    if (offset < 0 || offset + 2 > dataBytes.length)
+        return [];
+    const cb = (dataBytes[offset] ?? 0) | ((dataBytes[offset + 1] ?? 0) << 8);
+    if (!cb || offset + 2 + cb > dataBytes.length)
+        return [];
+    return decodeGrpprl(dataBytes, offset + 2, offset + 2 + cb);
+}
+function expandHugePapxProperties(properties, dataBytes) {
+    if (!dataBytes?.length)
+        return properties;
+    const expanded = [];
+    for (const property of properties) {
+        if (property.raw !== SprmCodes.sprmPHugePapx) {
+            expanded.push(property);
+            continue;
+        }
+        const operandBytes = property.operandBytes || (property.value instanceof Uint8Array ? property.value : null);
+        if (!operandBytes || operandBytes.length < 4) {
+            expanded.push(property);
+            continue;
+        }
+        const hugeOffset = u32(operandBytes);
+        const hugeProperties = readHugePapxProperties(dataBytes, hugeOffset);
+        expanded.push(...(hugeProperties.length ? hugeProperties : [property]));
+    }
+    return expanded;
+}
+export function readPapxProperties(wordBytes, offset, dataBytes) {
+    if (offset == null || offset < 0 || offset >= wordBytes.length)
+        return { styleId: 0, properties: [] };
+    const reader = new BinaryReader(wordBytes);
+    const cb = reader.u8(offset);
+    if (cb === 0 && !reader.ensure(offset + 1, 1))
+        return { styleId: 0, properties: [] };
+    let bodyStart;
+    let bodySize;
+    if (cb === 0) {
+        bodySize = reader.u8(offset + 1) * 2;
+        bodyStart = offset + 2;
+    }
+    else {
+        bodySize = cb - 1;
+        bodyStart = offset + 1;
+    }
+    if (bodySize < 2 || !reader.ensure(bodyStart, Math.max(2, bodySize))) {
+        return { styleId: 0, properties: [] };
+    }
+    const styleId = reader.u16(bodyStart);
+    const propsStart = bodyStart + 2;
+    const propsEnd = Math.min(wordBytes.length, bodyStart + bodySize);
+    const properties = expandHugePapxProperties(decodeGrpprl(wordBytes, propsStart, propsEnd), dataBytes);
+    return { styleId, properties };
+}

package/dist/msdoc/fonts.d.ts

@@ -0,0 +1,2 @@
+import type { FibRgFcLcb, FontsCollection } from '../types.js';
+export declare function parseFonts(tableBytes: Uint8Array, fibRgFcLcb: FibRgFcLcb): FontsCollection;

package/dist/msdoc/fonts.js

@@ -0,0 +1,87 @@
+import { BinaryReader } from '../core/binary.js';
+function decodeUtf16Z(bytes, offset) {
+    let end = offset;
+    while (end + 1 < bytes.length) {
+        if (bytes[end] === 0 && bytes[end + 1] === 0)
+            break;
+        end += 2;
+    }
+    const text = new TextDecoder('utf-16le').decode(bytes.subarray(offset, end));
+    return { value: text, nextOffset: Math.min(bytes.length, end + 2) };
+}
+function parseFfn(recordBytes, index) {
+    if (!recordBytes.length)
+        return null;
+    const reader = new BinaryReader(recordBytes);
+    const cbFfnM1 = reader.u8(0);
+    const ffid = reader.u8(1);
+    const wWeight = reader.u16(2);
+    const chs = reader.u8(4);
+    const ixchSzAlt = reader.u8(5);
+    const panose = reader.slice(6, 10);
+    const fontSignature = reader.slice(16, 24);
+    const namesOffset = 40;
+    let name = '';
+    let altName = '';
+    if (recordBytes.length > namesOffset) {
+        const full = new TextDecoder('utf-16le').decode(recordBytes.subarray(namesOffset));
+        const parts = full.split('\u0000').filter(Boolean);
+        name = parts[0] || '';
+        altName = parts[1] || '';
+        if (!altName && ixchSzAlt) {
+            const altOffset = namesOffset + ixchSzAlt * 2;
+            if (altOffset + 2 <= recordBytes.length) {
+                altName = decodeUtf16Z(recordBytes, altOffset).value;
+            }
+        }
+    }
+    return {
+        index,
+        cbFfnM1,
+        ffid,
+        weight: wWeight,
+        charset: chs,
+        ixchSzAlt,
+        panose,
+        fontSignature,
+        name,
+        altName,
+    };
+}
+export function parseFonts(tableBytes, fibRgFcLcb) {
+    const fcSttbfFfn = fibRgFcLcb.fcSttbfFfn;
+    const lcbSttbfFfn = fibRgFcLcb.lcbSttbfFfn;
+    if (fcSttbfFfn == null || lcbSttbfFfn == null || lcbSttbfFfn <= 0) {
+        return {
+            header: null,
+            fonts: [],
+            byIndex(index) {
+                return index == null ? null : null;
+            },
+        };
+    }
+    const bytes = tableBytes.subarray(fcSttbfFfn, fcSttbfFfn + lcbSttbfFfn);
+    const reader = new BinaryReader(bytes);
+    const cData = reader.u16(0);
+    const cbExtra = reader.u16(2);
+    let offset = 4;
+    const fonts = [];
+    for (let i = 0; i < cData && offset < bytes.length; i += 1) {
+        const cbFfnM1 = reader.u8(offset);
+        const recordLength = cbFfnM1 + 1;
+        const recordBytes = bytes.subarray(offset, Math.min(offset + recordLength, bytes.length));
+        const font = parseFfn(recordBytes, i);
+        if (font)
+            fonts.push(font);
+        offset += recordLength + cbExtra;
+    }
+    return {
+        header: { cData, cbExtra },
+        fonts,
+        byIndex(index) {
+            if (index == null || index < 0)
+                return null;
+            return fonts[index] || null;
+        },
+    };
+}

package/dist/msdoc/objects.d.ts

@@ -0,0 +1,15 @@
+import type { ImageAsset, MsDocParseOptions, ObjectPoolInfo, ParsedCFB } from '../types.js';
+export declare function detectImageSegment(bytes: Uint8Array): {
+    mime: string;
+    start: number;
+    end: number;
+} | null;
+export declare function extractPictureAsset(dataStreamBytes: Uint8Array, pictureOffset: number | null | undefined, options?: MsDocParseOptions): ImageAsset | null;
+export declare function parseOle10Native(streamBytes: Uint8Array): {
+    label: string;
+    originalPath: string;
+    tempPath: string;
+    dataSize: number;
+    bytes: Uint8Array;
+} | null;
+export declare function extractObjectPool(cfb: ParsedCFB): Map<string, ObjectPoolInfo>;