@mlightcad/data-model 1.10.7 → 1.11.1

package/lib/misc/AcDbOleImageExtractor.js

@@ -0,0 +1,659 @@
+/**
+ * Extracts a renderable image {@link Blob} from AutoCAD OLE frame binary
+ * payloads (OLE2FRAME / OLEFRAME).
+ *
+ * AutoCAD stores OLE 2 items as a short geometry header followed by an OLE
+ * Compound File Binary (CFB) document. Embedded pictures (for example
+ * "Paintbrush Picture") typically expose either:
+ * - a `CONTENTS` stream containing a full BMP / PNG / JPEG file, or
+ * - a `\2OlePres###` presentation stream with a CF_DIB / CF_BITMAP payload
+ *
+ * This extractor prefers CFB streams when present, then falls back to scanning
+ * the raw buffer for common image signatures and packed DIBs.
+ */
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var CFB_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+/** Standard clipboard format identifiers used in OLE presentation streams. */
+var CF_BITMAP = 2;
+var CF_DIB = 8;
+var DIRECTORY_ENTRY_SIZE = 128;
+var MAX_STREAM_BYTES = 64 * 1024 * 1024;
+/**
+ * Attempts to extract an image blob from OLE binary data.
+ *
+ * @param data - Raw OLE payload from {@link AcDbOleFrame.getOleObject}.
+ * @returns A browser-decodable image blob, or `undefined` when no image is found.
+ */
+export function acdbExtractOleImageBlob(data) {
+    if (!(data === null || data === void 0 ? void 0 : data.length)) {
+        return undefined;
+    }
+    var fromCfb = extractImageFromCfb(data);
+    if (fromCfb) {
+        return fromCfb;
+    }
+    return extractImageFromRawBytes(data);
+}
+/**
+ * Locates an embedded CFB document inside `data` and tries to pull an image
+ * from preferred streams (`CONTENTS`, `Ole10Native`, OlePres, …), then from
+ * every remaining stream as a last resort.
+ *
+ * @param data - Full OLE payload that may contain a CFB compound file.
+ * @returns An image blob when one is found, otherwise `undefined`.
+ */
+function extractImageFromCfb(data) {
+    var e_1, _a, e_2, _b, e_3, _c;
+    var cfbOffset = findSignature(data, CFB_SIGNATURE);
+    if (cfbOffset < 0) {
+        return undefined;
+    }
+    var cfb = data.subarray(cfbOffset);
+    var file;
+    try {
+        file = openCfb(cfb);
+    }
+    catch (_d) {
+        return undefined;
+    }
+    var preferredNames = [
+        'CONTENTS',
+        'Package',
+        'Ole10Native',
+        '\x01Ole10Native'
+    ];
+    try {
+        for (var preferredNames_1 = __values(preferredNames), preferredNames_1_1 = preferredNames_1.next(); !preferredNames_1_1.done; preferredNames_1_1 = preferredNames_1.next()) {
+            var name_1 = preferredNames_1_1.value;
+            var stream = file.readStream(name_1);
+            if (!(stream === null || stream === void 0 ? void 0 : stream.length))
+                continue;
+            var blob = extractImageFromRawBytes(stream);
+            if (blob)
+                return blob;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (preferredNames_1_1 && !preferredNames_1_1.done && (_a = preferredNames_1.return)) _a.call(preferredNames_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var _e = __values(file.entries()), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var entry = _f.value;
+            if (entry.type !== 'stream')
+                continue;
+            if (!/olepres/i.test(entry.name) && !entry.name.includes('OlePres')) {
+                continue;
+            }
+            var stream = file.readStream(entry.name);
+            if (!(stream === null || stream === void 0 ? void 0 : stream.length))
+                continue;
+            var fromPres = extractImageFromOlePresentation(stream);
+            if (fromPres)
+                return fromPres;
+            var fromRaw = extractImageFromRawBytes(stream);
+            if (fromRaw)
+                return fromRaw;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    try {
+        // Last resort: scan every stream for embedded image bytes.
+        for (var _g = __values(file.entries()), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var entry = _h.value;
+            if (entry.type !== 'stream')
+                continue;
+            var stream = file.readStream(entry.name);
+            if (!(stream === null || stream === void 0 ? void 0 : stream.length))
+                continue;
+            var blob = extractImageFromRawBytes(stream);
+            if (blob)
+                return blob;
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return undefined;
+}
+/**
+ * Parses an OLE presentation stream (`\2OlePres000`, …) and extracts a DIB /
+ * bitmap when the clipboard format is CF_DIB or CF_BITMAP.
+ *
+ * @param stream - Bytes of a `\2OlePres###` (or similarly named) stream.
+ * @returns A BMP image blob for CF_DIB / CF_BITMAP payloads, or `undefined`.
+ *
+ * @see https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-oleds/78ab0f5c-ad1b-41b4-bb5e-1eea2cd13a6c
+ */
+function extractImageFromOlePresentation(stream) {
+    if (stream.length < 28) {
+        return undefined;
+    }
+    var view = new DataView(stream.buffer, stream.byteOffset, stream.byteLength);
+    var offset = 0;
+    var markerOrLength = view.getUint32(offset, true);
+    offset += 4;
+    var clipboardFormat = 0;
+    if (markerOrLength === 0xffffffff) {
+        clipboardFormat = view.getUint32(offset, true);
+        offset += 4;
+    }
+    else if (markerOrLength === 0xfffffffe) {
+        // Unicode clipboard format name — skip string and try raw scan later.
+        return undefined;
+    }
+    else if (markerOrLength > 0 && markerOrLength < 0xffff) {
+        // ANSI clipboard format name
+        offset += markerOrLength;
+    }
+    else {
+        return undefined;
+    }
+    // TargetDevice.Size
+    if (offset + 4 > stream.length)
+        return undefined;
+    var targetDeviceSize = view.getUint32(offset, true);
+    offset += 4;
+    if (targetDeviceSize > 4) {
+        offset += targetDeviceSize - 4;
+    }
+    // Aspect, lindex, advf, reserved1, width, height
+    offset += 4 * 6;
+    if (offset + 4 > stream.length)
+        return undefined;
+    var dataSize = view.getUint32(offset, true);
+    offset += 4;
+    if (dataSize <= 0 || offset + dataSize > stream.length) {
+        return undefined;
+    }
+    var presentationData = stream.subarray(offset, offset + dataSize);
+    if (clipboardFormat === CF_DIB) {
+        return dibToBmpBlob(presentationData);
+    }
+    if (clipboardFormat === CF_BITMAP) {
+        return extractImageFromRawBytes(presentationData);
+    }
+    return extractImageFromRawBytes(presentationData);
+}
+/**
+ * Scans a byte buffer for common image file signatures (BMP, PNG, JPEG, GIF)
+ * and packed DIB structures.
+ *
+ * @param data - Arbitrary bytes that may contain an embedded image.
+ * @returns The first recognized image blob, or `undefined` if none is found.
+ */
+function extractImageFromRawBytes(data) {
+    var bmp = findBmpBlob(data);
+    if (bmp)
+        return bmp;
+    var png = findPngBlob(data);
+    if (png)
+        return png;
+    var jpeg = findJpegBlob(data);
+    if (jpeg)
+        return jpeg;
+    var gif = findGifBlob(data);
+    if (gif)
+        return gif;
+    var dib = findPackedDibBlob(data);
+    if (dib)
+        return dib;
+    return undefined;
+}
+/**
+ * Finds a Windows BMP file (`BM` magic) inside `data` and returns it as a blob.
+ *
+ * @param data - Buffer to search for a BITMAPFILEHEADER.
+ * @returns An `image/bmp` blob when a valid BMP is found, otherwise `undefined`.
+ */
+function findBmpBlob(data) {
+    for (var i = 0; i < data.length - 14; i++) {
+        if (data[i] !== 0x42 || data[i + 1] !== 0x4d)
+            continue;
+        var view = new DataView(data.buffer, data.byteOffset + i, data.length - i);
+        var fileSize = view.getUint32(2, true);
+        if (fileSize < 14 || fileSize > data.length - i)
+            continue;
+        var dibOffset = view.getUint32(10, true);
+        if (dibOffset < 14 || dibOffset >= fileSize)
+            continue;
+        return new Blob([data.subarray(i, i + fileSize)], { type: 'image/bmp' });
+    }
+    return undefined;
+}
+/**
+ * Finds a PNG file inside `data`, preferably bounded by an `IEND` chunk.
+ *
+ * @param data - Buffer to search for a PNG signature.
+ * @returns An `image/png` blob when found, otherwise `undefined`.
+ */
+function findPngBlob(data) {
+    var sig = [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a];
+    var start = findSignature(data, sig);
+    if (start < 0)
+        return undefined;
+    // Scan for IEND chunk to bound the PNG.
+    for (var i = start + 8; i + 12 <= data.length; i++) {
+        if (data[i + 4] === 0x49 &&
+            data[i + 5] === 0x45 &&
+            data[i + 6] === 0x4e &&
+            data[i + 7] === 0x44) {
+            var end = i + 12;
+            return new Blob([data.subarray(start, end)], { type: 'image/png' });
+        }
+    }
+    return new Blob([data.subarray(start)], { type: 'image/png' });
+}
+/**
+ * Finds a JPEG file inside `data` by locating SOI (`FF D8 FF`) and EOI
+ * (`FF D9`) markers.
+ *
+ * @param data - Buffer to search for JPEG markers.
+ * @returns An `image/jpeg` blob when a complete JPEG is found, otherwise
+ *   `undefined`.
+ */
+function findJpegBlob(data) {
+    var start = findSignature(data, [0xff, 0xd8, 0xff]);
+    if (start < 0)
+        return undefined;
+    for (var i = start + 3; i + 1 < data.length; i++) {
+        if (data[i] === 0xff && data[i + 1] === 0xd9) {
+            return new Blob([data.subarray(start, i + 2)], { type: 'image/jpeg' });
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds a GIF87a / GIF89a file inside `data`, preferably bounded by a trailer
+ * byte (`0x3B`).
+ *
+ * @param data - Buffer to search for a GIF signature.
+ * @returns An `image/gif` blob when found, otherwise `undefined`.
+ */
+function findGifBlob(data) {
+    var start87 = findSignature(data, [0x47, 0x49, 0x46, 0x38, 0x37, 0x61]);
+    var start89 = findSignature(data, [0x47, 0x49, 0x46, 0x38, 0x39, 0x61]);
+    var start = start87 >= 0 ? start87 : start89;
+    if (start < 0)
+        return undefined;
+    for (var i = start + 6; i < data.length; i++) {
+        if (data[i] === 0x3b) {
+            return new Blob([data.subarray(start, i + 1)], { type: 'image/gif' });
+        }
+    }
+    return new Blob([data.subarray(start)], { type: 'image/gif' });
+}
+/**
+ * Locates a packed DIB (BITMAPINFOHEADER with `biSize === 40`) and wraps it as
+ * a BMP file by prepending a BITMAPFILEHEADER.
+ *
+ * @param data - Buffer that may contain a packed device-independent bitmap.
+ * @returns An `image/bmp` blob when a plausible DIB is found, otherwise
+ *   `undefined`.
+ */
+function findPackedDibBlob(data) {
+    for (var i = 0; i + 40 <= data.length; i++) {
+        var view = new DataView(data.buffer, data.byteOffset + i, data.length - i);
+        var biSize = view.getUint32(0, true);
+        if (biSize !== 40)
+            continue;
+        var width = view.getInt32(4, true);
+        var height = view.getInt32(8, true);
+        var planes = view.getUint16(12, true);
+        var bitCount = view.getUint16(14, true);
+        var compression = view.getUint32(16, true);
+        var sizeImage = view.getUint32(20, true);
+        var clrUsed = view.getUint32(32, true);
+        if (width <= 0 || width > 65536)
+            continue;
+        if (height === 0 || Math.abs(height) > 65536)
+            continue;
+        if (planes !== 1)
+            continue;
+        if (![1, 4, 8, 16, 24, 32].includes(bitCount))
+            continue;
+        // BI_RGB / BI_BITFIELDS only
+        if (compression !== 0 && compression !== 3)
+            continue;
+        var pixelOffset = getPackedDibPixelOffset(biSize, bitCount, compression, clrUsed);
+        var absHeight = Math.abs(height);
+        var rowSize = ((width * bitCount + 31) >> 5) << 2;
+        var expectedPixels = sizeImage > 0 ? sizeImage : rowSize * absHeight;
+        var totalSize = pixelOffset + expectedPixels;
+        if (totalSize <= 40 || i + totalSize > data.length)
+            continue;
+        return dibToBmpBlob(data.subarray(i, i + totalSize));
+    }
+    return undefined;
+}
+/**
+ * Computes the byte offset from the start of a packed BITMAPINFOHEADER DIB to
+ * the first pixel byte, accounting for color tables and BI_BITFIELDS masks.
+ *
+ * @param biSize - Size of the bitmap info header (typically 40).
+ * @param bitCount - Bits per pixel.
+ * @param compression - Compression type (`0` = BI_RGB, `3` = BI_BITFIELDS).
+ * @param clrUsed - Number of color-table entries, or `0` for the default.
+ * @returns Offset in bytes from the DIB start to pixel data.
+ */
+function getPackedDibPixelOffset(biSize, bitCount, compression, clrUsed) {
+    var extra = 0;
+    if (bitCount > 8 && compression === 3) {
+        extra += 12;
+    }
+    if (clrUsed > 0) {
+        extra += clrUsed * 4;
+    }
+    else if (bitCount <= 8) {
+        extra += (1 << bitCount) * 4;
+    }
+    return biSize + extra;
+}
+/**
+ * Wraps packed DIB bytes as a Windows BMP by prepending a 14-byte
+ * BITMAPFILEHEADER.
+ *
+ * @param dib - Packed DIB starting with BITMAPINFOHEADER / BITMAPCOREHEADER.
+ * @returns An `image/bmp` blob, or `undefined` when the header is invalid.
+ */
+function dibToBmpBlob(dib) {
+    if (dib.length < 40)
+        return undefined;
+    var view = new DataView(dib.buffer, dib.byteOffset, dib.byteLength);
+    var biSize = view.getUint32(0, true);
+    if (biSize !== 40 && biSize !== 12)
+        return undefined;
+    var fileSize = 14 + dib.length;
+    var header = new Uint8Array(14);
+    var headerView = new DataView(header.buffer);
+    header[0] = 0x42; // 'B'
+    header[1] = 0x4d; // 'M'
+    headerView.setUint32(2, fileSize, true);
+    headerView.setUint32(10, 14 + getPixelDataOffsetFromDib(dib), true);
+    var combined = new Uint8Array(fileSize);
+    combined.set(header, 0);
+    combined.set(dib, 14);
+    return new Blob([combined], { type: 'image/bmp' });
+}
+/**
+ * Returns the offset from the start of a DIB to its pixel array, for use as
+ * `bfOffBits` after a 14-byte BITMAPFILEHEADER is prepended.
+ *
+ * @param dib - Packed DIB starting with BITMAPINFOHEADER or BITMAPCOREHEADER.
+ * @returns Pixel-data offset relative to the DIB start (not including the
+ *   file header).
+ */
+function getPixelDataOffsetFromDib(dib) {
+    var view = new DataView(dib.buffer, dib.byteOffset, dib.byteLength);
+    var biSize = view.getUint32(0, true);
+    if (biSize === 12) {
+        var bitCount_1 = view.getUint16(10, true);
+        var colors = bitCount_1 <= 8 ? 1 << bitCount_1 : 0;
+        return biSize + colors * 3;
+    }
+    var bitCount = view.getUint16(14, true);
+    var compression = view.getUint32(16, true);
+    var clrUsed = view.getUint32(32, true);
+    return getPackedDibPixelOffset(biSize, bitCount, compression, clrUsed);
+}
+/**
+ * Searches `data` for the first occurrence of `signature`.
+ *
+ * @param data - Buffer to search.
+ * @param signature - Byte sequence to locate.
+ * @returns Index of the first match, or `-1` if not found.
+ */
+function findSignature(data, signature) {
+    outer: for (var i = 0; i <= data.length - signature.length; i++) {
+        for (var j = 0; j < signature.length; j++) {
+            if (data[i + j] !== signature[j])
+                continue outer;
+        }
+        return i;
+    }
+    return -1;
+}
+/**
+ * Opens a Compound File Binary (OLE2) document and exposes directory entries
+ * plus named stream reads.
+ *
+ * @param data - Bytes starting at a valid CFB signature.
+ * @returns A lightweight CFB reader for stream extraction.
+ * @throws If the buffer is too small, not a CFB, or has an unsupported sector
+ *   size.
+ */
+function openCfb(data) {
+    if (data.length < 512) {
+        throw new Error('CFB too small');
+    }
+    for (var i = 0; i < CFB_SIGNATURE.length; i++) {
+        if (data[i] !== CFB_SIGNATURE[i]) {
+            throw new Error('Not a CFB document');
+        }
+    }
+    var view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    var sectorShift = view.getUint16(30, true);
+    var sectorSize = 1 << sectorShift;
+    if (sectorSize !== 512 && sectorSize !== 4096) {
+        throw new Error('Unsupported CFB sector size');
+    }
+    var fatCount = view.getUint32(44, true);
+    var firstDirSector = view.getUint32(48, true);
+    var miniStreamCutoff = view.getUint32(56, true);
+    var firstMiniFatSector = view.getUint32(60, true);
+    var miniFatCount = view.getUint32(64, true);
+    var firstDifatSector = view.getUint32(68, true);
+    var difatCount = view.getUint32(72, true);
+    var difat = [];
+    for (var i = 0; i < 109; i++) {
+        var sector = view.getUint32(76 + i * 4, true);
+        if (sector <= 0xfffffffa) {
+            difat.push(sector);
+        }
+    }
+    var difatSector = firstDifatSector;
+    for (var n = 0; n < difatCount && difatSector <= 0xfffffffa; n++) {
+        var offset = (difatSector + 1) * sectorSize;
+        if (offset + sectorSize > data.length)
+            break;
+        var entriesPerSector = sectorSize / 4 - 1;
+        for (var i = 0; i < entriesPerSector; i++) {
+            var sector = view.getUint32(offset + i * 4, true);
+            if (sector <= 0xfffffffa) {
+                difat.push(sector);
+            }
+        }
+        difatSector = view.getUint32(offset + entriesPerSector * 4, true);
+    }
+    var fat = [];
+    for (var i = 0; i < Math.min(fatCount, difat.length); i++) {
+        var fatSector = difat[i];
+        var offset = (fatSector + 1) * sectorSize;
+        if (offset + sectorSize > data.length)
+            break;
+        var entries_1 = sectorSize / 4;
+        for (var j = 0; j < entries_1; j++) {
+            fat.push(view.getUint32(offset + j * 4, true));
+        }
+    }
+    var directorySectors = followFatChain(fat, firstDirSector, 4096);
+    var directoryBytes = readSectorChain(data, directorySectors, sectorSize);
+    var entries = [];
+    var entryCount = Math.floor(directoryBytes.length / DIRECTORY_ENTRY_SIZE);
+    for (var i = 0; i < entryCount; i++) {
+        var entryOffset = i * DIRECTORY_ENTRY_SIZE;
+        var entryView = new DataView(directoryBytes.buffer, directoryBytes.byteOffset + entryOffset, DIRECTORY_ENTRY_SIZE);
+        var nameLength = entryView.getUint16(64, true);
+        if (nameLength < 2 || nameLength > 64)
+            continue;
+        var charCount = Math.floor((nameLength - 2) / 2);
+        var name_2 = '';
+        for (var c = 0; c < charCount; c++) {
+            name_2 += String.fromCharCode(entryView.getUint16(c * 2, true));
+        }
+        var objectType = entryView.getUint8(66);
+        var startSector = entryView.getUint32(116, true);
+        var sizeLow = entryView.getUint32(120, true);
+        var sizeHigh = entryView.getUint32(124, true);
+        var size = sizeHigh === 0 ? sizeLow : sizeLow + sizeHigh * 0x100000000;
+        var type = 'unknown';
+        if (objectType === 5)
+            type = 'root';
+        else if (objectType === 1)
+            type = 'storage';
+        else if (objectType === 2)
+            type = 'stream';
+        entries.push({ name: name_2, type: type, size: size, startSector: startSector });
+    }
+    var root = entries.find(function (e) { return e.type === 'root'; });
+    var miniFat = [];
+    if (miniFatCount > 0 && firstMiniFatSector <= 0xfffffffa) {
+        var miniFatSectors = followFatChain(fat, firstMiniFatSector, miniFatCount);
+        var miniFatBytes = readSectorChain(data, miniFatSectors, sectorSize);
+        var miniView = new DataView(miniFatBytes.buffer, miniFatBytes.byteOffset, miniFatBytes.byteLength);
+        for (var i = 0; i + 4 <= miniFatBytes.length; i += 4) {
+            miniFat.push(miniView.getUint32(i, true));
+        }
+    }
+    var miniStream;
+    if (root && root.size > 0) {
+        var miniStreamSectors = followFatChain(fat, root.startSector, 65536);
+        miniStream = readSectorChain(data, miniStreamSectors, sectorSize).subarray(0, root.size);
+    }
+    var readStream = function (name) {
+        var e_4, _a;
+        var entry = entries.find(function (e) {
+            return e.type === 'stream' &&
+                (e.name === name || e.name.toLowerCase() === name.toLowerCase());
+        });
+        if (!entry || entry.size <= 0 || entry.size > MAX_STREAM_BYTES) {
+            return undefined;
+        }
+        if (entry.size < miniStreamCutoff && miniStream && miniFat.length > 0) {
+            var miniSectorSize = 64;
+            var sectors_2 = followChain(miniFat, entry.startSector, 65536);
+            var out = new Uint8Array(entry.size);
+            var written = 0;
+            try {
+                for (var sectors_1 = __values(sectors_2), sectors_1_1 = sectors_1.next(); !sectors_1_1.done; sectors_1_1 = sectors_1.next()) {
+                    var sector = sectors_1_1.value;
+                    if (written >= entry.size)
+                        break;
+                    var start = sector * miniSectorSize;
+                    var end = Math.min(start + miniSectorSize, miniStream.length);
+                    if (start >= miniStream.length)
+                        break;
+                    var chunk = miniStream.subarray(start, end);
+                    out.set(chunk.subarray(0, Math.min(chunk.length, entry.size - written)), written);
+                    written += chunk.length;
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (sectors_1_1 && !sectors_1_1.done && (_a = sectors_1.return)) _a.call(sectors_1);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return out.subarray(0, Math.min(written, entry.size));
+        }
+        var sectors = followFatChain(fat, entry.startSector, 65536);
+        return readSectorChain(data, sectors, sectorSize).subarray(0, entry.size);
+    };
+    return {
+        entries: function () { return entries; },
+        readStream: readStream
+    };
+}
+/**
+ * Walks the CFB File Allocation Table starting at `start` and returns the
+ * sector chain.
+ *
+ * @param fat - FAT sector index table.
+ * @param start - First sector index in the chain.
+ * @param maxSectors - Safety cap on chain length.
+ * @returns Ordered list of sector indices.
+ */
+function followFatChain(fat, start, maxSectors) {
+    return followChain(fat, start, maxSectors);
+}
+/**
+ * Walks a sector-chain table (FAT or MiniFAT) until an end-of-chain marker,
+ * a cycle, or `maxSectors` is reached.
+ *
+ * @param table - Sector chain table (FAT or MiniFAT).
+ * @param start - First sector index.
+ * @param maxSectors - Maximum number of sectors to follow.
+ * @returns Ordered list of sector indices visited.
+ */
+function followChain(table, start, maxSectors) {
+    var sectors = [];
+    var sector = start;
+    var seen = new Set();
+    while (sector <= 0xfffffffa && sectors.length < maxSectors) {
+        if (seen.has(sector))
+            break;
+        seen.add(sector);
+        sectors.push(sector);
+        if (sector >= table.length)
+            break;
+        sector = table[sector];
+    }
+    return sectors;
+}
+/**
+ * Reads and concatenates CFB sectors into a single contiguous buffer.
+ *
+ * @param data - Full CFB document bytes.
+ * @param sectors - Sector indices to read (0-based within the file body).
+ * @param sectorSize - Bytes per sector (512 or 4096).
+ * @returns Concatenated sector data (may be truncated if past EOF).
+ */
+function readSectorChain(data, sectors, sectorSize) {
+    var e_5, _a;
+    var out = new Uint8Array(sectors.length * sectorSize);
+    var offset = 0;
+    try {
+        for (var sectors_3 = __values(sectors), sectors_3_1 = sectors_3.next(); !sectors_3_1.done; sectors_3_1 = sectors_3.next()) {
+            var sector = sectors_3_1.value;
+            var start = (sector + 1) * sectorSize;
+            var end = Math.min(start + sectorSize, data.length);
+            if (start >= data.length)
+                break;
+            out.set(data.subarray(start, end), offset);
+            offset += sectorSize;
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (sectors_3_1 && !sectors_3_1.done && (_a = sectors_3.return)) _a.call(sectors_3);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return out;
+}
+//# sourceMappingURL=AcDbOleImageExtractor.js.map