@file-viewer/doc 2.1.22 → 2.1.24

package/README.en.md

@@ -28,7 +28,8 @@ The package also exports `parseMsDocToHtml`, `mountMsDoc`, `createMsDocViewer`,
 - OLE/CFB container parsing
 - WordDocument, 0Table/1Table, CLX, FKP, CHPX, PAPX, STSH, and font table parsing
 - Paragraph, character, table, image, OLE attachment, and basic field-code output
+- Embedded picture extraction via MS-DOC PICF / OfficeArt BLIP records (PNG, JPEG, DIB, TIFF), with EMF/WMF → SVG conversion for browser preview
 - Browser-native HTML/CSS rendering without server-side conversion
 - Optional module worker entry at `@file-viewer/doc/worker`
 
-This package intentionally tracks the old public `msdoc-viewer@0.2.0` code line. Newer private document-engine work is not used here.
+This package intentionally tracks the old public `msdoc-viewer@0.2.0` code line and continues to harden that public MS-DOC path. Newer private document-engine work is not used here.

package/README.md

@@ -27,7 +27,7 @@
 - 常见字符样式：粗体、斜体、下划线、删除线、字号、颜色、高亮、大小写、上下标、字体切换
 - 常见段落样式：对齐、缩进、段前后距、行距、分页控制、边框
 - 表格：`sprmTDefTable`、单元格宽度、横向/纵向合并、边框、垂直对齐、nowrap、fitText
-- 图片：PICF + Data 流提取
+- 图片：按 MS-DOC PICF / OfficeArt BLIP 规范提取内嵌 PNG、JPEG、DIB、TIFF，并支持 EMF/WMF 转 SVG 预览
 - OLE / ObjectPool 附件提取
 - 域代码的基础处理（例如超链接）
 - 浏览器 Viewer 与 Worker Client
@@ -39,6 +39,7 @@ src/
   core/
     binary.ts        # 二进制读取器
     cfb.ts           # CFB/OLE 容器解析
+    inflate.ts       # OfficeArt 压缩 metafile 的 zlib/deflate 解压
     utils.ts         # 字节、编码、范围等底层工具
   msdoc/
     fib.ts           # FIB 读取
@@ -48,7 +49,9 @@ src/
     properties.ts    # PAPX / CHPX / TAPX 到状态对象的归并
     styles.ts        # STSH / 样式继承
     fonts.ts         # 字体表
-    objects.ts       # 图片 / OLE / ObjectPool
+    officeart.ts     # OfficeArt 内联 shape / BLIP 辅助解析
+    objects.ts       # PICF / OfficeArt 图片与 OLE / ObjectPool
+    vector.ts        # EMF/WMF 转 SVG
     parser.ts        # 主解析流程，输出 AST
   render/
     html.ts          # AST -> HTML/CSS
@@ -251,10 +254,10 @@ npm run build
 MS-DOC 是历史包袱很重的二进制格式，虽然主链路已经完整重构，但以下场景仍建议用更多真实样本持续压测：
 
 - 极端复杂的嵌套表格
-- 旧版 OfficeArt / shape 对象
 - 非常规域代码组合
 - 少见的 OLE 嵌入形式
 - 某些兼容模式下的边角 sprm 变体
+- 仅保存外部路径、未嵌入字节的链接图片（会给出占位提示，无法在离线环境加载本地盘路径）
 
 这些场景并不影响当前的整体架构，后续继续扩展时可直接在现有 TS 类型体系上增量补强。
 

package/dist/core/inflate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Small RFC1950/zlib + RFC1951/DEFLATE inflater.
+ *
+ * OfficeArt stores EMF/WMF BLIPs behind OfficeArtMetafileHeader.compression=0x00
+ * using the zlib wrapper defined by RFC1950. Keeping this inflater dependency-free
+ * preserves the browser-only build while still allowing the synchronous MS-DOC
+ * parser to expose browser-displayable SVG assets.
+ */
+export declare function inflateZlib(bytes: Uint8Array, expectedLength?: number): Uint8Array | null;

package/dist/core/inflate.js

@@ -0,0 +1,317 @@
+/**
+ * Small RFC1950/zlib + RFC1951/DEFLATE inflater.
+ *
+ * OfficeArt stores EMF/WMF BLIPs behind OfficeArtMetafileHeader.compression=0x00
+ * using the zlib wrapper defined by RFC1950. Keeping this inflater dependency-free
+ * preserves the browser-only build while still allowing the synchronous MS-DOC
+ * parser to expose browser-displayable SVG assets.
+ */
+class InflateError extends Error {
+    name = 'InflateError';
+}
+class BitReader {
+    bytes;
+    byteOffset = 0;
+    bitBuffer = 0;
+    bitCount = 0;
+    constructor(bytes) {
+        this.bytes = bytes;
+    }
+    readBits(count) {
+        if (count < 0 || count > 24)
+            throw new InflateError('Invalid bit count');
+        while (this.bitCount < count) {
+            if (this.byteOffset >= this.bytes.length)
+                throw new InflateError('Unexpected end of deflate stream');
+            this.bitBuffer |= (this.bytes[this.byteOffset++] ?? 0) << this.bitCount;
+            this.bitCount += 8;
+        }
+        const mask = count === 0 ? 0 : (1 << count) - 1;
+        const value = this.bitBuffer & mask;
+        this.bitBuffer >>>= count;
+        this.bitCount -= count;
+        return value;
+    }
+    readBit() {
+        return this.readBits(1);
+    }
+    alignToByte() {
+        this.bitBuffer = 0;
+        this.bitCount = 0;
+    }
+    readByte() {
+        return this.readBits(8);
+    }
+}
+class ByteSink {
+    buffer;
+    length = 0;
+    constructor(initialCapacity = 32768) {
+        this.buffer = new Uint8Array(initialCapacity);
+    }
+    reserve(extra) {
+        const required = this.length + extra;
+        if (required <= this.buffer.length)
+            return;
+        let next = this.buffer.length;
+        while (next < required)
+            next *= 2;
+        const grown = new Uint8Array(next);
+        grown.set(this.buffer.subarray(0, this.length));
+        this.buffer = grown;
+    }
+    push(value) {
+        this.reserve(1);
+        this.buffer[this.length++] = value & 0xff;
+    }
+    pushBytes(bytes) {
+        this.reserve(bytes.length);
+        this.buffer.set(bytes, this.length);
+        this.length += bytes.length;
+    }
+    copyFromBack(distance, length) {
+        if (distance <= 0 || distance > this.length)
+            throw new InflateError('Invalid back-reference distance');
+        this.reserve(length);
+        for (let i = 0; i < length; i += 1) {
+            this.buffer[this.length] = this.buffer[this.length - distance] ?? 0;
+            this.length += 1;
+        }
+    }
+    toUint8Array(expectedLength) {
+        const out = this.buffer.slice(0, this.length);
+        if (expectedLength != null && expectedLength >= 0 && out.length !== expectedLength) {
+            // The OfficeArt header is advisory in some legacy files. Do not fail the
+            // parse because a producer rounded the saved size differently.
+            return out;
+        }
+        return out;
+    }
+}
+function buildHuffmanTable(lengths) {
+    const maxBits = Math.max(0, ...lengths);
+    if (maxBits === 0)
+        throw new InflateError('Empty Huffman table');
+    const blCount = new Array(maxBits + 1).fill(0);
+    for (const length of lengths) {
+        if (length < 0 || length > maxBits)
+            throw new InflateError('Invalid code length');
+        if (length)
+            blCount[length] += 1;
+    }
+    const nextCode = new Array(maxBits + 1).fill(0);
+    let code = 0;
+    for (let bits = 1; bits <= maxBits; bits += 1) {
+        code = (code + (blCount[bits - 1] ?? 0)) << 1;
+        nextCode[bits] = code;
+    }
+    const maps = Array.from({ length: maxBits + 1 }, () => new Map());
+    for (let symbol = 0; symbol < lengths.length; symbol += 1) {
+        const length = lengths[symbol] ?? 0;
+        if (!length)
+            continue;
+        const canonical = nextCode[length] ?? 0;
+        nextCode[length] = canonical + 1;
+        maps[length].set(canonical, symbol);
+    }
+    return { maps, maxBits };
+}
+function decodeSymbol(reader, table) {
+    let code = 0;
+    for (let length = 1; length <= table.maxBits; length += 1) {
+        code = (code << 1) | reader.readBit();
+        const hit = table.maps[length]?.get(code);
+        if (hit != null)
+            return hit;
+    }
+    throw new InflateError('Invalid Huffman code');
+}
+const LENGTH_BASE = [
+    3, 4, 5, 6, 7, 8, 9, 10,
+    11, 13, 15, 17, 19, 23, 27, 31,
+    35, 43, 51, 59, 67, 83, 99, 115,
+    131, 163, 195, 227, 258,
+];
+const LENGTH_EXTRA = [
+    0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 1, 2, 2, 2, 2,
+    3, 3, 3, 3, 4, 4, 4, 4,
+    5, 5, 5, 5, 0,
+];
+const DISTANCE_BASE = [
+    1, 2, 3, 4, 5, 7, 9, 13,
+    17, 25, 33, 49, 65, 97, 129, 193,
+    257, 385, 513, 769, 1025, 1537, 2049, 3073,
+    4097, 6145, 8193, 12289, 16385, 24577,
+];
+const DISTANCE_EXTRA = [
+    0, 0, 0, 0, 1, 1, 2, 2,
+    3, 3, 4, 4, 5, 5, 6, 6,
+    7, 7, 8, 8, 9, 9, 10, 10,
+    11, 11, 12, 12, 13, 13,
+];
+let fixedLiteralLengthTable = null;
+let fixedDistanceTable = null;
+function getFixedTables() {
+    if (!fixedLiteralLengthTable) {
+        const lengths = new Array(288).fill(0);
+        for (let i = 0; i <= 143; i += 1)
+            lengths[i] = 8;
+        for (let i = 144; i <= 255; i += 1)
+            lengths[i] = 9;
+        for (let i = 256; i <= 279; i += 1)
+            lengths[i] = 7;
+        for (let i = 280; i <= 287; i += 1)
+            lengths[i] = 8;
+        fixedLiteralLengthTable = buildHuffmanTable(lengths);
+        fixedDistanceTable = buildHuffmanTable(new Array(32).fill(5));
+    }
+    return { literalLength: fixedLiteralLengthTable, distance: fixedDistanceTable };
+}
+const CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+function readDynamicTables(reader) {
+    const hlit = reader.readBits(5) + 257;
+    const hdist = reader.readBits(5) + 1;
+    const hclen = reader.readBits(4) + 4;
+    const codeLengthLengths = new Array(19).fill(0);
+    for (let i = 0; i < hclen; i += 1) {
+        codeLengthLengths[CODE_LENGTH_ORDER[i]] = reader.readBits(3);
+    }
+    const codeLengthTable = buildHuffmanTable(codeLengthLengths);
+    const lengths = [];
+    while (lengths.length < hlit + hdist) {
+        const symbol = decodeSymbol(reader, codeLengthTable);
+        if (symbol <= 15) {
+            lengths.push(symbol);
+        }
+        else if (symbol === 16) {
+            if (!lengths.length)
+                throw new InflateError('Repeat code length without previous value');
+            const repeat = reader.readBits(2) + 3;
+            const previous = lengths[lengths.length - 1] ?? 0;
+            for (let i = 0; i < repeat; i += 1)
+                lengths.push(previous);
+        }
+        else if (symbol === 17) {
+            const repeat = reader.readBits(3) + 3;
+            for (let i = 0; i < repeat; i += 1)
+                lengths.push(0);
+        }
+        else if (symbol === 18) {
+            const repeat = reader.readBits(7) + 11;
+            for (let i = 0; i < repeat; i += 1)
+                lengths.push(0);
+        }
+        else {
+            throw new InflateError('Invalid code length symbol');
+        }
+    }
+    const literalLengths = lengths.slice(0, hlit);
+    const distanceLengths = lengths.slice(hlit, hlit + hdist);
+    if (!literalLengths[256])
+        throw new InflateError('Missing end-of-block code');
+    if (!distanceLengths.some(Boolean))
+        distanceLengths[0] = 1;
+    return {
+        literalLength: buildHuffmanTable(literalLengths),
+        distance: buildHuffmanTable(distanceLengths),
+    };
+}
+function inflateHuffmanBlock(reader, sink, literalLength, distance) {
+    for (;;) {
+        const symbol = decodeSymbol(reader, literalLength);
+        if (symbol < 256) {
+            sink.push(symbol);
+            continue;
+        }
+        if (symbol === 256)
+            return;
+        if (symbol < 257 || symbol > 285)
+            throw new InflateError('Invalid length symbol');
+        const lengthIndex = symbol - 257;
+        let length = LENGTH_BASE[lengthIndex] ?? 0;
+        const lengthExtra = LENGTH_EXTRA[lengthIndex] ?? 0;
+        if (lengthExtra)
+            length += reader.readBits(lengthExtra);
+        const distSymbol = decodeSymbol(reader, distance);
+        if (distSymbol < 0 || distSymbol >= DISTANCE_BASE.length)
+            throw new InflateError('Invalid distance symbol');
+        let dist = DISTANCE_BASE[distSymbol] ?? 0;
+        const distExtra = DISTANCE_EXTRA[distSymbol] ?? 0;
+        if (distExtra)
+            dist += reader.readBits(distExtra);
+        sink.copyFromBack(dist, length);
+    }
+}
+function inflateDeflate(deflateBytes, expectedLength) {
+    const reader = new BitReader(deflateBytes);
+    const sink = new ByteSink(expectedLength && expectedLength > 0 ? expectedLength : undefined);
+    let final = false;
+    while (!final) {
+        final = reader.readBit() === 1;
+        const type = reader.readBits(2);
+        if (type === 0) {
+            reader.alignToByte();
+            const len = reader.readByte() | (reader.readByte() << 8);
+            const nlen = reader.readByte() | (reader.readByte() << 8);
+            if (((len ^ 0xffff) & 0xffff) !== nlen)
+                throw new InflateError('Invalid stored block length');
+            const chunk = new Uint8Array(len);
+            for (let i = 0; i < len; i += 1)
+                chunk[i] = reader.readByte();
+            sink.pushBytes(chunk);
+        }
+        else if (type === 1) {
+            const fixed = getFixedTables();
+            inflateHuffmanBlock(reader, sink, fixed.literalLength, fixed.distance);
+        }
+        else if (type === 2) {
+            const dynamic = readDynamicTables(reader);
+            inflateHuffmanBlock(reader, sink, dynamic.literalLength, dynamic.distance);
+        }
+        else {
+            throw new InflateError('Reserved deflate block type');
+        }
+    }
+    return sink.toUint8Array(expectedLength);
+}
+function adler32(bytes) {
+    let a = 1;
+    let b = 0;
+    for (const byte of bytes) {
+        a = (a + byte) % 65521;
+        b = (b + a) % 65521;
+    }
+    return ((b << 16) | a) >>> 0;
+}
+export function inflateZlib(bytes, expectedLength) {
+    if (bytes.length < 6)
+        return null;
+    const cmf = bytes[0] ?? 0;
+    const flg = bytes[1] ?? 0;
+    if ((cmf & 0x0f) !== 8)
+        return null;
+    if ((cmf >>> 4) > 7)
+        return null;
+    if (((cmf << 8) + flg) % 31 !== 0)
+        return null;
+    if (flg & 0x20)
+        return null;
+    try {
+        const deflateBytes = bytes.subarray(2, Math.max(2, bytes.length - 4));
+        const inflated = inflateDeflate(deflateBytes, expectedLength);
+        const expectedAdler = ((bytes[bytes.length - 4] ?? 0) << 24)
+            | ((bytes[bytes.length - 3] ?? 0) << 16)
+            | ((bytes[bytes.length - 2] ?? 0) << 8)
+            | (bytes[bytes.length - 1] ?? 0);
+        if (expectedAdler >>> 0) {
+            const actual = adler32(inflated);
+            if (actual !== (expectedAdler >>> 0))
+                return null;
+        }
+        return inflated;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/msdoc/objects.d.ts

@@ -1,10 +1,30 @@
 import type { ImageAsset, MsDocParseOptions, ObjectPoolInfo, ParsedCFB } from '../types.js';
+export interface OfficeArtRecordHeader {
+    recVer: number;
+    recInstance: number;
+    recType: number;
+    recLen: number;
+    size: number;
+}
 export declare function detectImageSegment(bytes: Uint8Array): {
     mime: string;
     start: number;
     end: number;
 } | null;
+/**
+ * OfficeArt records all start with the common 8-byte OfficeArtRecordHeader.
+ * Parsing this explicitly lets us walk inline shape containers instead of guessing
+ * image payloads by magic bytes, which was the root cause of the broken image output.
+ */
+export declare function parseOfficeArtRecordHeader(bytes: Uint8Array, offset: number): OfficeArtRecordHeader | null;
+/**
+ * Resolves a picture character (U+0001 + sprmCPicLocation) to an HTML-friendly asset.
+ * The happy path is: PICF -> optional linked picture name -> OfficeArtInlineSpContainer
+ * -> OfficeArtBlip*. When no structured BLIP can be found we still fall back to a
+ * signature scan so slightly malformed files remain usable.
+ */
 export declare function extractPictureAsset(dataStreamBytes: Uint8Array, pictureOffset: number | null | undefined, options?: MsDocParseOptions): ImageAsset | null;
+export declare function extractFbseImageAsset(drawingBytes: Uint8Array, offset: number, header?: OfficeArtRecordHeader | null): ImageAsset | null;
 export declare function parseOle10Native(streamBytes: Uint8Array): {
     label: string;
     originalPath: string;