main funcions fixes

desktop-operator/node_modules/resedit/dist/data/BitmapInfo.d.ts

@@ -0,0 +1,17 @@
+export default interface BitmapInfo {
+    width: number;
+    height: number;
+    planes: number;
+    bitCount: number;
+    compression: number;
+    sizeImage: number;
+    xPelsPerMeter: number;
+    yPelsPerMeter: number;
+    colorUsed: number;
+    colorImportant: number;
+    colors: Array<{
+        r: number;
+        g: number;
+        b: number;
+    }>;
+}

desktop-operator/node_modules/resedit/dist/data/BitmapInfo.js

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

desktop-operator/node_modules/resedit/dist/data/IconFile.d.ts

@@ -0,0 +1,21 @@
+import IconItem from './IconItem.js';
+import RawIconItem from './RawIconItem.js';
+/**
+ * All fields except for 'data' is optional.
+ * Missing fields are replaced by 'data' values when generating binary.
+ */
+export interface IconFileItem {
+    width?: number;
+    height?: number;
+    colors?: number;
+    planes?: number;
+    bitCount?: number;
+    data: IconItem | RawIconItem;
+}
+export default class IconFile {
+    /** Containing icons */
+    icons: IconFileItem[];
+    constructor();
+    static from(bin: ArrayBuffer | ArrayBufferView): IconFile;
+    generate(): ArrayBuffer;
+}

desktop-operator/node_modules/resedit/dist/data/IconFile.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IconItem_js_1 = require("./IconItem.js");
+var RawIconItem_js_1 = require("./RawIconItem.js");
+var functions_js_1 = require("../util/functions.js");
+function generateEntryBinary(icons) {
+    var count = icons.length;
+    /* istanbul ignore if */
+    if (count > 65535) {
+        count = 65535;
+    }
+    var tmpIcons = icons.map(function (item) {
+        if (item.data.isIcon()) {
+            return {
+                item: item,
+                bin: item.data.generate(),
+                offset: 0,
+            };
+        }
+        else {
+            return {
+                item: item,
+                bin: item.data.bin,
+                offset: 0,
+            };
+        }
+    });
+    var size = tmpIcons.reduce(function (p, icon) {
+        icon.offset = p;
+        return p + icon.bin.byteLength;
+    }, 6 + 16 * count);
+    var bin = new ArrayBuffer(size);
+    var view = new DataView(bin);
+    view.setUint16(0, 0, true); // reserved
+    view.setUint16(2, 1, true); // icon type
+    view.setUint16(4, count, true);
+    var offset = 6;
+    tmpIcons.forEach(function (icon) {
+        var item = icon.item;
+        var width;
+        var height;
+        var colors;
+        var planes;
+        var bitCount;
+        if (item.data.isIcon()) {
+            var bi = item.data.bitmapInfo;
+            width =
+                typeof item.width !== 'undefined'
+                    ? item.width
+                    : Math.abs(bi.width);
+            height =
+                typeof item.height !== 'undefined'
+                    ? item.height
+                    : Math.abs(bi.height / 2);
+            colors =
+                typeof item.colors !== 'undefined'
+                    ? item.colors
+                    : bi.colorUsed || bi.colors.length;
+            planes =
+                typeof item.planes !== 'undefined' ? item.planes : bi.planes;
+            bitCount =
+                typeof item.bitCount !== 'undefined'
+                    ? item.bitCount
+                    : bi.bitCount;
+        }
+        else {
+            width =
+                typeof item.width !== 'undefined'
+                    ? item.width
+                    : Math.abs(item.data.width);
+            height =
+                typeof item.height !== 'undefined'
+                    ? item.height
+                    : Math.abs(item.data.height);
+            colors = typeof item.colors !== 'undefined' ? item.colors : 0;
+            planes = typeof item.planes !== 'undefined' ? item.planes : 1;
+            bitCount =
+                typeof item.bitCount !== 'undefined'
+                    ? item.bitCount
+                    : item.data.bitCount;
+        }
+        var dataSize = icon.bin.byteLength;
+        view.setUint8(offset, width >= 256 ? 0 : width);
+        view.setUint8(offset + 1, height >= 256 ? 0 : height);
+        view.setUint8(offset + 2, colors >= 256 ? 0 : colors);
+        view.setUint8(offset + 3, 0);
+        view.setUint16(offset + 4, planes, true);
+        view.setUint16(offset + 6, bitCount, true);
+        view.setUint32(offset + 8, dataSize, true);
+        view.setUint32(offset + 12, icon.offset, true);
+        offset += 16;
+        functions_js_1.copyBuffer(bin, icon.offset, icon.bin, 0, dataSize);
+    });
+    return bin;
+}
+var IconFile = /** @class */ (function () {
+    function IconFile(bin) {
+        if (!bin) {
+            this.icons = [];
+            return;
+        }
+        var view = functions_js_1.createDataView(bin);
+        var totalSize = view.byteLength;
+        var icons = [];
+        /* istanbul ignore else */
+        if (view.getUint16(2, true) === 1) {
+            var count = view.getUint16(4, true);
+            var offset = 6;
+            for (var i = 0; i < count; ++i) {
+                var dataSize = functions_js_1.readUint32WithLastOffset(view, offset + 8, totalSize);
+                var dataOffset = functions_js_1.readUint32WithLastOffset(view, offset + 12, totalSize);
+                var width = functions_js_1.readUint8WithLastOffset(view, offset, totalSize);
+                var height = functions_js_1.readUint8WithLastOffset(view, offset + 1, totalSize);
+                var bitCount = functions_js_1.readUint8WithLastOffset(view, offset + 6, totalSize);
+                var data = void 0;
+                if (view.getUint32(dataOffset, true) === 0x28) {
+                    data = IconItem_js_1.default.from(width, height, bin, dataOffset, dataSize);
+                }
+                else {
+                    data = RawIconItem_js_1.default.from(bin, width || 256, height || 256, bitCount, dataOffset, dataSize);
+                }
+                icons.push({
+                    width: width,
+                    height: height,
+                    colors: functions_js_1.readUint8WithLastOffset(view, offset + 2, totalSize),
+                    planes: functions_js_1.readUint16WithLastOffset(view, offset + 4, totalSize),
+                    bitCount: bitCount,
+                    data: data,
+                });
+                offset += 16;
+            }
+        }
+        this.icons = icons;
+    }
+    IconFile.from = function (bin) {
+        return new IconFile(bin);
+    };
+    IconFile.prototype.generate = function () {
+        return generateEntryBinary(this.icons);
+    };
+    return IconFile;
+}());
+exports.default = IconFile;

desktop-operator/node_modules/resedit/dist/data/IconItem.d.ts

@@ -0,0 +1,58 @@
+import BitmapInfo from './BitmapInfo.js';
+export default class IconItem {
+    /**
+     * Bitmap header data (`BITMAPINFOHEADER`)
+     */
+    readonly bitmapInfo: BitmapInfo;
+    /**
+     * Horizontal size of the icon in pixel (overrides `bitmapInfo.width`).
+     * If `null` is specified, `bitmapInfo.width` will be used.
+     */
+    width: number | null;
+    /**
+     * Vertical size of the icon in pixel (overrides `bitmapInfo.height`).
+     * If `null` is specified, `bitmapInfo.height` will be used.
+     */
+    height: number | null;
+    /**
+     * Bitmap pixel data used for mask
+     * (the data will be appended immediately after `pixels` when generating icon binary)
+     */
+    masks: ArrayBuffer;
+    /**
+     * Bitmap pixel data
+     */
+    private _pixels;
+    private constructor();
+    /**
+     * Bitmap pixel data.
+     * @note
+     * On set, if `bitmapInfo.sizeImage` is non-zero, `bitmapInfo.sizeImage` will be updated.
+     */
+    get pixels(): ArrayBuffer;
+    /**
+     * Bitmap pixel data.
+     * @note
+     * On set, if `bitmapInfo.sizeImage` is non-zero, `bitmapInfo.sizeImage` will be updated.
+     */
+    set pixels(newValue: ArrayBuffer);
+    /**
+     * Generates `IconItem` instance from bitmap data binary.
+     * @param bin binary data containing the bitmap data
+     * @param byteOffset byte offset of `bin` referring the bitmap data
+     * @param byteLength available byte length for `bin` (from the offset `byteOffset`)
+     */
+    static from(bin: ArrayBuffer | ArrayBufferView, byteOffset?: number, byteLength?: number): IconItem;
+    /**
+     * Generates `IconItem` instance from bitmap data binary width actual icon size (width and height).
+     * @param width icon width
+     * @param height icon height
+     * @param bin binary data containing the bitmap data
+     * @param byteOffset byte offset of `bin` referring the bitmap data
+     * @param byteLength available byte length for `bin` (from the offset `byteOffset`)
+     */
+    static from(width: number, height: number, bin: ArrayBuffer | ArrayBufferView, byteOffset?: number, byteLength?: number): IconItem;
+    isIcon(): this is IconItem;
+    isRaw(): false;
+    generate(): ArrayBuffer;
+}

desktop-operator/node_modules/resedit/dist/data/IconItem.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var functions_js_1 = require("../util/functions.js");
+function calcMaskSize(width, height) {
+    // round up to 4 bytes (32 bit)
+    // (mask pixels is 1-bit bitmap)
+    var actualWidthBytes = functions_js_1.roundUp(Math.abs(width), 32) / 8;
+    return actualWidthBytes * Math.abs(height);
+}
+var IconItem = /** @class */ (function () {
+    function IconItem(width, height, bin, byteOffset, byteLength) {
+        var view = functions_js_1.createDataView(bin, byteOffset, byteLength);
+        var totalSize = view.byteLength;
+        var headerSize = view.getUint32(0, true);
+        if (headerSize > totalSize) {
+            headerSize = totalSize;
+        }
+        var sizeImage = functions_js_1.readUint32WithLastOffset(view, 20, headerSize);
+        var bi = {
+            width: functions_js_1.readInt32WithLastOffset(view, 4, headerSize),
+            height: functions_js_1.readInt32WithLastOffset(view, 8, headerSize),
+            planes: functions_js_1.readUint16WithLastOffset(view, 12, headerSize),
+            bitCount: functions_js_1.readUint16WithLastOffset(view, 14, headerSize),
+            compression: functions_js_1.readUint32WithLastOffset(view, 16, headerSize),
+            sizeImage: sizeImage,
+            xPelsPerMeter: functions_js_1.readInt32WithLastOffset(view, 24, headerSize),
+            yPelsPerMeter: functions_js_1.readInt32WithLastOffset(view, 28, headerSize),
+            colorUsed: functions_js_1.readUint32WithLastOffset(view, 32, headerSize),
+            colorImportant: functions_js_1.readUint32WithLastOffset(view, 36, headerSize),
+            colors: [],
+        };
+        var offset = 40;
+        var colors = bi.colorUsed;
+        if (!colors) {
+            switch (bi.bitCount) {
+                case 1:
+                    colors = 2;
+                    break;
+                case 4:
+                    colors = 16;
+                    break;
+                case 8:
+                    colors = 256;
+                    break;
+            }
+        }
+        for (var i = 0; i < colors; ++i) {
+            bi.colors.push({
+                b: functions_js_1.readUint8WithLastOffset(view, offset, totalSize),
+                g: functions_js_1.readUint8WithLastOffset(view, offset + 1, totalSize),
+                r: functions_js_1.readUint8WithLastOffset(view, offset + 2, totalSize),
+            });
+            offset += 4;
+        }
+        this.width = width;
+        this.height = height;
+        this.bitmapInfo = bi;
+        // round up to 4 bytes (32 bit)
+        var widthBytes = functions_js_1.roundUp(bi.bitCount * Math.abs(bi.width), 32) / 8;
+        var absActualHeight = Math.abs(bi.height) / 2;
+        // sizeImage may be weird if compression is 0 (BI_RGB), so
+        // we calculate actual bitmap size from width and height
+        var size = bi.compression !== 0 && sizeImage !== 0
+            ? sizeImage
+            : widthBytes * absActualHeight;
+        if (size + offset > totalSize) {
+            throw new Error("Unexpected bitmap data in icon: bitmap size " + size + " is larger than " + totalSize + " - " + offset);
+        }
+        this._pixels = functions_js_1.allocatePartialBinary(view, offset, size);
+        offset += size;
+        var maskSize = calcMaskSize(bi.width, absActualHeight);
+        if (maskSize + offset <= totalSize) {
+            this.masks = functions_js_1.allocatePartialBinary(view, offset, maskSize);
+        }
+        else {
+            // create a zero buffer (no mask is not allowed)
+            this.masks = new ArrayBuffer(maskSize);
+        }
+    }
+    Object.defineProperty(IconItem.prototype, "pixels", {
+        /**
+         * Bitmap pixel data.
+         * @note
+         * On set, if `bitmapInfo.sizeImage` is non-zero, `bitmapInfo.sizeImage` will be updated.
+         */
+        get: function () {
+            return this._pixels;
+        },
+        /**
+         * Bitmap pixel data.
+         * @note
+         * On set, if `bitmapInfo.sizeImage` is non-zero, `bitmapInfo.sizeImage` will be updated.
+         */
+        set: function (newValue) {
+            this._pixels = newValue;
+            if (this.bitmapInfo.sizeImage !== 0) {
+                this.bitmapInfo.sizeImage = newValue.byteLength;
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    IconItem.from = function (arg1, arg2, arg3, byteOffset, byteLength) {
+        var width;
+        var height;
+        var bin;
+        if (typeof arg3 === 'object') {
+            // second overload
+            width = arg1;
+            height = arg2;
+            bin = arg3;
+        }
+        else {
+            // first overload
+            width = null;
+            height = null;
+            bin = arg1;
+            byteOffset = arg2;
+            byteLength = arg3;
+        }
+        return new IconItem(width, height, bin, byteOffset, byteLength);
+    };
+    IconItem.prototype.isIcon = function () {
+        return true;
+    };
+    IconItem.prototype.isRaw = function () {
+        return false;
+    };
+    IconItem.prototype.generate = function () {
+        var bi = this.bitmapInfo;
+        var absWidth = Math.abs(bi.width);
+        // round up to 4 bytes (32 bit)
+        var absWidthBytes = functions_js_1.roundUp(bi.bitCount * absWidth, 32) / 8;
+        var absActualHeight = Math.abs(bi.height) / 2;
+        var actualSizeImage = absWidthBytes * absActualHeight;
+        var sizeMask = calcMaskSize(bi.width, absActualHeight);
+        var colorCount = bi.colors.length;
+        var totalSize = 40 + 4 * colorCount + actualSizeImage + sizeMask;
+        var bin = new ArrayBuffer(totalSize);
+        var view = new DataView(bin);
+        view.setUint32(0, 40, true);
+        view.setInt32(4, bi.width, true);
+        view.setInt32(8, bi.height, true);
+        view.setUint16(12, bi.planes, true);
+        view.setUint16(14, bi.bitCount, true);
+        view.setUint32(16, bi.compression, true);
+        // image size
+        view.setUint32(20, bi.sizeImage, true);
+        view.setInt32(24, bi.xPelsPerMeter, true);
+        view.setInt32(28, bi.yPelsPerMeter, true);
+        view.setUint32(32, bi.colorUsed, true);
+        view.setUint32(36, bi.colorImportant > colorCount ? colorCount : bi.colorImportant, true);
+        var offset = 40;
+        bi.colors.forEach(function (c) {
+            view.setUint8(offset, c.b);
+            view.setUint8(offset + 1, c.g);
+            view.setUint8(offset + 2, c.r);
+            offset += 4;
+        });
+        functions_js_1.copyBuffer(bin, offset, this.pixels, 0, actualSizeImage);
+        functions_js_1.copyBuffer(bin, offset + actualSizeImage, this.masks, 0, sizeMask);
+        return bin;
+    };
+    return IconItem;
+}());
+exports.default = IconItem;

desktop-operator/node_modules/resedit/dist/data/RawIconItem.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents the raw-graphic icon item, such as PNG data.
+ */
+export default class RawIconItem {
+    width: number;
+    height: number;
+    bitCount: number;
+    bin: ArrayBuffer;
+    constructor(bin: ArrayBuffer | ArrayBufferView, width: number, height: number, bitCount: number, byteOffset?: number, byteLength?: number);
+    static from(bin: ArrayBuffer | ArrayBufferView, width: number, height: number, bitCount: number, byteOffset?: number, byteLength?: number): RawIconItem;
+    isIcon(): false;
+    isRaw(): this is RawIconItem;
+}

desktop-operator/node_modules/resedit/dist/data/RawIconItem.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var functions_js_1 = require("../util/functions.js");
+/**
+ * Represents the raw-graphic icon item, such as PNG data.
+ */
+var RawIconItem = /** @class */ (function () {
+    function RawIconItem(bin, width, height, bitCount, byteOffset, byteLength) {
+        this.width = width;
+        this.height = height;
+        this.bitCount = bitCount;
+        if (typeof byteOffset !== 'number') {
+            byteOffset = 0;
+            byteLength = bin.byteLength;
+        }
+        else if (typeof byteLength !== 'number') {
+            byteLength = bin.byteLength - byteOffset;
+        }
+        this.bin = functions_js_1.allocatePartialBinary(bin, byteOffset, byteLength);
+    }
+    RawIconItem.from = function (bin, width, height, bitCount, byteOffset, byteLength) {
+        return new RawIconItem(bin, width, height, bitCount, byteOffset, byteLength);
+    };
+    RawIconItem.prototype.isIcon = function () {
+        return false;
+    };
+    RawIconItem.prototype.isRaw = function () {
+        return true;
+    };
+    return RawIconItem;
+}());
+exports.default = RawIconItem;

desktop-operator/node_modules/resedit/dist/data/index.d.ts

@@ -0,0 +1,5 @@
+import BitmapInfo from './BitmapInfo.js';
+import IconFile, { IconFileItem } from './IconFile.js';
+import IconItem from './IconItem.js';
+import RawIconItem from './RawIconItem.js';
+export { BitmapInfo, IconFile, IconFileItem, IconItem, RawIconItem };

desktop-operator/node_modules/resedit/dist/data/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawIconItem = exports.IconItem = exports.IconFile = void 0;
+var IconFile_js_1 = require("./IconFile.js");
+exports.IconFile = IconFile_js_1.default;
+var IconItem_js_1 = require("./IconItem.js");
+exports.IconItem = IconItem_js_1.default;
+var RawIconItem_js_1 = require("./RawIconItem.js");
+exports.RawIconItem = RawIconItem_js_1.default;