@hiraokahypertools/pst-extractor 0.1.0-alpha.1

package/dist/BTHeap.d.ts

@@ -0,0 +1,15 @@
+import { PHNodeHeapReader } from "./PHNodeHeapReader";
+export declare function getBTHeapReaderFrom(heap: PHNodeHeapReader, hnid: number): Promise<BTHeapReader>;
+export interface BTHeapReader {
+    list(): Promise<BTHeapEntry[]>;
+}
+export interface BTHeapEntry {
+    /**
+     * 2, 4, 8, or 16
+     */
+    key: ArrayBuffer;
+    /**
+     * 1 ~ 32
+     */
+    data: ArrayBuffer;
+}

package/dist/BTHeap.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBTHeapReaderFrom = void 0;
+function getBTHeapReaderFrom(heap, hnid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const header = yield heap.getHeapBuffers(hnid);
+        if (header.length !== 1) {
+            throw new Error(`btree heap buffer must be single`);
+        }
+        const headerView = new DataView(header[0]);
+        const bTypeBTH = 0xB5;
+        if (headerView.getUint8(0) !== bTypeBTH) {
+            throw new Error(`signature must be bTypeBTH`);
+        }
+        const cbKey = headerView.getUint8(1);
+        const cbEnt = headerView.getUint8(2);
+        const bIdxLevels = headerView.getUint8(3);
+        const hidRoot = headerView.getUint32(4, true);
+        const list = [];
+        function recursive(hid, level) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (hid !== 0) {
+                    if (level === 0) {
+                        const recordSize = cbKey + cbEnt;
+                        const records = (yield heap.getHeapBuffers(hid));
+                        if (records.length !== 1) {
+                            throw new Error(`btree heap record must be single`);
+                        }
+                        const record = records[0];
+                        const numRecords = Math.floor(record.byteLength / recordSize);
+                        for (let x = 0; x < numRecords; x++) {
+                            const top = recordSize * x;
+                            list.push({
+                                key: record.slice(top, top + cbKey),
+                                data: record.slice(top + cbKey, top + recordSize),
+                            });
+                        }
+                    }
+                    else {
+                        const recordSize = cbKey + 4;
+                        const records = (yield heap.getHeapBuffers(hid));
+                        if (records.length !== 1) {
+                            throw new Error(`btree intermediate record must be single`);
+                        }
+                        const record = records[0];
+                        const recordView = new DataView(record);
+                        const numRecords = Math.floor(record.byteLength / recordSize);
+                        for (let x = 0; x < numRecords; x++) {
+                            const top = recordSize * x;
+                            const hidInner = recordView.getUint32(top + cbKey, true);
+                            yield recursive(hidInner, level - 1);
+                        }
+                    }
+                }
+            });
+        }
+        yield recursive(hidRoot, bIdxLevels);
+        return {
+            list() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return list;
+                });
+            },
+        };
+    });
+}
+exports.getBTHeapReaderFrom = getBTHeapReaderFrom;

package/dist/CollectionAsyncProvider.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @internal
+ */
+export declare class CollectionAsyncProvider<T> {
+    private _cache;
+    private _count;
+    private _itemProvider;
+    constructor(count: number, itemProvider: (index: number) => Promise<T>);
+    get count(): number;
+    get(index: number): Promise<T>;
+    /**
+     * get all of the children
+     */
+    all(): Promise<T[]>;
+}

package/dist/CollectionAsyncProvider.js

@@ -0,0 +1,44 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionAsyncProvider = void 0;
+const KeyedDelay_1 = require("./KeyedDelay");
+/**
+ * @internal
+ */
+class CollectionAsyncProvider {
+    constructor(count, itemProvider) {
+        this._cache = new KeyedDelay_1.KeyedDelay();
+        this._count = count;
+        this._itemProvider = itemProvider;
+    }
+    get count() {
+        return this._count;
+    }
+    get(index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this._cache.getOrCreate(index.toString(), () => __awaiter(this, void 0, void 0, function* () { return yield this._itemProvider(index); }));
+        });
+    }
+    /**
+     * get all of the children
+     */
+    all() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const array = [];
+            for (let x = 0; x < this._count; x++) {
+                array.push(yield this.get(x));
+            }
+            return array;
+        });
+    }
+}
+exports.CollectionAsyncProvider = CollectionAsyncProvider;

package/dist/KeyedDelay.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @internal
+ */
+export declare class KeyedDelay<T> {
+    private _map;
+    constructor();
+    getOrCreate(key: string, provider: () => Promise<T>): Promise<T>;
+}

package/dist/KeyedDelay.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyedDelay = void 0;
+/**
+ * @internal
+ */
+class KeyedDelay {
+    constructor() {
+        this._map = new Map();
+    }
+    getOrCreate(key, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._map.has(key)) {
+                const value = this._map.get(key);
+                if (value === undefined) {
+                    throw new Error("provider must provide a non-undefined value");
+                }
+                return value;
+            }
+            else {
+                const value = yield provider();
+                this._map.set(key, value);
+                return value;
+            }
+        });
+    }
+}
+exports.KeyedDelay = KeyedDelay;

package/dist/LZFu.class.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+export declare class LZFu {
+    private static LZFU_HEADER;
+    /**
+     * Decompress the buffer of RTF content using LZ
+     * @static
+     * @param {Buffer} data
+     * @returns {string}
+     * @memberof LZFu
+     */
+    static decode(data: Buffer): string;
+}

package/dist/LZFu.class.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LZFu = void 0;
+const PSTUtil_class_1 = require("./PSTUtil.class");
+// An implementation of the LZFu algorithm to decompress RTF content
+class LZFu {
+    /**
+     * Decompress the buffer of RTF content using LZ
+     * @static
+     * @param {Buffer} data
+     * @returns {string}
+     * @memberof LZFu
+     */
+    static decode(data) {
+        // const compressedSize: number = PSTUtil.convertLittleEndianBytesToLong(
+        //   data,
+        //   0,
+        //   4
+        // ).toNumber()
+        const uncompressedSize = PSTUtil_class_1.PSTUtil.convertLittleEndianBytesToLong(data, 4, 8).toNumber();
+        const compressionSig = PSTUtil_class_1.PSTUtil.convertLittleEndianBytesToLong(data, 8, 12).toNumber();
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const compressedCRC = PSTUtil_class_1.PSTUtil.convertLittleEndianBytesToLong(data, 12, 16).toNumber();
+        if (compressionSig == 0x75465a4c) {
+            // we are compressed...
+            const output = Buffer.alloc(uncompressedSize);
+            let outputPosition = 0;
+            const lzBuffer = Buffer.alloc(4096);
+            // preload our buffer.
+            try {
+                const bytes = Buffer.from(LZFu.LZFU_HEADER); //getBytes("US-ASCII");
+                PSTUtil_class_1.PSTUtil.arraycopy(bytes, 0, lzBuffer, 0, LZFu.LZFU_HEADER.length);
+            }
+            catch (err) {
+                console.error('LZFu::decode cant preload buffer\n' + err);
+                throw err;
+            }
+            let bufferPosition = LZFu.LZFU_HEADER.length;
+            let currentDataPosition = 16;
+            // next byte is the flags,
+            while (currentDataPosition < data.length - 2 &&
+                outputPosition < output.length) {
+                let flags = data[currentDataPosition++] & 0xff;
+                for (let x = 0; x < 8 && outputPosition < output.length; x++) {
+                    const isRef = (flags & 1) == 1;
+                    flags >>= 1;
+                    if (isRef) {
+                        // get the starting point for the buffer and the length to read
+                        const refOffsetOrig = data[currentDataPosition++] & 0xff;
+                        const refSizeOrig = data[currentDataPosition++] & 0xff;
+                        const refOffset = (refOffsetOrig << 4) | (refSizeOrig >>> 4);
+                        const refSize = (refSizeOrig & 0xf) + 2;
+                        try {
+                            // copy the data from the buffer
+                            let index = refOffset;
+                            for (let y = 0; y < refSize && outputPosition < output.length; y++) {
+                                output[outputPosition++] = lzBuffer[index];
+                                lzBuffer[bufferPosition] = lzBuffer[index];
+                                bufferPosition++;
+                                bufferPosition %= 4096;
+                                ++index;
+                                index %= 4096;
+                            }
+                        }
+                        catch (err) {
+                            console.error('LZFu::decode copy the data from the buffer\n' + err);
+                            throw err;
+                        }
+                    }
+                    else {
+                        // copy the byte over
+                        lzBuffer[bufferPosition] = data[currentDataPosition];
+                        bufferPosition++;
+                        bufferPosition %= 4096;
+                        output[outputPosition++] = data[currentDataPosition++];
+                    }
+                }
+            }
+            if (outputPosition != uncompressedSize) {
+                throw new Error('LZFu::constructor decode Error decompressing RTF');
+            }
+            return new String(output).trim();
+        }
+        else if (compressionSig == 0x414c454d) {
+            // we are not compressed!
+            // just return the rest of the contents as a string
+            const output = Buffer.alloc(data.length - 16);
+            PSTUtil_class_1.PSTUtil.arraycopy(data, 16, output, 0, data.length - 16);
+            return new String(output).trim();
+        }
+        return '';
+    }
+}
+exports.LZFu = LZFu;
+LZFu.LZFU_HEADER = '{\\rtf1\\ansi\\mac\\deff0\\deftab720{\\fonttbl;}{\\f0\\fnil \\froman \\fswiss \\fmodern \\fscript \\fdecor MS Sans SerifSymbolArialTimes New RomanCourier{\\colortbl\\red0\\green0\\blue0\n\r\\par \\pard\\plain\\f0\\fs20\\b\\i\\u\\tab\\tx';

package/dist/NodeMap.class.d.ts

@@ -0,0 +1,35 @@
+import Long from 'long';
+/**
+ * Stores node names (both alpha and numeric) in node maps for quick lookup.
+ * @export
+ * @class NodeMap
+ */
+export declare class NodeMap {
+    private nameToId;
+    private idToNumericName;
+    private idToStringName;
+    /**
+     * Set a node into the map.
+     * @param {*} key
+     * @param {number} propId
+     * @param {number} [idx]
+     * @memberof NodeMap
+     */
+    setId(key: any, propId: number, idx?: number): void;
+    /**
+     * Get a node from the map.
+     * @param {*} key
+     * @param {number} [idx]
+     * @returns {number}
+     * @memberof NodeMap
+     */
+    getId(key: any, idx?: number): number;
+    /**
+     * Get a node from the map.
+     * @param {number} propId
+     * @returns {long}
+     * @memberof NodeMap
+     */
+    getNumericName(propId: number): Long | undefined;
+    private transformKey;
+}

package/dist/NodeMap.class.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMap = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const long_1 = __importDefault(require("long"));
+/**
+ * Stores node names (both alpha and numeric) in node maps for quick lookup.
+ * @export
+ * @class NodeMap
+ */
+class NodeMap {
+    constructor() {
+        this.nameToId = new Map();
+        this.idToNumericName = new Map();
+        this.idToStringName = new Map();
+    }
+    /**
+     * Set a node into the map.
+     * @param {*} key
+     * @param {number} propId
+     * @param {number} [idx]
+     * @memberof NodeMap
+     */
+    setId(key, propId, idx) {
+        if (typeof key === 'number' && idx !== undefined) {
+            const lkey = this.transformKey(key, idx);
+            this.nameToId.set(lkey.toString(), propId);
+            this.idToNumericName.set(propId, lkey);
+            // console.log('NodeMap::setId: propId = ' + propId + ', lkey = ' + lkey.toString());
+        }
+        else if (typeof key === 'string') {
+            this.nameToId.set(key, propId);
+            this.idToStringName.set(propId, key);
+            // console.log('NodeMap::setId: propId = ' + propId + ', key = ' + key);
+        }
+        else {
+            throw new Error('NodeMap::setId bad param type ' + typeof key);
+        }
+    }
+    /**
+     * Get a node from the map.
+     * @param {*} key
+     * @param {number} [idx]
+     * @returns {number}
+     * @memberof NodeMap
+     */
+    getId(key, idx) {
+        let id = undefined;
+        if (typeof key === 'number' && idx) {
+            id = this.nameToId.get(this.transformKey(key, idx).toString());
+        }
+        else if (typeof key === 'string') {
+            id = this.nameToId.get(key);
+        }
+        else {
+            throw new Error('NodeMap::getId bad param type ' + typeof key);
+        }
+        if (!id) {
+            return -1;
+        }
+        return id;
+    }
+    /**
+     * Get a node from the map.
+     * @param {number} propId
+     * @returns {long}
+     * @memberof NodeMap
+     */
+    getNumericName(propId) {
+        const lkey = this.idToNumericName.get(propId);
+        if (!lkey) {
+            // console.log("NodeMap::getNumericName Name to Id mapping not found, propId = " + propId);
+        }
+        return lkey;
+    }
+    transformKey(key, idx) {
+        let lidx = long_1.default.fromNumber(idx);
+        lidx = lidx.shiftLeft(32);
+        lidx = lidx.or(key);
+        return lidx;
+    }
+}
+exports.NodeMap = NodeMap;