@hiraokahypertools/pst-extractor 0.1.0-alpha.1

package/dist/PAUtil.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * PST adapter utilities
+ */
+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.createPropertyFinder = exports.processNameToIDMap = void 0;
+const msftUuidStringify_1 = require("./msftUuidStringify");
+const NodeMap_class_1 = require("./NodeMap.class");
+const PHUtil_1 = require("./PHUtil");
+const PropertyContextUtil_1 = require("./PropertyContextUtil");
+const PSTUtil_class_1 = require("./PSTUtil.class");
+const guidMap = new Map([
+    ['00020329-0000-0000-C000-000000000046', 0],
+    ['00062008-0000-0000-C000-000000000046', 1],
+    ['00062004-0000-0000-C000-000000000046', 2],
+    ['00020386-0000-0000-C000-000000000046', 3],
+    ['00062002-0000-0000-C000-000000000046', 4],
+    ['6ED8DA90-450B-101B-98DA-00AA003F1305', 5],
+    ['0006200A-0000-0000-C000-000000000046', 6],
+    ['41F28F13-83F4-4114-A584-EEDB5A6B0BFF', 7],
+    ['0006200E-0000-0000-C000-000000000046', 8],
+    ['00062041-0000-0000-C000-000000000046', 9],
+    ['00062003-0000-0000-C000-000000000046', 10],
+    ['4442858E-A9E3-4E80-B900-317A210CC15B', 11],
+    ['00020328-0000-0000-C000-000000000046', 12],
+    ['71035549-0739-4DCB-9163-00F0580DBBDF', 13],
+    ['00062040-0000-0000-C000-000000000046', 14],
+]);
+/**
+ * Process name to ID map.
+ *
+ * @param nameToIdMapDescriptorNode nodeId 97
+ */
+function processNameToIDMap(nameToIdMapDescriptorNode, resolver) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const subNode = nameToIdMapDescriptorNode.getSubNode();
+        const bcTable = (yield (yield (0, PropertyContextUtil_1.getPropertyContext)(yield (0, PHUtil_1.getHeapFrom)(subNode), resolver))
+            .list());
+        function getTableItem(key) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const found = bcTable.find(it => it.key === key);
+                if (found === undefined) {
+                    throw new Error(`processNameToIDMap key:${key} is null`);
+                }
+                const { value } = found;
+                if (value instanceof ArrayBuffer) {
+                    return value;
+                }
+                return undefined;
+            });
+        }
+        // process the map
+        // Get the guids
+        const guidEntry = yield getTableItem(2);
+        if (!guidEntry) {
+            throw new Error('PSTFile::processNameToIDMap guidEntry is null');
+        }
+        const guids = new Uint8Array(guidEntry);
+        const nGuids = Math.trunc(guids.byteLength / 16);
+        const guidIndexes = [];
+        let offset = 0;
+        for (let i = 0; i < nGuids; ++i) {
+            const strUID = (0, msftUuidStringify_1.msftUuidStringify)(guids, offset).toUpperCase();
+            const guid = guidMap.get(strUID);
+            if (guid) {
+                guidIndexes[i] = guid;
+            }
+            else {
+                guidIndexes[i] = -1; // We don't know this guid
+            }
+            // console.log('PSTFile:: processNameToIdMap idx: ' + i + ', ' + strUID + ', ' + guidIndexes[i]);
+            offset += 16;
+        }
+        // if we have a reference to an internal descriptor
+        const mapEntries = yield getTableItem(3);
+        if (!mapEntries) {
+            throw new Error('PSTFile::processNameToIDMap mapEntries is null');
+        }
+        const nameToIdByte = new Uint8Array(mapEntries);
+        const nameToIdByteView = new DataView(mapEntries);
+        const stringMapEntries = yield getTableItem(4);
+        if (!stringMapEntries) {
+            throw new Error('PSTFile::processNameToIDMap stringMapEntries is null');
+        }
+        const stringNameToIdByte = new Uint8Array(stringMapEntries);
+        const stringNameToIdByteView = new DataView(stringMapEntries);
+        const stringNameToIdByteBuffer = Buffer.from(stringMapEntries);
+        const nodeMap = new NodeMap_class_1.NodeMap();
+        // process the entries
+        for (let x = 0; x + 8 < nameToIdByte.length; x += 8) {
+            const key = nameToIdByteView.getUint32(x, true);
+            let guid = nameToIdByteView.getUint16(x + 4, true);
+            let propId = nameToIdByteView.getUint16(x + 6, true);
+            if (key == 0x55555555) {
+                break;
+            }
+            const PS_PUBLIC_STRINGS = 0;
+            const PS_MAPI = 12;
+            if ((guid & 0x0001) == 0) {
+                // identifier is numeric
+                propId += 0x8000;
+                guid >>= 1;
+                let guidIndex;
+                if (guid == 1) {
+                    guidIndex = PS_MAPI;
+                }
+                else if (guid == 2) {
+                    guidIndex = PS_PUBLIC_STRINGS;
+                }
+                else {
+                    guidIndex = guidIndexes[guid - 3];
+                }
+                nodeMap.setId(key, propId, guidIndex);
+            }
+            else {
+                // identifier is a string
+                // key is byte offset into the String stream in which the string name of the property is stored.
+                const len = stringNameToIdByteView.getUint32(key, true);
+                const keyByteValue = Buffer.alloc(len);
+                PSTUtil_class_1.PSTUtil.arraycopy(stringNameToIdByteBuffer, key + 4, keyByteValue, 0, keyByteValue.length);
+                propId += 0x8000;
+                nodeMap.setId(keyByteValue.toString('utf16le').replace(/\0/g, ''), propId);
+            }
+        }
+        return nodeMap;
+    });
+}
+exports.processNameToIDMap = processNameToIDMap;
+function createPropertyFinder(props) {
+    return {
+        findByKey(key) {
+            return props.find(it => it.key === key);
+        },
+    };
+}
+exports.createPropertyFinder = createPropertyFinder;

package/dist/PHNodeHeap.d.ts

@@ -0,0 +1,16 @@
+import { PHNodeHeapReader } from "./PHNodeHeapReader";
+export interface PHNodeHeap {
+    /**
+     * bType
+     *
+     * Set to `0` if heap structure doesn't exist, in case of loading absent subNode
+     */
+    bClientSig: number;
+    /**
+     * hnid
+     *
+     * Set to `0` if heap structure doesn't exist, in case of loading absent subNode
+     */
+    userRootHnid: number;
+    getReader(): PHNodeHeapReader;
+}

package/dist/PHNodeHeap.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PHNodeHeapReader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PST high level node heap reader
+ */
+export interface PHNodeHeapReader {
+    getHeapBuffers(hnid: number): Promise<ArrayBuffer[]>;
+}

package/dist/PHNodeHeapReader.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * PST high level node heap reader
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PHUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PST higher level utilities
+ */
+import { PHNodeHeap } from "./PHNodeHeap";
+import { PLSubNode } from "./PLSubNode";
+export declare function getHeapFrom(node: PLSubNode): Promise<PHNodeHeap>;

package/dist/PHUtil.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * PST higher level utilities
+ */
+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.getHeapFrom = void 0;
+function getHeapFrom(node) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const data_array = yield node.getData();
+        const data_chunks = new Map();
+        let bClientSig = 0;
+        let userRootHnid = 0;
+        for (let x = 0; x < data_array.length; x++) {
+            if (x === 0) {
+                ({ bClientSig, userRoot: userRootHnid } = load_root_header(data_chunks, data_array[x]));
+            }
+            else {
+                load_page_header(data_chunks, data_array[x], x);
+            }
+        }
+        return {
+            bClientSig,
+            userRootHnid,
+            toString() {
+                return `${node}`;
+            },
+            getReader() {
+                return {
+                    getHeapBuffers(hnid) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            if (hnid === 0) {
+                                return [];
+                            }
+                            else if (hnid & 0x1f) {
+                                // this is NID (node)
+                                const childNode = yield node.getChildBy(hnid);
+                                if (childNode === undefined) {
+                                    throw new Error(`childNode=0x${hnid.toString(16)} of ${node} not found`);
+                                }
+                                const data_array = yield childNode.getData();
+                                return data_array;
+                            }
+                            else {
+                                // this is HID (heap)
+                                const data = data_chunks.get(hnid);
+                                if (data === undefined) {
+                                    throw new Error(`heap=0x${hnid.toString(16)} of ${node} not found`);
+                                }
+                                return [data];
+                            }
+                        });
+                    },
+                    toString() {
+                        return `reader of ${node}`;
+                    },
+                };
+            },
+        };
+    });
+}
+exports.getHeapFrom = getHeapFrom;
+/**
+ * Parse HNHDR
+ *
+ * @see https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-pst/8e4ae05c-3c24-4103-b7e5-ffef6f244834
+ */
+function load_root_header(data_chunks, data) {
+    const view = new DataView(data);
+    const page_map = view.getUint16(0, true);
+    const sig = view.getUint8(2);
+    const bClientSig = view.getUint8(3);
+    const userRoot = view.getUint32(4, true);
+    if (sig !== 0xec) {
+        throw new Error("invalid HNHDR signature found");
+    }
+    // read HNPAGEMAP
+    const offsets_count = view.getUint16(page_map, true) + 1;
+    for (let x = 0; x < offsets_count - 1; x++) {
+        const from = view.getUint16(page_map + 4 + 2 * (x), true);
+        const to = view.getUint16(page_map + 4 + 2 * (x + 1), true);
+        data_chunks.set(0x20 * (1 + x), data.slice(from, to));
+    }
+    return { bClientSig, userRoot };
+}
+function load_page_header(data_chunks, data, page_index) {
+    const view = new DataView(data);
+    const page_map = view.getUint16(0, true);
+    const offsets_count = view.getUint16(page_map, true) + 1;
+    for (let x = 0; x < offsets_count - 1; x++) {
+        const from = view.getUint16(page_map + 4 + 2 * (x), true);
+        const to = view.getUint16(page_map + 4 + 2 * (x + 1), true);
+        data_chunks.set(0x20 * (1 + x) + 65536 * page_index, data.slice(from, to));
+    }
+}

package/dist/PLMisc.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PST lower level misc utilities
+ */
+/**
+ *
+ * @internal
+ */
+export declare function splitPer(array: ArrayBuffer, per: number): Generator<ArrayBuffer>;

package/dist/PLMisc.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * PST lower level misc utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPer = void 0;
+/**
+ *
+ * @internal
+ */
+function* splitPer(array, per) {
+    for (let offset = 0; offset < array.byteLength; offset += per) {
+        yield array.slice(offset, offset + per);
+    }
+}
+exports.splitPer = splitPer;

package/dist/PLNode.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PST lower level node
+ */
+import { PLSubNode } from "./PLSubNode";
+export interface PLNode {
+    nodeId: number;
+    getParent(): PLNode | undefined;
+    getChildren(): PLNode[];
+    getSubNode(): PLSubNode;
+    getSiblingNode(nidType: number): PLNode | undefined;
+}

package/dist/PLNode.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * PST lower level node
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PLStore.d.ts

@@ -0,0 +1,9 @@
+/**
+ * PST lower level store
+ */
+import { PLNode } from "./PLNode";
+export interface PLStore {
+    getOneNodeBy(nodeId: number): PLNode | undefined;
+    getOneNodeByOrError(nodeId: number): PLNode;
+    close(): void;
+}

package/dist/PLStore.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * PST lower level store
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PLSubNode.d.ts

@@ -0,0 +1,8 @@
+/**
+ * PST lower level node reader
+ */
+export interface PLSubNode {
+    nodeId: number;
+    getChildBy(childNodeId: number): Promise<PLSubNode | undefined>;
+    getData(): Promise<ArrayBuffer[]>;
+}

package/dist/PLSubNode.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * PST lower level node reader
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PLUtil.d.ts

@@ -0,0 +1,29 @@
+/**
+ * PST lower level utilities
+ */
+import Long from "long";
+import { PLStore } from "./PLStore";
+export declare type ReadFile = (buffer: ArrayBuffer, offset: number, length: number, position: number) => Promise<number>;
+export declare type Close = () => Promise<void>;
+/**
+ * Defines a callback based async file operation API.
+ */
+export interface ReadFileApi {
+    /**
+     * Defines read API like `fs.promises.readFile`.
+     */
+    readFile: ReadFile;
+    /**
+     * Defines close API like `fs.promises.close`.
+     */
+    close: Close;
+}
+/**
+ * @internal
+ */
+export declare function readNumber64(view: DataView, offset: number): number;
+/**
+ * @internal
+ */
+export declare function readLong(view: DataView, offset: number): Long;
+export declare function openLowPst(api: ReadFileApi): Promise<PLStore>;