@finsemble/finsemble-electron-adapter 1.0.0-beta-1

package/node_modules/image-size/dist/types/ico.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICO = void 0;
+const TYPE_ICON = 1;
+/**
+ * ICON Header
+ *
+ * | Offset | Size | Purpose |
+ * | 0	    | 2    | Reserved. Must always be 0.  |
+ * | 2      | 2    | Image type: 1 for icon (.ICO) image, 2 for cursor (.CUR) image. Other values are invalid. |
+ * | 4      | 2    | Number of images in the file. |
+ *
+ */
+const SIZE_HEADER = 2 + 2 + 2; // 6
+/**
+ * Image Entry
+ *
+ * | Offset | Size | Purpose |
+ * | 0	    | 1    | Image width in pixels. Can be any number between 0 and 255. Value 0 means width is 256 pixels. |
+ * | 1      | 1    | Image height in pixels. Can be any number between 0 and 255. Value 0 means height is 256 pixels. |
+ * | 2      | 1    | Number of colors in the color palette. Should be 0 if the image does not use a color palette. |
+ * | 3      | 1    | Reserved. Should be 0. |
+ * | 4      | 2    | ICO format: Color planes. Should be 0 or 1. |
+ * |        |      | CUR format: The horizontal coordinates of the hotspot in number of pixels from the left. |
+ * | 6      | 2    | ICO format: Bits per pixel. |
+ * |        |      | CUR format: The vertical coordinates of the hotspot in number of pixels from the top. |
+ * | 8      | 4    | The size of the image's data in bytes |
+ * | 12     | 4    | The offset of BMP or PNG data from the beginning of the ICO/CUR file |
+ *
+ */
+const SIZE_IMAGE_ENTRY = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4; // 16
+function getSizeFromOffset(buffer, offset) {
+    const value = buffer.readUInt8(offset);
+    return value === 0 ? 256 : value;
+}
+function getImageSize(buffer, imageIndex) {
+    const offset = SIZE_HEADER + (imageIndex * SIZE_IMAGE_ENTRY);
+    return {
+        height: getSizeFromOffset(buffer, offset + 1),
+        width: getSizeFromOffset(buffer, offset)
+    };
+}
+exports.ICO = {
+    validate(buffer) {
+        if (buffer.readUInt16LE(0) !== 0) {
+            return false;
+        }
+        return buffer.readUInt16LE(2) === TYPE_ICON;
+    },
+    calculate(buffer) {
+        const nbImages = buffer.readUInt16LE(4);
+        const imageSize = getImageSize(buffer, 0);
+        if (nbImages === 1) {
+            return imageSize;
+        }
+        const imgs = [imageSize];
+        for (let imageIndex = 1; imageIndex < nbImages; imageIndex += 1) {
+            imgs.push(getImageSize(buffer, imageIndex));
+        }
+        const result = {
+            height: imageSize.height,
+            images: imgs,
+            width: imageSize.width
+        };
+        return result;
+    }
+};

package/node_modules/image-size/dist/types/interface.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+export interface ISize {
+    width: number | undefined;
+    height: number | undefined;
+    orientation?: number;
+    type?: string;
+}
+export interface ISizeCalculationResult extends ISize {
+    images?: ISize[];
+}
+export interface IImage {
+    validate: (buffer: Buffer) => boolean;
+    calculate: (buffer: Buffer, filepath?: string) => ISizeCalculationResult;
+}

package/node_modules/image-size/dist/types/interface.js

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

package/node_modules/image-size/dist/types/j2c.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const J2C: IImage;

package/node_modules/image-size/dist/types/j2c.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.J2C = void 0;
+exports.J2C = {
+    validate(buffer) {
+        // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
+        return buffer.toString('hex', 0, 4) === 'ff4fff51';
+    },
+    calculate(buffer) {
+        return {
+            height: buffer.readUInt32BE(12),
+            width: buffer.readUInt32BE(8),
+        };
+    }
+};

package/node_modules/image-size/dist/types/jp2.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const JP2: IImage;

package/node_modules/image-size/dist/types/jp2.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JP2 = void 0;
+const BoxTypes = {
+    ftyp: '66747970',
+    ihdr: '69686472',
+    jp2h: '6a703268',
+    jp__: '6a502020',
+    rreq: '72726571',
+    xml_: '786d6c20'
+};
+const calculateRREQLength = (box) => {
+    const unit = box.readUInt8(0);
+    let offset = 1 + (2 * unit);
+    const numStdFlags = box.readUInt16BE(offset);
+    const flagsLength = numStdFlags * (2 + unit);
+    offset = offset + 2 + flagsLength;
+    const numVendorFeatures = box.readUInt16BE(offset);
+    const featuresLength = numVendorFeatures * (16 + unit);
+    return offset + 2 + featuresLength;
+};
+const parseIHDR = (box) => {
+    return {
+        height: box.readUInt32BE(4),
+        width: box.readUInt32BE(8),
+    };
+};
+exports.JP2 = {
+    validate(buffer) {
+        const signature = buffer.toString('hex', 4, 8);
+        const signatureLength = buffer.readUInt32BE(0);
+        if (signature !== BoxTypes.jp__ || signatureLength < 1) {
+            return false;
+        }
+        const ftypeBoxStart = signatureLength + 4;
+        const ftypBoxLength = buffer.readUInt32BE(signatureLength);
+        const ftypBox = buffer.slice(ftypeBoxStart, ftypeBoxStart + ftypBoxLength);
+        return ftypBox.toString('hex', 0, 4) === BoxTypes.ftyp;
+    },
+    calculate(buffer) {
+        const signatureLength = buffer.readUInt32BE(0);
+        const ftypBoxLength = buffer.readUInt16BE(signatureLength + 2);
+        let offset = signatureLength + 4 + ftypBoxLength;
+        const nextBoxType = buffer.toString('hex', offset, offset + 4);
+        switch (nextBoxType) {
+            case BoxTypes.rreq:
+                // WHAT ARE THESE 4 BYTES?????
+                // eslint-disable-next-line no-case-declarations
+                const MAGIC = 4;
+                offset = offset + 4 + MAGIC + calculateRREQLength(buffer.slice(offset + 4));
+                return parseIHDR(buffer.slice(offset + 8, offset + 24));
+            case BoxTypes.jp2h:
+                return parseIHDR(buffer.slice(offset + 8, offset + 24));
+            default:
+                throw new TypeError('Unsupported header found: ' + buffer.toString('ascii', offset, offset + 4));
+        }
+    }
+};

package/node_modules/image-size/dist/types/jpg.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const JPG: IImage;

package/node_modules/image-size/dist/types/jpg.js

@@ -0,0 +1,123 @@
+"use strict";
+// NOTE: we only support baseline and progressive JPGs here
+// due to the structure of the loader class, we only get a buffer
+// with a maximum size of 4096 bytes. so if the SOF marker is outside
+// if this range we can't detect the file size correctly.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JPG = void 0;
+const readUInt_1 = require("../readUInt");
+const EXIF_MARKER = '45786966';
+const APP1_DATA_SIZE_BYTES = 2;
+const EXIF_HEADER_BYTES = 6;
+const TIFF_BYTE_ALIGN_BYTES = 2;
+const BIG_ENDIAN_BYTE_ALIGN = '4d4d';
+const LITTLE_ENDIAN_BYTE_ALIGN = '4949';
+// Each entry is exactly 12 bytes
+const IDF_ENTRY_BYTES = 12;
+const NUM_DIRECTORY_ENTRIES_BYTES = 2;
+function isEXIF(buffer) {
+    return (buffer.toString('hex', 2, 6) === EXIF_MARKER);
+}
+function extractSize(buffer, index) {
+    return {
+        height: buffer.readUInt16BE(index),
+        width: buffer.readUInt16BE(index + 2)
+    };
+}
+function extractOrientation(exifBlock, isBigEndian) {
+    // TODO: assert that this contains 0x002A
+    // let STATIC_MOTOROLA_TIFF_HEADER_BYTES = 2
+    // let TIFF_IMAGE_FILE_DIRECTORY_BYTES = 4
+    // TODO: derive from TIFF_IMAGE_FILE_DIRECTORY_BYTES
+    const idfOffset = 8;
+    // IDF osset works from right after the header bytes
+    // (so the offset includes the tiff byte align)
+    const offset = EXIF_HEADER_BYTES + idfOffset;
+    const idfDirectoryEntries = (0, readUInt_1.readUInt)(exifBlock, 16, offset, isBigEndian);
+    for (let directoryEntryNumber = 0; directoryEntryNumber < idfDirectoryEntries; directoryEntryNumber++) {
+        const start = offset + NUM_DIRECTORY_ENTRIES_BYTES + (directoryEntryNumber * IDF_ENTRY_BYTES);
+        const end = start + IDF_ENTRY_BYTES;
+        // Skip on corrupt EXIF blocks
+        if (start > exifBlock.length) {
+            return;
+        }
+        const block = exifBlock.slice(start, end);
+        const tagNumber = (0, readUInt_1.readUInt)(block, 16, 0, isBigEndian);
+        // 0x0112 (decimal: 274) is the `orientation` tag ID
+        if (tagNumber === 274) {
+            const dataFormat = (0, readUInt_1.readUInt)(block, 16, 2, isBigEndian);
+            if (dataFormat !== 3) {
+                return;
+            }
+            // unsinged int has 2 bytes per component
+            // if there would more than 4 bytes in total it's a pointer
+            const numberOfComponents = (0, readUInt_1.readUInt)(block, 32, 4, isBigEndian);
+            if (numberOfComponents !== 1) {
+                return;
+            }
+            return (0, readUInt_1.readUInt)(block, 16, 8, isBigEndian);
+        }
+    }
+}
+function validateExifBlock(buffer, index) {
+    // Skip APP1 Data Size
+    const exifBlock = buffer.slice(APP1_DATA_SIZE_BYTES, index);
+    // Consider byte alignment
+    const byteAlign = exifBlock.toString('hex', EXIF_HEADER_BYTES, EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES);
+    // Ignore Empty EXIF. Validate byte alignment
+    const isBigEndian = byteAlign === BIG_ENDIAN_BYTE_ALIGN;
+    const isLittleEndian = byteAlign === LITTLE_ENDIAN_BYTE_ALIGN;
+    if (isBigEndian || isLittleEndian) {
+        return extractOrientation(exifBlock, isBigEndian);
+    }
+}
+function validateBuffer(buffer, index) {
+    // index should be within buffer limits
+    if (index > buffer.length) {
+        throw new TypeError('Corrupt JPG, exceeded buffer limits');
+    }
+    // Every JPEG block must begin with a 0xFF
+    if (buffer[index] !== 0xFF) {
+        throw new TypeError('Invalid JPG, marker table corrupted');
+    }
+}
+exports.JPG = {
+    validate(buffer) {
+        const SOIMarker = buffer.toString('hex', 0, 2);
+        return ('ffd8' === SOIMarker);
+    },
+    calculate(buffer) {
+        // Skip 4 chars, they are for signature
+        buffer = buffer.slice(4);
+        let orientation;
+        let next;
+        while (buffer.length) {
+            // read length of the next block
+            const i = buffer.readUInt16BE(0);
+            if (isEXIF(buffer)) {
+                orientation = validateExifBlock(buffer, i);
+            }
+            // ensure correct format
+            validateBuffer(buffer, i);
+            // 0xFFC0 is baseline standard(SOF)
+            // 0xFFC1 is baseline optimized(SOF)
+            // 0xFFC2 is progressive(SOF2)
+            next = buffer[i + 1];
+            if (next === 0xC0 || next === 0xC1 || next === 0xC2) {
+                const size = extractSize(buffer, i + 5);
+                // TODO: is orientation=0 a valid answer here?
+                if (!orientation) {
+                    return size;
+                }
+                return {
+                    height: size.height,
+                    orientation,
+                    width: size.width
+                };
+            }
+            // move to the next block
+            buffer = buffer.slice(i + 2);
+        }
+        throw new TypeError('Invalid JPG, no size found');
+    }
+};

package/node_modules/image-size/dist/types/ktx.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const KTX: IImage;

package/node_modules/image-size/dist/types/ktx.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KTX = void 0;
+const SIGNATURE = 'KTX 11';
+exports.KTX = {
+    validate(buffer) {
+        return SIGNATURE === buffer.toString('ascii', 1, 7);
+    },
+    calculate(buffer) {
+        return {
+            height: buffer.readUInt32LE(40),
+            width: buffer.readUInt32LE(36),
+        };
+    }
+};

package/node_modules/image-size/dist/types/png.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const PNG: IImage;

package/node_modules/image-size/dist/types/png.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNG = void 0;
+const pngSignature = 'PNG\r\n\x1a\n';
+const pngImageHeaderChunkName = 'IHDR';
+// Used to detect "fried" png's: http://www.jongware.com/pngdefry.html
+const pngFriedChunkName = 'CgBI';
+exports.PNG = {
+    validate(buffer) {
+        if (pngSignature === buffer.toString('ascii', 1, 8)) {
+            let chunkName = buffer.toString('ascii', 12, 16);
+            if (chunkName === pngFriedChunkName) {
+                chunkName = buffer.toString('ascii', 28, 32);
+            }
+            if (chunkName !== pngImageHeaderChunkName) {
+                throw new TypeError('Invalid PNG');
+            }
+            return true;
+        }
+        return false;
+    },
+    calculate(buffer) {
+        if (buffer.toString('ascii', 12, 16) === pngFriedChunkName) {
+            return {
+                height: buffer.readUInt32BE(36),
+                width: buffer.readUInt32BE(32)
+            };
+        }
+        return {
+            height: buffer.readUInt32BE(20),
+            width: buffer.readUInt32BE(16)
+        };
+    }
+};

package/node_modules/image-size/dist/types/pnm.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const PNM: IImage;

package/node_modules/image-size/dist/types/pnm.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNM = void 0;
+const PNMTypes = {
+    P1: 'pbm/ascii',
+    P2: 'pgm/ascii',
+    P3: 'ppm/ascii',
+    P4: 'pbm',
+    P5: 'pgm',
+    P6: 'ppm',
+    P7: 'pam',
+    PF: 'pfm'
+};
+const Signatures = Object.keys(PNMTypes);
+const handlers = {
+    default: (lines) => {
+        let dimensions = [];
+        while (lines.length > 0) {
+            const line = lines.shift();
+            if (line[0] === '#') {
+                continue;
+            }
+            dimensions = line.split(' ');
+            break;
+        }
+        if (dimensions.length === 2) {
+            return {
+                height: parseInt(dimensions[1], 10),
+                width: parseInt(dimensions[0], 10),
+            };
+        }
+        else {
+            throw new TypeError('Invalid PNM');
+        }
+    },
+    pam: (lines) => {
+        const size = {};
+        while (lines.length > 0) {
+            const line = lines.shift();
+            if (line.length > 16 || line.charCodeAt(0) > 128) {
+                continue;
+            }
+            const [key, value] = line.split(' ');
+            if (key && value) {
+                size[key.toLowerCase()] = parseInt(value, 10);
+            }
+            if (size.height && size.width) {
+                break;
+            }
+        }
+        if (size.height && size.width) {
+            return {
+                height: size.height,
+                width: size.width
+            };
+        }
+        else {
+            throw new TypeError('Invalid PAM');
+        }
+    }
+};
+exports.PNM = {
+    validate(buffer) {
+        const signature = buffer.toString('ascii', 0, 2);
+        return Signatures.includes(signature);
+    },
+    calculate(buffer) {
+        const signature = buffer.toString('ascii', 0, 2);
+        const type = PNMTypes[signature];
+        // TODO: this probably generates garbage. move to a stream based parser
+        const lines = buffer.toString('ascii', 3).split(/[\r\n]+/);
+        const handler = handlers[type] || handlers.default;
+        return handler(lines);
+    }
+};

package/node_modules/image-size/dist/types/psd.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const PSD: IImage;

package/node_modules/image-size/dist/types/psd.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSD = void 0;
+exports.PSD = {
+    validate(buffer) {
+        return ('8BPS' === buffer.toString('ascii', 0, 4));
+    },
+    calculate(buffer) {
+        return {
+            height: buffer.readUInt32BE(14),
+            width: buffer.readUInt32BE(18)
+        };
+    }
+};

package/node_modules/image-size/dist/types/svg.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const SVG: IImage;

package/node_modules/image-size/dist/types/svg.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVG = void 0;
+const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
+const extractorRegExps = {
+    height: /\sheight=(['"])([^%]+?)\1/,
+    root: svgReg,
+    viewbox: /\sviewBox=(['"])(.+?)\1/i,
+    width: /\swidth=(['"])([^%]+?)\1/,
+};
+const INCH_CM = 2.54;
+const units = {
+    in: 96,
+    cm: 96 / INCH_CM,
+    em: 16,
+    ex: 8,
+    m: 96 / INCH_CM * 100,
+    mm: 96 / INCH_CM / 10,
+    pc: 96 / 72 / 12,
+    pt: 96 / 72,
+    px: 1
+};
+const unitsReg = new RegExp(`^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join('|')})?$`);
+function parseLength(len) {
+    const m = unitsReg.exec(len);
+    if (!m) {
+        return undefined;
+    }
+    return Math.round(Number(m[1]) * (units[m[2]] || 1));
+}
+function parseViewbox(viewbox) {
+    const bounds = viewbox.split(' ');
+    return {
+        height: parseLength(bounds[3]),
+        width: parseLength(bounds[2])
+    };
+}
+function parseAttributes(root) {
+    const width = root.match(extractorRegExps.width);
+    const height = root.match(extractorRegExps.height);
+    const viewbox = root.match(extractorRegExps.viewbox);
+    return {
+        height: height && parseLength(height[2]),
+        viewbox: viewbox && parseViewbox(viewbox[2]),
+        width: width && parseLength(width[2]),
+    };
+}
+function calculateByDimensions(attrs) {
+    return {
+        height: attrs.height,
+        width: attrs.width,
+    };
+}
+function calculateByViewbox(attrs, viewbox) {
+    const ratio = viewbox.width / viewbox.height;
+    if (attrs.width) {
+        return {
+            height: Math.floor(attrs.width / ratio),
+            width: attrs.width,
+        };
+    }
+    if (attrs.height) {
+        return {
+            height: attrs.height,
+            width: Math.floor(attrs.height * ratio),
+        };
+    }
+    return {
+        height: viewbox.height,
+        width: viewbox.width,
+    };
+}
+exports.SVG = {
+    validate(buffer) {
+        const str = String(buffer);
+        return svgReg.test(str);
+    },
+    calculate(buffer) {
+        const root = buffer.toString('utf8').match(extractorRegExps.root);
+        if (root) {
+            const attrs = parseAttributes(root[0]);
+            if (attrs.width && attrs.height) {
+                return calculateByDimensions(attrs);
+            }
+            if (attrs.viewbox) {
+                return calculateByViewbox(attrs, attrs.viewbox);
+            }
+        }
+        throw new TypeError('Invalid SVG');
+    }
+};

package/node_modules/image-size/dist/types/tiff.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const TIFF: IImage;

package/node_modules/image-size/dist/types/tiff.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIFF = void 0;
+// based on http://www.compix.com/fileformattif.htm
+// TO-DO: support big-endian as well
+const fs = require("fs");
+const readUInt_1 = require("../readUInt");
+// Read IFD (image-file-directory) into a buffer
+function readIFD(buffer, filepath, isBigEndian) {
+    const ifdOffset = (0, readUInt_1.readUInt)(buffer, 32, 4, isBigEndian);
+    // read only till the end of the file
+    let bufferSize = 1024;
+    const fileSize = fs.statSync(filepath).size;
+    if (ifdOffset + bufferSize > fileSize) {
+        bufferSize = fileSize - ifdOffset - 10;
+    }
+    // populate the buffer
+    const endBuffer = Buffer.alloc(bufferSize);
+    const descriptor = fs.openSync(filepath, 'r');
+    fs.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
+    fs.closeSync(descriptor);
+    return endBuffer.slice(2);
+}
+// TIFF values seem to be messed up on Big-Endian, this helps
+function readValue(buffer, isBigEndian) {
+    const low = (0, readUInt_1.readUInt)(buffer, 16, 8, isBigEndian);
+    const high = (0, readUInt_1.readUInt)(buffer, 16, 10, isBigEndian);
+    return (high << 16) + low;
+}
+// move to the next tag
+function nextTag(buffer) {
+    if (buffer.length > 24) {
+        return buffer.slice(12);
+    }
+}
+// Extract IFD tags from TIFF metadata
+function extractTags(buffer, isBigEndian) {
+    const tags = {};
+    let temp = buffer;
+    while (temp && temp.length) {
+        const code = (0, readUInt_1.readUInt)(temp, 16, 0, isBigEndian);
+        const type = (0, readUInt_1.readUInt)(temp, 16, 2, isBigEndian);
+        const length = (0, readUInt_1.readUInt)(temp, 32, 4, isBigEndian);
+        // 0 means end of IFD
+        if (code === 0) {
+            break;
+        }
+        else {
+            // 256 is width, 257 is height
+            // if (code === 256 || code === 257) {
+            if (length === 1 && (type === 3 || type === 4)) {
+                tags[code] = readValue(temp, isBigEndian);
+            }
+            // move to the next tag
+            temp = nextTag(temp);
+        }
+    }
+    return tags;
+}
+// Test if the TIFF is Big Endian or Little Endian
+function determineEndianness(buffer) {
+    const signature = buffer.toString('ascii', 0, 2);
+    if ('II' === signature) {
+        return 'LE';
+    }
+    else if ('MM' === signature) {
+        return 'BE';
+    }
+}
+const signatures = [
+    // '492049', // currently not supported
+    '49492a00',
+    '4d4d002a', // Big Endian
+    // '4d4d002a', // BigTIFF > 4GB. currently not supported
+];
+exports.TIFF = {
+    validate(buffer) {
+        return signatures.includes(buffer.toString('hex', 0, 4));
+    },
+    calculate(buffer, filepath) {
+        if (!filepath) {
+            throw new TypeError('Tiff doesn\'t support buffer');
+        }
+        // Determine BE/LE
+        const isBigEndian = determineEndianness(buffer) === 'BE';
+        // read the IFD
+        const ifdBuffer = readIFD(buffer, filepath, isBigEndian);
+        // extract the tags from the IFD
+        const tags = extractTags(ifdBuffer, isBigEndian);
+        const width = tags[256];
+        const height = tags[257];
+        if (!width || !height) {
+            throw new TypeError('Invalid Tiff. Missing tags');
+        }
+        return { height, width };
+    }
+};

package/node_modules/image-size/dist/types/webp.d.ts

@@ -0,0 +1,2 @@
+import { IImage } from './interface';
+export declare const WEBP: IImage;