@hiraokahypertools/pst-extractor 0.1.0-alpha.1

package/dist/Property.d.ts

@@ -0,0 +1,38 @@
+export interface Property {
+    /**
+     * Key of property.
+     *
+     * e.g. `0x3001` is `PR_DISPLAY_NAME`
+     */
+    key: number;
+    /**
+     * Type of property.
+     *
+     * e.g. `0x001f` is `PT_UNICODE`
+     */
+    type: number;
+    /**
+     * Value of property.
+     *
+     * The value conversion depends on implementation.
+     * Check the source code of {@link PropertyValueResolverV1} for detail.
+     *
+     * - `PT_SHORT` will be casted to `number`
+     * - `PT_FLOAT` will be casted to `number`
+     * - `PT_LONG` will be casted to `number`
+     * - `PT_OBJECT` will be casted to {@link PropertyTypeObject}
+     * - `PT_LONGLONG` will be casted to `Long`
+     * - `PT_DOUBLE` will be casted to `number`
+     * - `PT_BOOLEAN` will be casted to `boolean`
+     * - `PT_STRING8` will be casted to `string`
+     * - `PT_UNICODE` will be casted to `string`
+     * - `PT_SYSTIME` will be casted to `Date`
+     * - `PT_CLSID` will be casted to `ArrayBuffer`
+     * - `0x0102` will be casted to `ArrayBuffer`
+     * - `PT_MV_UNICODE` will be casted to `string[]`
+     * - `PT_MV_BINARY` will be casted to `ArrayBuffer[]`
+     * - `PT_MV_LONG` will be casted to `number[]`
+     * - `PT_MV_CLSID` will be casted to `ArrayBuffer[]`
+     */
+    value: any;
+}

package/dist/Property.js

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

package/dist/PropertyContext.d.ts

@@ -0,0 +1,6 @@
+import { Property } from "./Property";
+import { RawProperty } from "./RawProperty";
+export interface PropertyContext {
+    listRaw(): Promise<RawProperty[]>;
+    list(): Promise<Property[]>;
+}

package/dist/PropertyContext.js

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

package/dist/PropertyContextUtil.d.ts

@@ -0,0 +1,4 @@
+import { PHNodeHeap } from "./PHNodeHeap";
+import { PropertyContext } from "./PropertyContext";
+import { PropertyValueResolver } from "./PropertyValueResolver";
+export declare function getPropertyContext(heap: PHNodeHeap, resolver: PropertyValueResolver): Promise<PropertyContext>;

package/dist/PropertyContextUtil.js

@@ -0,0 +1,77 @@
+"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.getPropertyContext = void 0;
+const BTHeap_1 = require("./BTHeap");
+const bTypePC = 0xBC;
+function copy(array) {
+    return array
+        .map(it => Object.assign({}, it));
+}
+function getPropertyContext(heap, resolver) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (heap.bClientSig !== bTypePC) {
+            throw new Error("bClientSig must be bTypePC");
+        }
+        const reader = heap.getReader();
+        function getRecords() {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const index_data = yield (0, BTHeap_1.getBTHeapReaderFrom)(reader, heap.userRootHnid);
+                    return yield index_data.list();
+                }
+                catch (ex) {
+                    throw new Error(`getRecords failure of hnid ${heap.userRootHnid} of ${heap} --> ${ex}`);
+                }
+            });
+        }
+        const rawProperties = (yield getRecords())
+            .map(record => {
+            const keyView = new DataView(record.key);
+            const dataView = new DataView(record.data);
+            return {
+                key: keyView.getUint16(0, true),
+                type: dataView.getUint16(0, true),
+                value: record.data.slice(2),
+            };
+        });
+        return {
+            listRaw() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return copy(rawProperties);
+                });
+            },
+            list() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const props = [];
+                    for (let it of rawProperties) {
+                        try {
+                            props.push({
+                                key: it.key,
+                                type: it.type,
+                                value: yield resolver.resolveValueOf(it.key, it.type, it.value, reader),
+                            });
+                        }
+                        catch (ex) {
+                            throw new Error(`getPropertyContext.list() resolving property`
+                                + ` key=0x${it.key.toString(16).padStart(4, '0')}`
+                                + ` type=0x${it.type.toString(16).padStart(4, '0')}`
+                                + ` of ${heap} failure`
+                                + ` --> ${ex}`);
+                        }
+                    }
+                    return props;
+                });
+            },
+        };
+    });
+}
+exports.getPropertyContext = getPropertyContext;

package/dist/PropertyTypeObject.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The value representation of `PT_OBJECT` type
+ *
+ * @see [[MS-PST]: PtypObject Properties | Microsoft Docs](https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-pst/49457d57-820e-453d-bbc0-1d192a999814)
+ */
+export declare class PropertyTypeObject {
+    private _subNodeId;
+    private _size;
+    constructor(subNodeId: number, size: number);
+    get subNodeId(): number;
+    get size(): number;
+}

package/dist/PropertyTypeObject.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyTypeObject = void 0;
+/**
+ * The value representation of `PT_OBJECT` type
+ *
+ * @see [[MS-PST]: PtypObject Properties | Microsoft Docs](https://docs.microsoft.com/en-us/openspecs/office_file_formats/ms-pst/49457d57-820e-453d-bbc0-1d192a999814)
+ */
+class PropertyTypeObject {
+    constructor(subNodeId, size) {
+        this._subNodeId = subNodeId;
+        this._size = size;
+    }
+    get subNodeId() {
+        return this._subNodeId;
+    }
+    get size() {
+        return this._size;
+    }
+}
+exports.PropertyTypeObject = PropertyTypeObject;

package/dist/PropertyValueResolver.d.ts

@@ -0,0 +1,4 @@
+import { PHNodeHeapReader } from "./PHNodeHeapReader";
+export interface PropertyValueResolver {
+    resolveValueOf(key: number, type: number, value: ArrayBuffer, heap: PHNodeHeapReader): Promise<any>;
+}

package/dist/PropertyValueResolver.js

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

package/dist/PropertyValueResolverV1.d.ts

@@ -0,0 +1,7 @@
+import { PHNodeHeapReader } from "./PHNodeHeapReader";
+import { PropertyValueResolver } from "./PropertyValueResolver";
+export declare class PropertyValueResolverV1 implements PropertyValueResolver {
+    private convertAnsiString;
+    constructor(convertAnsiString: (array: ArrayBuffer) => Promise<string>);
+    resolveValueOf(key: number, type: number, value: ArrayBuffer, heap: PHNodeHeapReader): Promise<any>;
+}

package/dist/PropertyValueResolverV1.js

@@ -0,0 +1,253 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyValueResolverV1 = void 0;
+const long_1 = __importDefault(require("long"));
+const PLUtil_1 = require("./PLUtil");
+const PropertyTypeObject_1 = require("./PropertyTypeObject");
+const PSTUtil_class_1 = require("./PSTUtil.class");
+const typeConverters = {};
+const PT_BOOLEAN = 0xB;
+const PT_DOUBLE = 0x5;
+const PT_LONG = 0x3;
+const PT_OBJECT = 0xD;
+const PT_LONGLONG = 0x14;
+const PT_STRING8 = 0x1E;
+const PT_UNICODE = 0x1F;
+const PT_SYSTIME = 0x40;
+const PT_CLSID = 0x48;
+const PT_SHORT = 0x2;
+const PT_FLOAT = 0x4;
+const PT_MV_UNICODE = 0x101F;
+const PT_MV_STRING8 = 0x101E;
+const PT_MV_BINARY = 0x1102;
+const PT_MV_LONG = 0x1003;
+const PT_MV_CLSID = 0x1048;
+typeConverters[PT_SHORT] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    return arg.view.getInt16(0, true);
+});
+typeConverters[PT_FLOAT] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    return arg.view.getFloat32(0, true);
+});
+typeConverters[PT_LONG] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    return arg.view.getInt32(0, true);
+});
+typeConverters[PT_OBJECT] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const bytes = yield arg.resolveHeap(heap);
+    if (bytes !== undefined) {
+        const view = new DataView(bytes);
+        return new PropertyTypeObject_1.PropertyTypeObject(view.getUint32(0, true), view.getUint32(4, true));
+    }
+    return bytes;
+});
+typeConverters[PT_LONGLONG] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const bytes = yield arg.getBytes(8);
+    if (bytes !== undefined) {
+        const view = new DataView(bytes);
+        return (0, PLUtil_1.readLong)(view, 0);
+    }
+    else {
+        return undefined;
+    }
+});
+typeConverters[PT_DOUBLE] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const bytes = yield arg.getBytes(8);
+    return (bytes !== undefined)
+        ? new DataView(bytes).getFloat64(0, true)
+        : undefined;
+});
+typeConverters[PT_BOOLEAN] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    return arg.view.getUint8(0) !== 0;
+});
+typeConverters[PT_STRING8] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const bytes = yield arg.resolveHeap(heap);
+    return (bytes !== undefined)
+        ? yield arg.convertAnsiString(bytes)
+        : undefined;
+});
+typeConverters[PT_UNICODE] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const bytes = yield arg.resolveHeap(heap);
+    return (bytes !== undefined)
+        ? Buffer.from(bytes).toString('utf16le').replace(/\0/g, '')
+        : undefined;
+    // `.replace(/\0/g, '')` is needed to eliminate a trailing null char.
+});
+typeConverters[PT_SYSTIME] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const bytes = yield arg.getBytes(8);
+    if (bytes !== undefined) {
+        const view = new DataView(bytes);
+        return PSTUtil_class_1.PSTUtil.filetimeToDate(new long_1.default(view.getUint32(4, true)), new long_1.default(view.getUint32(0, true)));
+    }
+    else {
+        return undefined;
+    }
+});
+typeConverters[PT_CLSID] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const bytes = yield arg.resolveHeap(heap);
+    return bytes;
+});
+typeConverters[0x0102] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const bytes = yield arg.resolveHeap(heap);
+    return bytes;
+});
+typeConverters[PT_MV_UNICODE] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const list = [];
+    if (heap !== 0) {
+        const bytes = yield arg.resolveHeap(heap);
+        if (bytes !== undefined) {
+            const view = new DataView(bytes);
+            const count = view.getUint32(0, true);
+            for (let x = 0; x < count - 1; x++) {
+                const from = view.getUint32(4 + 4 * (x), true);
+                const to = view.getUint32(4 + 4 * (x + 1), true);
+                const elementBytes = bytes.slice(from, to);
+                list.push(Buffer.from(elementBytes).toString('utf16le').replace(/\0/g, ''));
+            }
+        }
+    }
+    return list;
+});
+typeConverters[PT_MV_BINARY] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const list = [];
+    if (heap !== 0) {
+        const bytes = yield arg.resolveHeap(heap);
+        if (bytes !== undefined) {
+            const view = new DataView(bytes);
+            const count = view.getUint32(0, true);
+            for (let x = 0; x < count - 1; x++) {
+                const from = view.getUint32(4 + 4 * (x), true);
+                const to = view.getUint32(4 + 4 * (x + 1), true);
+                const elementBytes = bytes.slice(from, to);
+                list.push(elementBytes);
+            }
+        }
+    }
+    return list;
+});
+typeConverters[PT_MV_LONG] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const list = [];
+    if (heap !== 0) {
+        const bytes = yield arg.resolveHeap(heap);
+        if (bytes !== undefined) {
+            const view = new DataView(bytes);
+            const count = bytes.byteLength / 4;
+            for (let x = 0; x < count; x++) {
+                list.push(view.getInt32(4 * x, true));
+            }
+        }
+    }
+    return list;
+});
+typeConverters[PT_MV_CLSID] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const list = [];
+    if (heap !== 0) {
+        const bytes = yield arg.resolveHeap(heap);
+        if (bytes !== undefined) {
+            const count = bytes.byteLength / 16;
+            for (let x = 0; x < count; x++) {
+                const from = 16 * (x);
+                const to = 16 * (x + 1);
+                const elementBytes = bytes.slice(from, to);
+                list.push(elementBytes);
+            }
+        }
+    }
+    return list;
+});
+typeConverters[PT_MV_STRING8] = (arg) => __awaiter(void 0, void 0, void 0, function* () {
+    const heap = arg.view.getUint32(0, true);
+    const list = [];
+    if (heap !== 0) {
+        const bytes = yield arg.resolveHeap(heap);
+        if (bytes !== undefined) {
+            const view = new DataView(bytes);
+            const count = view.getUint32(0, true);
+            for (let x = 0; x < count - 1; x++) {
+                const from = view.getUint32(4 + 4 * (x), true);
+                const to = view.getUint32(4 + 4 * (x + 1), true);
+                const elementBytes = bytes.slice(from, to);
+                list.push(yield arg.convertAnsiString(elementBytes));
+            }
+        }
+    }
+    return list;
+});
+function mixIntoOne(array) {
+    if (array.length === 0) {
+        return new ArrayBuffer(0);
+    }
+    else if (array.length === 1) {
+        return array[0];
+    }
+    else {
+        const numBytes = array.reduce((prev, it) => prev + it.byteLength, 0);
+        const one = new ArrayBuffer(numBytes);
+        const dest = new Uint8Array(one);
+        array.reduce((nextPos, source) => {
+            dest.set(new Uint8Array(source), nextPos);
+            return nextPos + source.byteLength;
+        }, 0);
+        return one;
+    }
+}
+class PropertyValueResolverV1 {
+    constructor(convertAnsiString) {
+        this.convertAnsiString = convertAnsiString;
+    }
+    resolveValueOf(key, type, value, heap) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const view = new DataView(value);
+            function resolveHeap(hnid) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return mixIntoOne(yield heap.getHeapBuffers(hnid));
+                });
+            }
+            const converter = typeConverters[type];
+            if (converter === undefined) {
+                throw new Error(`property type 0x${type.toString(16)} is unknown. please define a typeConverter in PropertyValueResolverV1.ts`);
+            }
+            return yield converter({
+                view: view,
+                heap: heap,
+                getBytes(numBytes) {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        const { byteLength } = value;
+                        if (byteLength === 4 && byteLength < numBytes) {
+                            const hnid = view.getUint32(0, true);
+                            return yield resolveHeap(hnid);
+                        }
+                        else if (byteLength !== 4 && numBytes <= byteLength) {
+                            return value.slice(0, numBytes);
+                        }
+                        else {
+                            throw new Error("dont know how to provide buffer");
+                        }
+                    });
+                },
+                resolveHeap: resolveHeap,
+                convertAnsiString: this.convertAnsiString,
+            });
+        });
+    }
+}
+exports.PropertyValueResolverV1 = PropertyValueResolverV1;

package/dist/RawProperty.d.ts

@@ -0,0 +1,8 @@
+export interface RawProperty {
+    key: number;
+    type: number;
+    /**
+     * 0 bytes if absent
+     */
+    value: ArrayBuffer;
+}

package/dist/RawProperty.js

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

package/dist/RecurrencePattern.class.d.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+export declare enum RecurFrequency {
+    Daily = 8202,
+    Weekly = 8203,
+    Monthly = 8204,
+    Yearly = 8205
+}
+export declare enum PatternType {
+    Day = 0,
+    Week = 1,
+    Month = 2,
+    MonthEnd = 4,
+    MonthNth = 3
+}
+export declare enum EndType {
+    AfterDate = 8225,
+    AfterNOccurrences = 8226,
+    NeverEnd = 8227
+}
+export declare enum NthOccurrence {
+    First = 1,
+    Second = 2,
+    Third = 3,
+    Fourth = 4,
+    Last = 5
+}
+export declare type WeekSpecific = boolean[] & {
+    length: 7;
+};
+export declare type MonthNthSpecific = {
+    weekdays: WeekSpecific;
+    nth: NthOccurrence;
+};
+export declare class RecurrencePattern {
+    private buffer;
+    recurFrequency: RecurFrequency;
+    patternType: PatternType;
+    firstDateTime: Date;
+    period: number;
+    patternTypeSpecific: number | WeekSpecific | MonthNthSpecific | null;
+    endType: EndType;
+    occurrenceCount: number;
+    firstDOW: number;
+    startDate: Date;
+    endDate: Date;
+    constructor(buffer: Buffer);
+    toJSON(): any;
+    private readInt;
+    private readPatternTypeSpecific;
+}

package/dist/RecurrencePattern.class.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecurrencePattern = exports.NthOccurrence = exports.EndType = exports.PatternType = exports.RecurFrequency = void 0;
+const OFFSETS = {
+    RecurFrequency: 4,
+    PatternType: 6,
+    FirstDateTime: 10,
+    Period: 14,
+    PatternTypeSpecific: 22,
+    EndType: 22,
+    OccurrenceCount: 26,
+    FirstDOW: 30,
+    StartDate: -8,
+    EndDate: -4,
+};
+var RecurFrequency;
+(function (RecurFrequency) {
+    RecurFrequency[RecurFrequency["Daily"] = 8202] = "Daily";
+    RecurFrequency[RecurFrequency["Weekly"] = 8203] = "Weekly";
+    RecurFrequency[RecurFrequency["Monthly"] = 8204] = "Monthly";
+    RecurFrequency[RecurFrequency["Yearly"] = 8205] = "Yearly";
+})(RecurFrequency = exports.RecurFrequency || (exports.RecurFrequency = {}));
+var PatternType;
+(function (PatternType) {
+    PatternType[PatternType["Day"] = 0] = "Day";
+    PatternType[PatternType["Week"] = 1] = "Week";
+    PatternType[PatternType["Month"] = 2] = "Month";
+    PatternType[PatternType["MonthEnd"] = 4] = "MonthEnd";
+    PatternType[PatternType["MonthNth"] = 3] = "MonthNth";
+})(PatternType = exports.PatternType || (exports.PatternType = {}));
+var EndType;
+(function (EndType) {
+    EndType[EndType["AfterDate"] = 8225] = "AfterDate";
+    EndType[EndType["AfterNOccurrences"] = 8226] = "AfterNOccurrences";
+    EndType[EndType["NeverEnd"] = 8227] = "NeverEnd";
+})(EndType = exports.EndType || (exports.EndType = {}));
+var NthOccurrence;
+(function (NthOccurrence) {
+    NthOccurrence[NthOccurrence["First"] = 1] = "First";
+    NthOccurrence[NthOccurrence["Second"] = 2] = "Second";
+    NthOccurrence[NthOccurrence["Third"] = 3] = "Third";
+    NthOccurrence[NthOccurrence["Fourth"] = 4] = "Fourth";
+    NthOccurrence[NthOccurrence["Last"] = 5] = "Last";
+})(NthOccurrence = exports.NthOccurrence || (exports.NthOccurrence = {}));
+class RecurrencePattern {
+    constructor(buffer) {
+        this.buffer = buffer;
+        const bufferEnd = buffer.length;
+        let patternTypeOffset = 0;
+        this.recurFrequency = this.readInt(OFFSETS.RecurFrequency, 1);
+        this.patternType = this.readInt(OFFSETS.PatternType, 1);
+        this.firstDateTime = winToJsDate(this.readInt(OFFSETS.FirstDateTime, 2));
+        this.period = this.readInt(OFFSETS.Period, 2);
+        this.patternTypeSpecific = this.readPatternTypeSpecific(this.patternType);
+        switch (this.patternType) {
+            case PatternType.Week:
+            case PatternType.Month:
+            case PatternType.MonthEnd:
+                patternTypeOffset = 4;
+                break;
+            case PatternType.MonthNth:
+                patternTypeOffset = 8;
+                break;
+        }
+        this.endType = this.readInt(OFFSETS.EndType + patternTypeOffset, 2);
+        this.occurrenceCount = this.readInt(OFFSETS.OccurrenceCount + patternTypeOffset, 2);
+        this.firstDOW = this.readInt(OFFSETS.FirstDOW + patternTypeOffset, 2);
+        this.startDate = winToJsDate(this.readInt(bufferEnd + OFFSETS.StartDate, 2));
+        this.endDate = winToJsDate(this.readInt(bufferEnd + OFFSETS.EndDate, 2));
+    }
+    toJSON() {
+        return {
+            recurFrequency: RecurFrequency[this.recurFrequency],
+            patternType: PatternType[this.patternType],
+            firstDateTime: this.firstDateTime,
+            period: this.period,
+            patternTypeSpecific: this.patternTypeSpecific,
+            endType: EndType[this.endType],
+            occurrenceCount: this.occurrenceCount,
+            firstDOW: this.firstDOW,
+            startDate: this.startDate,
+            endDate: this.endDate,
+        };
+    }
+    readInt(offset, size) {
+        switch (size) {
+            case 1:
+                return this.buffer.readInt16LE(offset);
+            case 2:
+                return this.buffer.readInt32LE(offset);
+        }
+    }
+    readPatternTypeSpecific(type) {
+        switch (type) {
+            case PatternType.Day:
+                return null;
+            case PatternType.Week:
+                return readWeekByte(this.buffer.readInt8(OFFSETS.PatternTypeSpecific));
+            case PatternType.Month:
+            case PatternType.MonthEnd:
+                return this.readInt(OFFSETS.PatternTypeSpecific, 2);
+            case PatternType.MonthNth:
+                return {
+                    weekdays: readWeekByte(this.buffer.readInt8(OFFSETS.PatternTypeSpecific)),
+                    nth: this.readInt(OFFSETS.PatternTypeSpecific + 4, 2),
+                };
+        }
+    }
+}
+exports.RecurrencePattern = RecurrencePattern;
+function winToJsDate(dateInt) {
+    return new Date(dateInt * 60 * 1000 - 1.16444736e13); // subtract milliseconds between 1601-01-01 and 1970-01-01
+}
+function readWeekByte(byte) {
+    const weekArr = [];
+    for (let i = 0; i < 7; ++i) {
+        weekArr.push(Boolean(byte & (1 << i)));
+    }
+    return weekArr;
+}

package/dist/RootProvider.d.ts

@@ -0,0 +1,12 @@
+import { PropertyFinder } from "./PAUtil";
+import { PLNode } from "./PLNode";
+import { PLSubNode } from "./PLSubNode";
+import { PropertyValueResolver } from "./PropertyValueResolver";
+import { PSTFolder } from "./PSTFolder.class";
+import { PSTMessage } from "./PSTMessage.class";
+export interface RootProvider {
+    resolver: PropertyValueResolver;
+    getNameToIdMapItem(key: number, idx: number): number;
+    getItemOf(node: PLNode, subNode: PLSubNode, propertyFinder: PropertyFinder | undefined): Promise<PSTMessage>;
+    getFolderOf(node: PLNode): Promise<PSTFolder>;
+}

package/dist/RootProvider.js

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

package/dist/SingleAsyncProvider.d.ts

@@ -0,0 +1,5 @@
+export declare class SingleAsyncProvider<T> {
+    private _value;
+    private _ready;
+    getOrCreate(provider: () => Promise<T>): Promise<T>;
+}