Initial commit

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

node_modules/pe-library/dist/format/ArrayFormatBase.d.ts

@@ -0,0 +1,14 @@
+import FormatBase from './FormatBase.js';
+/** abstract class that support array-like methods and 'for...of' operation */
+declare abstract class ArrayFormatBase<T> extends FormatBase {
+    protected constructor(view: DataView);
+    abstract readonly length: number;
+    abstract get(index: number): Readonly<T>;
+    abstract set(index: number, data: T): void;
+    forEach(callback: (value: T, index: number, base: this) => void): void;
+    _iterator(): Iterator<Readonly<T>>;
+}
+interface ArrayFormatBase<T> {
+    [Symbol.iterator]: () => Iterator<Readonly<T>>;
+}
+export default ArrayFormatBase;

node_modules/pe-library/dist/format/ArrayFormatBase.js

@@ -0,0 +1,66 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+/** abstract class that support array-like methods and 'for...of' operation */
+var ArrayFormatBase = /** @class */ (function (_super) {
+    __extends(ArrayFormatBase, _super);
+    function ArrayFormatBase(view) {
+        return _super.call(this, view) || this;
+    }
+    ArrayFormatBase.prototype.forEach = function (callback) {
+        var len = this.length;
+        var a = [];
+        a.length = len;
+        for (var i = 0; i < len; ++i) {
+            a[i] = this.get(i);
+        }
+        for (var i = 0; i < len; ++i) {
+            callback(a[i], i, this);
+        }
+    };
+    ArrayFormatBase.prototype._iterator = function () {
+        return new (/** @class */ (function () {
+            function class_1(base) {
+                this.base = base;
+                this.i = 0;
+            }
+            class_1.prototype.next = function () {
+                if (this.i === this.base.length) {
+                    return {
+                        value: undefined,
+                        done: true,
+                    };
+                }
+                else {
+                    return {
+                        value: this.base.get(this.i++),
+                        done: false,
+                    };
+                }
+            };
+            return class_1;
+        }()))(this);
+    };
+    return ArrayFormatBase;
+}(FormatBase_js_1.default));
+/* istanbul ignore else */
+if (typeof Symbol !== 'undefined') {
+    ArrayFormatBase.prototype[Symbol.iterator] =
+        ArrayFormatBase.prototype._iterator;
+}
+exports.default = ArrayFormatBase;

node_modules/pe-library/dist/format/FormatBase.d.ts

@@ -0,0 +1,6 @@
+export default abstract class FormatBase {
+    protected readonly view: DataView;
+    protected constructor(view: DataView);
+    copyTo(bin: ArrayBuffer, offset: number): void;
+    get byteLength(): number;
+}

node_modules/pe-library/dist/format/FormatBase.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase = /** @class */ (function () {
+    function FormatBase(view) {
+        this.view = view;
+    }
+    FormatBase.prototype.copyTo = function (bin, offset) {
+        new Uint8Array(bin, offset, this.view.byteLength).set(new Uint8Array(this.view.buffer, this.view.byteOffset, this.view.byteLength));
+    };
+    Object.defineProperty(FormatBase.prototype, "byteLength", {
+        get: function () {
+            return this.view.byteLength;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return FormatBase;
+}());
+exports.default = FormatBase;

node_modules/pe-library/dist/format/ImageDataDirectoryArray.d.ts

@@ -0,0 +1,16 @@
+import ArrayFormatBase from './ArrayFormatBase.js';
+export interface ImageDataDirectory {
+    virtualAddress: number;
+    size: number;
+}
+export default class ImageDataDirectoryArray extends ArrayFormatBase<ImageDataDirectory> {
+    static readonly size = 128;
+    static readonly itemSize = 8;
+    readonly length = 16;
+    private constructor();
+    /** @note This does not clone binary data; the changes to the array will modify the specified buffer `bin` */
+    static from(bin: ArrayBuffer, offset?: number): ImageDataDirectoryArray;
+    get(index: number): Readonly<ImageDataDirectory>;
+    set(index: number, data: ImageDataDirectory): void;
+    findIndexByVirtualAddress(virtualAddress: number): number | null;
+}

node_modules/pe-library/dist/format/ImageDataDirectoryArray.js

@@ -0,0 +1,55 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ArrayFormatBase_js_1 = require("./ArrayFormatBase.js");
+var ImageDataDirectoryArray = /** @class */ (function (_super) {
+    __extends(ImageDataDirectoryArray, _super);
+    function ImageDataDirectoryArray(view) {
+        var _this = _super.call(this, view) || this;
+        _this.length = 16;
+        return _this;
+    }
+    /** @note This does not clone binary data; the changes to the array will modify the specified buffer `bin` */
+    ImageDataDirectoryArray.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        return new ImageDataDirectoryArray(new DataView(bin, offset, 128));
+    };
+    ImageDataDirectoryArray.prototype.get = function (index) {
+        return {
+            virtualAddress: this.view.getUint32(index * 8, true),
+            size: this.view.getUint32(4 + index * 8, true),
+        };
+    };
+    ImageDataDirectoryArray.prototype.set = function (index, data) {
+        this.view.setUint32(index * 8, data.virtualAddress, true);
+        this.view.setUint32(4 + index * 8, data.size, true);
+    };
+    ImageDataDirectoryArray.prototype.findIndexByVirtualAddress = function (virtualAddress) {
+        for (var i = 0; i < 16; ++i) {
+            var va = this.view.getUint32(i * 8, true);
+            var vs = this.view.getUint32(4 + i * 8, true);
+            if (virtualAddress >= va && virtualAddress < va + vs) {
+                return i;
+            }
+        }
+        return null;
+    };
+    ImageDataDirectoryArray.size = 128; // 16 * 8
+    ImageDataDirectoryArray.itemSize = 8;
+    return ImageDataDirectoryArray;
+}(ArrayFormatBase_js_1.default));
+exports.default = ImageDataDirectoryArray;

node_modules/pe-library/dist/format/ImageDirectoryEntry.d.ts

@@ -0,0 +1,22 @@
+declare enum ImageDirectoryEntry {
+    Export = 0,
+    Import = 1,
+    Resource = 2,
+    Exception = 3,
+    Certificate = 4,
+    Security = 4,
+    BaseRelocation = 5,
+    Debug = 6,
+    Architecture = 7,
+    GlobalPointer = 8,
+    Tls = 9,
+    TLS = 9,
+    LoadConfig = 10,
+    BoundImport = 11,
+    Iat = 12,
+    IAT = 12,
+    DelayImport = 13,
+    ComDescriptor = 14,
+    COMDescriptor = 14
+}
+export default ImageDirectoryEntry;

node_modules/pe-library/dist/format/ImageDirectoryEntry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ImageDirectoryEntry;
+(function (ImageDirectoryEntry) {
+    ImageDirectoryEntry[ImageDirectoryEntry["Export"] = 0] = "Export";
+    ImageDirectoryEntry[ImageDirectoryEntry["Import"] = 1] = "Import";
+    ImageDirectoryEntry[ImageDirectoryEntry["Resource"] = 2] = "Resource";
+    ImageDirectoryEntry[ImageDirectoryEntry["Exception"] = 3] = "Exception";
+    ImageDirectoryEntry[ImageDirectoryEntry["Certificate"] = 4] = "Certificate";
+    // alias
+    ImageDirectoryEntry[ImageDirectoryEntry["Security"] = 4] = "Security";
+    ImageDirectoryEntry[ImageDirectoryEntry["BaseRelocation"] = 5] = "BaseRelocation";
+    ImageDirectoryEntry[ImageDirectoryEntry["Debug"] = 6] = "Debug";
+    ImageDirectoryEntry[ImageDirectoryEntry["Architecture"] = 7] = "Architecture";
+    ImageDirectoryEntry[ImageDirectoryEntry["GlobalPointer"] = 8] = "GlobalPointer";
+    ImageDirectoryEntry[ImageDirectoryEntry["Tls"] = 9] = "Tls";
+    ImageDirectoryEntry[ImageDirectoryEntry["TLS"] = 9] = "TLS";
+    ImageDirectoryEntry[ImageDirectoryEntry["LoadConfig"] = 10] = "LoadConfig";
+    ImageDirectoryEntry[ImageDirectoryEntry["BoundImport"] = 11] = "BoundImport";
+    ImageDirectoryEntry[ImageDirectoryEntry["Iat"] = 12] = "Iat";
+    ImageDirectoryEntry[ImageDirectoryEntry["IAT"] = 12] = "IAT";
+    ImageDirectoryEntry[ImageDirectoryEntry["DelayImport"] = 13] = "DelayImport";
+    ImageDirectoryEntry[ImageDirectoryEntry["ComDescriptor"] = 14] = "ComDescriptor";
+    ImageDirectoryEntry[ImageDirectoryEntry["COMDescriptor"] = 14] = "COMDescriptor";
+})(ImageDirectoryEntry || (ImageDirectoryEntry = {}));
+exports.default = ImageDirectoryEntry;

node_modules/pe-library/dist/format/ImageDosHeader.d.ts

@@ -0,0 +1,42 @@
+import FormatBase from './FormatBase.js';
+export default class ImageDosHeader extends FormatBase {
+    static readonly size = 64;
+    static readonly DEFAULT_MAGIC = 23117;
+    private constructor();
+    static from(bin: ArrayBuffer | ArrayBufferView, offset?: number): ImageDosHeader;
+    isValid(): boolean;
+    get magic(): number;
+    set magic(val: number);
+    get lastPageSize(): number;
+    set lastPageSize(val: number);
+    get pages(): number;
+    set pages(val: number);
+    get relocations(): number;
+    set relocations(val: number);
+    get headerSizeInParagraph(): number;
+    set headerSizeInParagraph(val: number);
+    get minAllocParagraphs(): number;
+    set minAllocParagraphs(val: number);
+    get maxAllocParagraphs(): number;
+    set maxAllocParagraphs(val: number);
+    get initialSS(): number;
+    set initialSS(val: number);
+    get initialSP(): number;
+    set initialSP(val: number);
+    get checkSum(): number;
+    set checkSum(val: number);
+    get initialIP(): number;
+    set initialIP(val: number);
+    get initialCS(): number;
+    set initialCS(val: number);
+    get relocationTableAddress(): number;
+    set relocationTableAddress(val: number);
+    get overlayNum(): number;
+    set overlayNum(val: number);
+    get oemId(): number;
+    set oemId(val: number);
+    get oemInfo(): number;
+    set oemInfo(val: number);
+    get newHeaderAddress(): number;
+    set newHeaderAddress(val: number);
+}

node_modules/pe-library/dist/format/ImageDosHeader.js

@@ -0,0 +1,208 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+var functions_js_1 = require("../util/functions.js");
+var ImageDosHeader = /** @class */ (function (_super) {
+    __extends(ImageDosHeader, _super);
+    function ImageDosHeader(view) {
+        return _super.call(this, view) || this;
+    }
+    ImageDosHeader.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        return new ImageDosHeader(functions_js_1.createDataView(bin, offset, 64));
+    };
+    ImageDosHeader.prototype.isValid = function () {
+        return this.magic === ImageDosHeader.DEFAULT_MAGIC;
+    };
+    Object.defineProperty(ImageDosHeader.prototype, "magic", {
+        get: function () {
+            return this.view.getUint16(0, true);
+        },
+        set: function (val) {
+            this.view.setUint16(0, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "lastPageSize", {
+        get: function () {
+            return this.view.getUint16(2, true);
+        },
+        set: function (val) {
+            this.view.setUint16(2, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "pages", {
+        get: function () {
+            return this.view.getUint16(4, true);
+        },
+        set: function (val) {
+            this.view.setUint16(4, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "relocations", {
+        get: function () {
+            return this.view.getUint16(6, true);
+        },
+        set: function (val) {
+            this.view.setUint16(6, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "headerSizeInParagraph", {
+        get: function () {
+            return this.view.getUint16(8, true);
+        },
+        set: function (val) {
+            this.view.setUint16(8, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "minAllocParagraphs", {
+        get: function () {
+            return this.view.getUint16(10, true);
+        },
+        set: function (val) {
+            this.view.setUint16(10, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "maxAllocParagraphs", {
+        get: function () {
+            return this.view.getUint16(12, true);
+        },
+        set: function (val) {
+            this.view.setUint16(12, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "initialSS", {
+        get: function () {
+            return this.view.getUint16(14, true);
+        },
+        set: function (val) {
+            this.view.setUint16(14, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "initialSP", {
+        get: function () {
+            return this.view.getUint16(16, true);
+        },
+        set: function (val) {
+            this.view.setUint16(16, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "checkSum", {
+        get: function () {
+            return this.view.getUint16(18, true);
+        },
+        set: function (val) {
+            this.view.setUint16(18, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "initialIP", {
+        get: function () {
+            return this.view.getUint16(20, true);
+        },
+        set: function (val) {
+            this.view.setUint16(20, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "initialCS", {
+        get: function () {
+            return this.view.getUint16(22, true);
+        },
+        set: function (val) {
+            this.view.setUint16(22, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "relocationTableAddress", {
+        get: function () {
+            return this.view.getUint16(24, true);
+        },
+        set: function (val) {
+            this.view.setUint16(24, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "overlayNum", {
+        get: function () {
+            return this.view.getUint16(26, true);
+        },
+        set: function (val) {
+            this.view.setUint16(26, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "oemId", {
+        // WORD e_res[4] (28,30,32,34)
+        get: function () {
+            return this.view.getUint16(36, true);
+        },
+        set: function (val) {
+            this.view.setUint16(36, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "oemInfo", {
+        get: function () {
+            return this.view.getUint16(38, true);
+        },
+        set: function (val) {
+            this.view.setUint16(38, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageDosHeader.prototype, "newHeaderAddress", {
+        // WORD e_res2[10] (40,42,44,46,48,50,52,54,56,58)
+        get: function () {
+            return this.view.getUint32(60, true);
+        },
+        set: function (val) {
+            this.view.setUint32(60, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ImageDosHeader.size = 64;
+    ImageDosHeader.DEFAULT_MAGIC = 0x5a4d; // 'MZ'
+    return ImageDosHeader;
+}(FormatBase_js_1.default));
+exports.default = ImageDosHeader;

node_modules/pe-library/dist/format/ImageFileHeader.d.ts

@@ -0,0 +1,20 @@
+import FormatBase from './FormatBase.js';
+export default class ImageFileHeader extends FormatBase {
+    static readonly size = 20;
+    private constructor();
+    static from(bin: ArrayBuffer, offset?: number): ImageFileHeader;
+    get machine(): number;
+    set machine(val: number);
+    get numberOfSections(): number;
+    set numberOfSections(val: number);
+    get timeDateStamp(): number;
+    set timeDateStamp(val: number);
+    get pointerToSymbolTable(): number;
+    set pointerToSymbolTable(val: number);
+    get numberOfSymbols(): number;
+    set numberOfSymbols(val: number);
+    get sizeOfOptionalHeader(): number;
+    set sizeOfOptionalHeader(val: number);
+    get characteristics(): number;
+    set characteristics(val: number);
+}

node_modules/pe-library/dist/format/ImageFileHeader.js

@@ -0,0 +1,101 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+var ImageFileHeader = /** @class */ (function (_super) {
+    __extends(ImageFileHeader, _super);
+    function ImageFileHeader(view) {
+        return _super.call(this, view) || this;
+    }
+    ImageFileHeader.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        return new ImageFileHeader(new DataView(bin, offset, 20));
+    };
+    Object.defineProperty(ImageFileHeader.prototype, "machine", {
+        get: function () {
+            return this.view.getUint16(0, true);
+        },
+        set: function (val) {
+            this.view.setUint16(0, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "numberOfSections", {
+        get: function () {
+            return this.view.getUint16(2, true);
+        },
+        set: function (val) {
+            this.view.setUint16(2, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "timeDateStamp", {
+        get: function () {
+            return this.view.getUint32(4, true);
+        },
+        set: function (val) {
+            this.view.setUint32(4, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "pointerToSymbolTable", {
+        get: function () {
+            return this.view.getUint32(8, true);
+        },
+        set: function (val) {
+            this.view.setUint32(8, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "numberOfSymbols", {
+        get: function () {
+            return this.view.getUint32(12, true);
+        },
+        set: function (val) {
+            this.view.setUint32(12, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "sizeOfOptionalHeader", {
+        get: function () {
+            return this.view.getUint16(16, true);
+        },
+        set: function (val) {
+            this.view.setUint16(16, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageFileHeader.prototype, "characteristics", {
+        get: function () {
+            return this.view.getUint16(18, true);
+        },
+        set: function (val) {
+            this.view.setUint16(18, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ImageFileHeader.size = 20;
+    return ImageFileHeader;
+}(FormatBase_js_1.default));
+exports.default = ImageFileHeader;

node_modules/pe-library/dist/format/ImageNtHeaders.d.ts

@@ -0,0 +1,19 @@
+import FormatBase from './FormatBase.js';
+import ImageFileHeader from './ImageFileHeader.js';
+import ImageOptionalHeader from './ImageOptionalHeader.js';
+import ImageOptionalHeader64 from './ImageOptionalHeader64.js';
+import ImageDataDirectoryArray from './ImageDataDirectoryArray.js';
+export default class ImageNtHeaders extends FormatBase {
+    static readonly DEFAULT_SIGNATURE = 17744;
+    private constructor();
+    static from(bin: ArrayBuffer | ArrayBufferView, offset?: number): ImageNtHeaders;
+    isValid(): boolean;
+    is32bit(): boolean;
+    get signature(): number;
+    set signature(val: number);
+    get fileHeader(): ImageFileHeader;
+    get optionalHeader(): ImageOptionalHeader | ImageOptionalHeader64;
+    get optionalHeaderDataDirectory(): ImageDataDirectoryArray;
+    getDataDirectoryOffset(): number;
+    getSectionHeaderOffset(): number;
+}

node_modules/pe-library/dist/format/ImageNtHeaders.js

@@ -0,0 +1,103 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+var ImageFileHeader_js_1 = require("./ImageFileHeader.js");
+var ImageOptionalHeader_js_1 = require("./ImageOptionalHeader.js");
+var ImageOptionalHeader64_js_1 = require("./ImageOptionalHeader64.js");
+var ImageDataDirectoryArray_js_1 = require("./ImageDataDirectoryArray.js");
+var functions_js_1 = require("../util/functions.js");
+var ImageNtHeaders = /** @class */ (function (_super) {
+    __extends(ImageNtHeaders, _super);
+    function ImageNtHeaders(view) {
+        return _super.call(this, view) || this;
+    }
+    ImageNtHeaders.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        var magic = functions_js_1.createDataView(bin, offset + ImageFileHeader_js_1.default.size, 6).getUint16(4, true);
+        var len = 4 + ImageFileHeader_js_1.default.size + ImageDataDirectoryArray_js_1.default.size;
+        if (magic === ImageOptionalHeader64_js_1.default.DEFAULT_MAGIC) {
+            len += ImageOptionalHeader64_js_1.default.size;
+        }
+        else {
+            len += ImageOptionalHeader_js_1.default.size;
+        }
+        return new ImageNtHeaders(functions_js_1.createDataView(bin, offset, len));
+    };
+    ImageNtHeaders.prototype.isValid = function () {
+        return this.signature === ImageNtHeaders.DEFAULT_SIGNATURE;
+    };
+    ImageNtHeaders.prototype.is32bit = function () {
+        return (this.view.getUint16(ImageFileHeader_js_1.default.size + 4, true) ===
+            ImageOptionalHeader_js_1.default.DEFAULT_MAGIC);
+    };
+    Object.defineProperty(ImageNtHeaders.prototype, "signature", {
+        get: function () {
+            return this.view.getUint32(0, true);
+        },
+        set: function (val) {
+            this.view.setUint32(0, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageNtHeaders.prototype, "fileHeader", {
+        get: function () {
+            return ImageFileHeader_js_1.default.from(this.view.buffer, this.view.byteOffset + 4);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageNtHeaders.prototype, "optionalHeader", {
+        get: function () {
+            var off = ImageFileHeader_js_1.default.size + 4;
+            var magic = this.view.getUint16(off, true);
+            if (magic === ImageOptionalHeader64_js_1.default.DEFAULT_MAGIC) {
+                return ImageOptionalHeader64_js_1.default.from(this.view.buffer, this.view.byteOffset + off);
+            }
+            else {
+                return ImageOptionalHeader_js_1.default.from(this.view.buffer, this.view.byteOffset + off);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageNtHeaders.prototype, "optionalHeaderDataDirectory", {
+        get: function () {
+            return ImageDataDirectoryArray_js_1.default.from(this.view.buffer, this.view.byteOffset + this.getDataDirectoryOffset());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ImageNtHeaders.prototype.getDataDirectoryOffset = function () {
+        var off = ImageFileHeader_js_1.default.size + 4;
+        var magic = this.view.getUint16(off, true);
+        if (magic === ImageOptionalHeader64_js_1.default.DEFAULT_MAGIC) {
+            off += ImageOptionalHeader64_js_1.default.size;
+        }
+        else {
+            off += ImageOptionalHeader_js_1.default.size;
+        }
+        return off;
+    };
+    ImageNtHeaders.prototype.getSectionHeaderOffset = function () {
+        return this.getDataDirectoryOffset() + ImageDataDirectoryArray_js_1.default.size;
+    };
+    ImageNtHeaders.DEFAULT_SIGNATURE = 0x4550; // 'PE\x00\x00'
+    return ImageNtHeaders;
+}(FormatBase_js_1.default));
+exports.default = ImageNtHeaders;

node_modules/pe-library/dist/format/ImageOptionalHeader.d.ts

@@ -0,0 +1,67 @@
+import FormatBase from './FormatBase.js';
+export default class ImageOptionalHeader extends FormatBase {
+    static readonly size = 96;
+    static readonly DEFAULT_MAGIC = 267;
+    private constructor();
+    static from(bin: ArrayBuffer, offset?: number): ImageOptionalHeader;
+    get magic(): number;
+    set magic(val: number);
+    get majorLinkerVersion(): number;
+    set majorLinkerVersion(val: number);
+    get minorLinkerVersion(): number;
+    set minorLinkerVersion(val: number);
+    get sizeOfCode(): number;
+    set sizeOfCode(val: number);
+    get sizeOfInitializedData(): number;
+    set sizeOfInitializedData(val: number);
+    get sizeOfUninitializedData(): number;
+    set sizeOfUninitializedData(val: number);
+    get addressOfEntryPoint(): number;
+    set addressOfEntryPoint(val: number);
+    get baseOfCode(): number;
+    set baseOfCode(val: number);
+    get baseOfData(): number;
+    set baseOfData(val: number);
+    get imageBase(): number;
+    set imageBase(val: number);
+    get sectionAlignment(): number;
+    set sectionAlignment(val: number);
+    get fileAlignment(): number;
+    set fileAlignment(val: number);
+    get majorOperatingSystemVersion(): number;
+    set majorOperatingSystemVersion(val: number);
+    get minorOperatingSystemVersion(): number;
+    set minorOperatingSystemVersion(val: number);
+    get majorImageVersion(): number;
+    set majorImageVersion(val: number);
+    get minorImageVersion(): number;
+    set minorImageVersion(val: number);
+    get majorSubsystemVersion(): number;
+    set majorSubsystemVersion(val: number);
+    get minorSubsystemVersion(): number;
+    set minorSubsystemVersion(val: number);
+    get win32VersionValue(): number;
+    set win32VersionValue(val: number);
+    get sizeOfImage(): number;
+    set sizeOfImage(val: number);
+    get sizeOfHeaders(): number;
+    set sizeOfHeaders(val: number);
+    get checkSum(): number;
+    set checkSum(val: number);
+    get subsystem(): number;
+    set subsystem(val: number);
+    get dllCharacteristics(): number;
+    set dllCharacteristics(val: number);
+    get sizeOfStackReserve(): number;
+    set sizeOfStackReserve(val: number);
+    get sizeOfStackCommit(): number;
+    set sizeOfStackCommit(val: number);
+    get sizeOfHeapReserve(): number;
+    set sizeOfHeapReserve(val: number);
+    get sizeOfHeapCommit(): number;
+    set sizeOfHeapCommit(val: number);
+    get loaderFlags(): number;
+    set loaderFlags(val: number);
+    get numberOfRvaAndSizes(): number;
+    set numberOfRvaAndSizes(val: number);
+}

node_modules/pe-library/dist/format/ImageOptionalHeader.js

@@ -0,0 +1,332 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+var ImageOptionalHeader = /** @class */ (function (_super) {
+    __extends(ImageOptionalHeader, _super);
+    function ImageOptionalHeader(view) {
+        return _super.call(this, view) || this;
+    }
+    ImageOptionalHeader.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        return new ImageOptionalHeader(new DataView(bin, offset, 96));
+    };
+    Object.defineProperty(ImageOptionalHeader.prototype, "magic", {
+        get: function () {
+            return this.view.getUint16(0, true);
+        },
+        set: function (val) {
+            this.view.setUint16(0, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "majorLinkerVersion", {
+        get: function () {
+            return this.view.getUint8(2);
+        },
+        set: function (val) {
+            this.view.setUint8(2, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "minorLinkerVersion", {
+        get: function () {
+            return this.view.getUint8(3);
+        },
+        set: function (val) {
+            this.view.setUint8(3, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfCode", {
+        get: function () {
+            return this.view.getUint32(4, true);
+        },
+        set: function (val) {
+            this.view.setUint32(4, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfInitializedData", {
+        get: function () {
+            return this.view.getUint32(8, true);
+        },
+        set: function (val) {
+            this.view.setUint32(8, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfUninitializedData", {
+        get: function () {
+            return this.view.getUint32(12, true);
+        },
+        set: function (val) {
+            this.view.setUint32(12, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "addressOfEntryPoint", {
+        get: function () {
+            return this.view.getUint32(16, true);
+        },
+        set: function (val) {
+            this.view.setUint32(16, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "baseOfCode", {
+        get: function () {
+            return this.view.getUint32(20, true);
+        },
+        set: function (val) {
+            this.view.setUint32(20, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "baseOfData", {
+        get: function () {
+            return this.view.getUint32(24, true);
+        },
+        set: function (val) {
+            this.view.setUint32(24, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "imageBase", {
+        get: function () {
+            return this.view.getUint32(28, true);
+        },
+        set: function (val) {
+            this.view.setUint32(28, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sectionAlignment", {
+        get: function () {
+            return this.view.getUint32(32, true);
+        },
+        set: function (val) {
+            this.view.setUint32(32, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "fileAlignment", {
+        get: function () {
+            return this.view.getUint32(36, true);
+        },
+        set: function (val) {
+            this.view.setUint32(36, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "majorOperatingSystemVersion", {
+        get: function () {
+            return this.view.getUint16(40, true);
+        },
+        set: function (val) {
+            this.view.setUint16(40, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "minorOperatingSystemVersion", {
+        get: function () {
+            return this.view.getUint16(42, true);
+        },
+        set: function (val) {
+            this.view.setUint16(42, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "majorImageVersion", {
+        get: function () {
+            return this.view.getUint16(44, true);
+        },
+        set: function (val) {
+            this.view.setUint16(44, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "minorImageVersion", {
+        get: function () {
+            return this.view.getUint16(46, true);
+        },
+        set: function (val) {
+            this.view.setUint16(46, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "majorSubsystemVersion", {
+        get: function () {
+            return this.view.getUint16(48, true);
+        },
+        set: function (val) {
+            this.view.setUint16(48, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "minorSubsystemVersion", {
+        get: function () {
+            return this.view.getUint16(50, true);
+        },
+        set: function (val) {
+            this.view.setUint16(50, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "win32VersionValue", {
+        get: function () {
+            return this.view.getUint32(52, true);
+        },
+        set: function (val) {
+            this.view.setUint32(52, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfImage", {
+        get: function () {
+            return this.view.getUint32(56, true);
+        },
+        set: function (val) {
+            this.view.setUint32(56, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfHeaders", {
+        get: function () {
+            return this.view.getUint32(60, true);
+        },
+        set: function (val) {
+            this.view.setUint32(60, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "checkSum", {
+        get: function () {
+            return this.view.getUint32(64, true);
+        },
+        set: function (val) {
+            this.view.setUint32(64, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "subsystem", {
+        get: function () {
+            return this.view.getUint16(68, true);
+        },
+        set: function (val) {
+            this.view.setUint16(68, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "dllCharacteristics", {
+        get: function () {
+            return this.view.getUint16(70, true);
+        },
+        set: function (val) {
+            this.view.setUint16(70, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfStackReserve", {
+        get: function () {
+            return this.view.getUint32(72, true);
+        },
+        set: function (val) {
+            this.view.setUint32(72, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfStackCommit", {
+        get: function () {
+            return this.view.getUint32(76, true);
+        },
+        set: function (val) {
+            this.view.setUint32(76, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfHeapReserve", {
+        get: function () {
+            return this.view.getUint32(80, true);
+        },
+        set: function (val) {
+            this.view.setUint32(80, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "sizeOfHeapCommit", {
+        get: function () {
+            return this.view.getUint32(84, true);
+        },
+        set: function (val) {
+            this.view.setUint32(84, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "loaderFlags", {
+        get: function () {
+            return this.view.getUint32(88, true);
+        },
+        set: function (val) {
+            this.view.setUint32(88, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader.prototype, "numberOfRvaAndSizes", {
+        get: function () {
+            return this.view.getUint32(92, true);
+        },
+        set: function (val) {
+            this.view.setUint32(92, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ImageOptionalHeader.size = 96;
+    ImageOptionalHeader.DEFAULT_MAGIC = 0x10b;
+    return ImageOptionalHeader;
+}(FormatBase_js_1.default));
+exports.default = ImageOptionalHeader;

node_modules/pe-library/dist/format/ImageOptionalHeader64.d.ts

@@ -0,0 +1,75 @@
+import FormatBase from './FormatBase.js';
+export default class ImageOptionalHeader64 extends FormatBase {
+    static readonly size = 112;
+    static readonly DEFAULT_MAGIC = 523;
+    private constructor();
+    static from(bin: ArrayBuffer, offset?: number): ImageOptionalHeader64;
+    get magic(): number;
+    set magic(val: number);
+    get majorLinkerVersion(): number;
+    set majorLinkerVersion(val: number);
+    get minorLinkerVersion(): number;
+    set minorLinkerVersion(val: number);
+    get sizeOfCode(): number;
+    set sizeOfCode(val: number);
+    get sizeOfInitializedData(): number;
+    set sizeOfInitializedData(val: number);
+    get sizeOfUninitializedData(): number;
+    set sizeOfUninitializedData(val: number);
+    get addressOfEntryPoint(): number;
+    set addressOfEntryPoint(val: number);
+    get baseOfCode(): number;
+    set baseOfCode(val: number);
+    get imageBase(): number;
+    set imageBase(val: number);
+    get imageBaseBigInt(): bigint;
+    set imageBaseBigInt(val: bigint);
+    get sectionAlignment(): number;
+    set sectionAlignment(val: number);
+    get fileAlignment(): number;
+    set fileAlignment(val: number);
+    get majorOperatingSystemVersion(): number;
+    set majorOperatingSystemVersion(val: number);
+    get minorOperatingSystemVersion(): number;
+    set minorOperatingSystemVersion(val: number);
+    get majorImageVersion(): number;
+    set majorImageVersion(val: number);
+    get minorImageVersion(): number;
+    set minorImageVersion(val: number);
+    get majorSubsystemVersion(): number;
+    set majorSubsystemVersion(val: number);
+    get minorSubsystemVersion(): number;
+    set minorSubsystemVersion(val: number);
+    get win32VersionValue(): number;
+    set win32VersionValue(val: number);
+    get sizeOfImage(): number;
+    set sizeOfImage(val: number);
+    get sizeOfHeaders(): number;
+    set sizeOfHeaders(val: number);
+    get checkSum(): number;
+    set checkSum(val: number);
+    get subsystem(): number;
+    set subsystem(val: number);
+    get dllCharacteristics(): number;
+    set dllCharacteristics(val: number);
+    get sizeOfStackReserve(): number;
+    set sizeOfStackReserve(val: number);
+    get sizeOfStackReserveBigInt(): bigint;
+    set sizeOfStackReserveBigInt(val: bigint);
+    get sizeOfStackCommit(): number;
+    set sizeOfStackCommit(val: number);
+    get sizeOfStackCommitBigInt(): bigint;
+    set sizeOfStackCommitBigInt(val: bigint);
+    get sizeOfHeapReserve(): number;
+    set sizeOfHeapReserve(val: number);
+    get sizeOfHeapReserveBigInt(): bigint;
+    set sizeOfHeapReserveBigInt(val: bigint);
+    get sizeOfHeapCommit(): number;
+    set sizeOfHeapCommit(val: number);
+    get sizeOfHeapCommitBigInt(): bigint;
+    set sizeOfHeapCommitBigInt(val: bigint);
+    get loaderFlags(): number;
+    set loaderFlags(val: number);
+    get numberOfRvaAndSizes(): number;
+    set numberOfRvaAndSizes(val: number);
+}

node_modules/pe-library/dist/format/ImageOptionalHeader64.js

@@ -0,0 +1,396 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var FormatBase_js_1 = require("./FormatBase.js");
+function getUint64LE(view, offset) {
+    return (view.getUint32(offset + 4, true) * 0x100000000 +
+        view.getUint32(offset, true));
+}
+function setUint64LE(view, offset, val) {
+    view.setUint32(offset, val & 0xffffffff, true);
+    view.setUint32(offset + 4, Math.floor(val / 0x100000000), true);
+}
+function getUint64LEBigInt(view, offset) {
+    /* istanbul ignore if */
+    if (typeof BigInt === 'undefined') {
+        throw new Error('BigInt not supported');
+    }
+    return (BigInt(0x100000000) * BigInt(view.getUint32(offset + 4, true)) +
+        BigInt(view.getUint32(offset, true)));
+}
+function setUint64LEBigInt(view, offset, val) {
+    /* istanbul ignore if */
+    if (typeof BigInt === 'undefined') {
+        throw new Error('BigInt not supported');
+    }
+    view.setUint32(offset, Number(val & BigInt(0xffffffff)), true);
+    view.setUint32(offset + 4, Math.floor(Number((val / BigInt(0x100000000)) & BigInt(0xffffffff))), true);
+}
+var ImageOptionalHeader64 = /** @class */ (function (_super) {
+    __extends(ImageOptionalHeader64, _super);
+    function ImageOptionalHeader64(view) {
+        return _super.call(this, view) || this;
+    }
+    ImageOptionalHeader64.from = function (bin, offset) {
+        if (offset === void 0) { offset = 0; }
+        return new ImageOptionalHeader64(new DataView(bin, offset, 112));
+    };
+    Object.defineProperty(ImageOptionalHeader64.prototype, "magic", {
+        get: function () {
+            return this.view.getUint16(0, true);
+        },
+        set: function (val) {
+            this.view.setUint16(0, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "majorLinkerVersion", {
+        get: function () {
+            return this.view.getUint8(2);
+        },
+        set: function (val) {
+            this.view.setUint8(2, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "minorLinkerVersion", {
+        get: function () {
+            return this.view.getUint8(3);
+        },
+        set: function (val) {
+            this.view.setUint8(3, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfCode", {
+        get: function () {
+            return this.view.getUint32(4, true);
+        },
+        set: function (val) {
+            this.view.setUint32(4, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfInitializedData", {
+        get: function () {
+            return this.view.getUint32(8, true);
+        },
+        set: function (val) {
+            this.view.setUint32(8, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfUninitializedData", {
+        get: function () {
+            return this.view.getUint32(12, true);
+        },
+        set: function (val) {
+            this.view.setUint32(12, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "addressOfEntryPoint", {
+        get: function () {
+            return this.view.getUint32(16, true);
+        },
+        set: function (val) {
+            this.view.setUint32(16, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "baseOfCode", {
+        get: function () {
+            return this.view.getUint32(20, true);
+        },
+        set: function (val) {
+            this.view.setUint32(20, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "imageBase", {
+        get: function () {
+            return getUint64LE(this.view, 24);
+        },
+        set: function (val) {
+            setUint64LE(this.view, 24, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "imageBaseBigInt", {
+        get: function () {
+            return getUint64LEBigInt(this.view, 24);
+        },
+        set: function (val) {
+            setUint64LEBigInt(this.view, 24, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sectionAlignment", {
+        get: function () {
+            return this.view.getUint32(32, true);
+        },
+        set: function (val) {
+            this.view.setUint32(32, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "fileAlignment", {
+        get: function () {
+            return this.view.getUint32(36, true);
+        },
+        set: function (val) {
+            this.view.setUint32(36, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "majorOperatingSystemVersion", {
+        get: function () {
+            return this.view.getUint16(40, true);
+        },
+        set: function (val) {
+            this.view.setUint16(40, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "minorOperatingSystemVersion", {
+        get: function () {
+            return this.view.getUint16(42, true);
+        },
+        set: function (val) {
+            this.view.setUint16(42, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "majorImageVersion", {
+        get: function () {
+            return this.view.getUint16(44, true);
+        },
+        set: function (val) {
+            this.view.setUint16(44, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "minorImageVersion", {
+        get: function () {
+            return this.view.getUint16(46, true);
+        },
+        set: function (val) {
+            this.view.setUint16(46, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "majorSubsystemVersion", {
+        get: function () {
+            return this.view.getUint16(48, true);
+        },
+        set: function (val) {
+            this.view.setUint16(48, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "minorSubsystemVersion", {
+        get: function () {
+            return this.view.getUint16(50, true);
+        },
+        set: function (val) {
+            this.view.setUint16(50, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "win32VersionValue", {
+        get: function () {
+            return this.view.getUint32(52, true);
+        },
+        set: function (val) {
+            this.view.setUint32(52, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfImage", {
+        get: function () {
+            return this.view.getUint32(56, true);
+        },
+        set: function (val) {
+            this.view.setUint32(56, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfHeaders", {
+        get: function () {
+            return this.view.getUint32(60, true);
+        },
+        set: function (val) {
+            this.view.setUint32(60, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "checkSum", {
+        get: function () {
+            return this.view.getUint32(64, true);
+        },
+        set: function (val) {
+            this.view.setUint32(64, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "subsystem", {
+        get: function () {
+            return this.view.getUint16(68, true);
+        },
+        set: function (val) {
+            this.view.setUint16(68, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "dllCharacteristics", {
+        get: function () {
+            return this.view.getUint16(70, true);
+        },
+        set: function (val) {
+            this.view.setUint16(70, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfStackReserve", {
+        get: function () {
+            return getUint64LE(this.view, 72);
+        },
+        set: function (val) {
+            setUint64LE(this.view, 72, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfStackReserveBigInt", {
+        get: function () {
+            return getUint64LEBigInt(this.view, 72);
+        },
+        set: function (val) {
+            setUint64LEBigInt(this.view, 72, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfStackCommit", {
+        get: function () {
+            return getUint64LE(this.view, 80);
+        },
+        set: function (val) {
+            setUint64LE(this.view, 80, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfStackCommitBigInt", {
+        get: function () {
+            return getUint64LEBigInt(this.view, 80);
+        },
+        set: function (val) {
+            setUint64LEBigInt(this.view, 80, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfHeapReserve", {
+        get: function () {
+            return getUint64LE(this.view, 88);
+        },
+        set: function (val) {
+            setUint64LE(this.view, 88, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfHeapReserveBigInt", {
+        get: function () {
+            return getUint64LEBigInt(this.view, 88);
+        },
+        set: function (val) {
+            setUint64LEBigInt(this.view, 88, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfHeapCommit", {
+        get: function () {
+            return getUint64LE(this.view, 96);
+        },
+        set: function (val) {
+            setUint64LE(this.view, 96, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "sizeOfHeapCommitBigInt", {
+        get: function () {
+            return getUint64LEBigInt(this.view, 96);
+        },
+        set: function (val) {
+            setUint64LEBigInt(this.view, 96, val);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "loaderFlags", {
+        get: function () {
+            return this.view.getUint32(104, true);
+        },
+        set: function (val) {
+            this.view.setUint32(104, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImageOptionalHeader64.prototype, "numberOfRvaAndSizes", {
+        get: function () {
+            return this.view.getUint32(108, true);
+        },
+        set: function (val) {
+            this.view.setUint32(108, val, true);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ImageOptionalHeader64.size = 112;
+    ImageOptionalHeader64.DEFAULT_MAGIC = 0x20b;
+    return ImageOptionalHeader64;
+}(FormatBase_js_1.default));
+exports.default = ImageOptionalHeader64;

node_modules/pe-library/dist/format/ImageSectionHeaderArray.d.ts

@@ -0,0 +1,21 @@
+import ArrayFormatBase from './ArrayFormatBase.js';
+export interface ImageSectionHeader {
+    name: string;
+    virtualSize: number;
+    virtualAddress: number;
+    sizeOfRawData: number;
+    pointerToRawData: number;
+    pointerToRelocations: number;
+    pointerToLineNumbers: number;
+    numberOfRelocations: number;
+    numberOfLineNumbers: number;
+    characteristics: number;
+}
+export default class ImageSectionHeaderArray extends ArrayFormatBase<ImageSectionHeader> {
+    readonly length: number;
+    static readonly itemSize = 40;
+    private constructor();
+    static from(bin: ArrayBuffer, length: number, offset?: number): ImageSectionHeaderArray;
+    get(index: number): Readonly<ImageSectionHeader>;
+    set(index: number, data: ImageSectionHeader): void;
+}

node_modules/pe-library/dist/format/ImageSectionHeaderArray.js

@@ -0,0 +1,61 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+var ArrayFormatBase_js_1 = require("./ArrayFormatBase.js");
+var functions_js_1 = require("../util/functions.js");
+var ImageSectionHeaderArray = /** @class */ (function (_super) {
+    __extends(ImageSectionHeaderArray, _super);
+    function ImageSectionHeaderArray(view, length) {
+        var _this = _super.call(this, view) || this;
+        _this.length = length;
+        return _this;
+    }
+    ImageSectionHeaderArray.from = function (bin, length, offset) {
+        if (offset === void 0) { offset = 0; }
+        var size = length * 40;
+        return new ImageSectionHeaderArray(new DataView(bin, offset, size), length);
+    };
+    ImageSectionHeaderArray.prototype.get = function (index) {
+        return {
+            name: functions_js_1.getFixedString(this.view, index * 40, 8),
+            virtualSize: this.view.getUint32(8 + index * 40, true),
+            virtualAddress: this.view.getUint32(12 + index * 40, true),
+            sizeOfRawData: this.view.getUint32(16 + index * 40, true),
+            pointerToRawData: this.view.getUint32(20 + index * 40, true),
+            pointerToRelocations: this.view.getUint32(24 + index * 40, true),
+            pointerToLineNumbers: this.view.getUint32(28 + index * 40, true),
+            numberOfRelocations: this.view.getUint16(32 + index * 40, true),
+            numberOfLineNumbers: this.view.getUint16(34 + index * 40, true),
+            characteristics: this.view.getUint32(36 + index * 40, true),
+        };
+    };
+    ImageSectionHeaderArray.prototype.set = function (index, data) {
+        functions_js_1.setFixedString(this.view, index * 40, 8, data.name);
+        this.view.setUint32(8 + index * 40, data.virtualSize, true);
+        this.view.setUint32(12 + index * 40, data.virtualAddress, true);
+        this.view.setUint32(16 + index * 40, data.sizeOfRawData, true);
+        this.view.setUint32(20 + index * 40, data.pointerToRawData, true);
+        this.view.setUint32(24 + index * 40, data.pointerToRelocations, true);
+        this.view.setUint32(28 + index * 40, data.pointerToLineNumbers, true);
+        this.view.setUint16(32 + index * 40, data.numberOfRelocations, true);
+        this.view.setUint16(34 + index * 40, data.numberOfLineNumbers, true);
+        this.view.setUint32(36 + index * 40, data.characteristics, true);
+    };
+    ImageSectionHeaderArray.itemSize = 40;
+    return ImageSectionHeaderArray;
+}(ArrayFormatBase_js_1.default));
+exports.default = ImageSectionHeaderArray;

node_modules/pe-library/dist/format/index.d.ts

@@ -0,0 +1,15 @@
+import ArrayFormatBase from './ArrayFormatBase.js';
+import FormatBase from './FormatBase.js';
+import ImageDataDirectoryArray, { ImageDataDirectory } from './ImageDataDirectoryArray.js';
+import ImageDirectoryEntry from './ImageDirectoryEntry.js';
+import ImageDosHeader from './ImageDosHeader.js';
+import ImageFileHeader from './ImageFileHeader.js';
+import ImageNtHeaders from './ImageNtHeaders.js';
+import ImageOptionalHeader from './ImageOptionalHeader.js';
+import ImageOptionalHeader64 from './ImageOptionalHeader64.js';
+import ImageSectionHeaderArray, { ImageSectionHeader } from './ImageSectionHeaderArray.js';
+export { ArrayFormatBase, FormatBase, ImageDataDirectory, ImageDataDirectoryArray, ImageDirectoryEntry, ImageDosHeader, ImageFileHeader, ImageNtHeaders, ImageOptionalHeader, ImageOptionalHeader64, ImageSectionHeader, ImageSectionHeaderArray, };
+export declare function getImageDosHeader(bin: ArrayBuffer): ImageDosHeader;
+export declare function getImageNtHeadersByDosHeader(bin: ArrayBuffer, dosHeader: ImageDosHeader): ImageNtHeaders;
+export declare function getImageSectionHeadersByNtHeaders(bin: ArrayBuffer, dosHeader: ImageDosHeader, ntHeaders: ImageNtHeaders): ImageSectionHeaderArray;
+export declare function findImageSectionBlockByDirectoryEntry(bin: ArrayBuffer, dosHeader: ImageDosHeader, ntHeaders: ImageNtHeaders, entryType: ImageDirectoryEntry): ArrayBuffer | null;

node_modules/pe-library/dist/format/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findImageSectionBlockByDirectoryEntry = exports.getImageSectionHeadersByNtHeaders = exports.getImageNtHeadersByDosHeader = exports.getImageDosHeader = exports.ImageSectionHeaderArray = exports.ImageOptionalHeader64 = exports.ImageOptionalHeader = exports.ImageNtHeaders = exports.ImageFileHeader = exports.ImageDosHeader = exports.ImageDirectoryEntry = exports.ImageDataDirectoryArray = exports.FormatBase = exports.ArrayFormatBase = void 0;
+var ArrayFormatBase_js_1 = require("./ArrayFormatBase.js");
+exports.ArrayFormatBase = ArrayFormatBase_js_1.default;
+var FormatBase_js_1 = require("./FormatBase.js");
+exports.FormatBase = FormatBase_js_1.default;
+var ImageDataDirectoryArray_js_1 = require("./ImageDataDirectoryArray.js");
+exports.ImageDataDirectoryArray = ImageDataDirectoryArray_js_1.default;
+var ImageDirectoryEntry_js_1 = require("./ImageDirectoryEntry.js");
+exports.ImageDirectoryEntry = ImageDirectoryEntry_js_1.default;
+var ImageDosHeader_js_1 = require("./ImageDosHeader.js");
+exports.ImageDosHeader = ImageDosHeader_js_1.default;
+var ImageFileHeader_js_1 = require("./ImageFileHeader.js");
+exports.ImageFileHeader = ImageFileHeader_js_1.default;
+var ImageNtHeaders_js_1 = require("./ImageNtHeaders.js");
+exports.ImageNtHeaders = ImageNtHeaders_js_1.default;
+var ImageOptionalHeader_js_1 = require("./ImageOptionalHeader.js");
+exports.ImageOptionalHeader = ImageOptionalHeader_js_1.default;
+var ImageOptionalHeader64_js_1 = require("./ImageOptionalHeader64.js");
+exports.ImageOptionalHeader64 = ImageOptionalHeader64_js_1.default;
+var ImageSectionHeaderArray_js_1 = require("./ImageSectionHeaderArray.js");
+exports.ImageSectionHeaderArray = ImageSectionHeaderArray_js_1.default;
+function getImageDosHeader(bin) {
+    return ImageDosHeader_js_1.default.from(bin);
+}
+exports.getImageDosHeader = getImageDosHeader;
+function getImageNtHeadersByDosHeader(bin, dosHeader) {
+    return ImageNtHeaders_js_1.default.from(bin, dosHeader.newHeaderAddress);
+}
+exports.getImageNtHeadersByDosHeader = getImageNtHeadersByDosHeader;
+function getImageSectionHeadersByNtHeaders(bin, dosHeader, ntHeaders) {
+    return ImageSectionHeaderArray_js_1.default.from(bin, ntHeaders.fileHeader.numberOfSections, dosHeader.newHeaderAddress + ntHeaders.byteLength);
+}
+exports.getImageSectionHeadersByNtHeaders = getImageSectionHeadersByNtHeaders;
+function findImageSectionBlockByDirectoryEntry(bin, dosHeader, ntHeaders, entryType) {
+    var arr = ImageSectionHeaderArray_js_1.default.from(bin, ntHeaders.fileHeader.numberOfSections, dosHeader.newHeaderAddress + ntHeaders.byteLength);
+    var len = arr.length;
+    var rva = ntHeaders.optionalHeaderDataDirectory.get(entryType).virtualAddress;
+    for (var i = 0; i < len; ++i) {
+        var sec = arr.get(i);
+        var vaEnd = sec.virtualAddress + sec.virtualSize;
+        if (rva >= sec.virtualAddress && rva < vaEnd) {
+            var ptr = sec.pointerToRawData;
+            if (!ptr) {
+                return null;
+            }
+            return bin.slice(ptr, ptr + sec.sizeOfRawData);
+        }
+        if (rva < sec.virtualAddress) {
+            return null;
+        }
+    }
+    return null;
+}
+exports.findImageSectionBlockByDirectoryEntry = findImageSectionBlockByDirectoryEntry;