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

package/node_modules/image-size/Readme.md

@@ -0,0 +1,182 @@
+# image-size
+
+[![Build Status](https://circleci.com/gh/image-size/image-size.svg?style=shield)](https://circleci.com/gh/image-size/image-size)
+[![Package Version](https://img.shields.io/npm/v/image-size.svg)](https://www.npmjs.com/package/image-size)
+[![Downloads](https://img.shields.io/npm/dm/image-size.svg)](http://npm-stat.com/charts.html?package=image-size&author=&from=&to=)
+
+A [Node](https://nodejs.org/en/) module to get dimensions of any image file
+
+## Supported formats
+
+* BMP
+* CUR
+* DDS
+* GIF
+* ICNS
+* ICO
+* JPEG
+* KTX
+* PNG
+* PNM (PAM, PBM, PFM, PGM, PPM)
+* PSD
+* SVG
+* TIFF
+* WebP
+
+## Programmatic Usage
+
+```shell
+npm install image-size --save
+```
+
+or
+
+```shell
+yarn add image-size
+```
+
+### Synchronous
+
+```javascript
+const sizeOf = require('image-size')
+const dimensions = sizeOf('images/funny-cats.png')
+console.log(dimensions.width, dimensions.height)
+```
+
+### Asynchronous
+
+```javascript
+const sizeOf = require('image-size')
+sizeOf('images/funny-cats.png', function (err, dimensions) {
+  console.log(dimensions.width, dimensions.height)
+})
+```
+
+NOTE: The asynchronous version doesn't work if the input is a Buffer. Use synchronous version instead.
+
+Also, the asynchronous functions have a default concurrency limit of **100**
+To change this limit, you can call the `setConcurrency` function like this:
+
+```javascript
+const sizeOf = require('image-size')
+sizeOf.setConcurrency(123456)
+```
+
+### Using promises (nodejs 10.x+)
+
+```javascript
+const { promisify } = require('util')
+const sizeOf = promisify(require('image-size'))
+sizeOf('images/funny-cats.png')
+  .then(dimensions => { console.log(dimensions.width, dimensions.height) })
+  .catch(err => console.error(err))
+```
+
+### Async/Await (Typescript & ES7)
+
+```javascript
+const { promisify } = require('util')
+const sizeOf = promisify(require('image-size'))
+(async () => {
+  try {
+    const dimensions = await sizeOf('images/funny-cats.png')
+    console.log(dimensions.width, dimensions.height)
+  } catch (err) {
+    console.error(err)
+  }
+})().then(c => console.log(c))
+```
+
+### Multi-size
+
+If the target file is an icon (.ico) or a cursor (.cur), the `width` and `height` will be the ones of the first found image.
+
+An additional `images` array is available and returns the dimensions of all the available images
+
+```javascript
+const sizeOf = require('image-size')
+const images = sizeOf('images/multi-size.ico').images
+for (const dimensions of images) {
+  console.log(dimensions.width, dimensions.height)
+}
+```
+
+### Using a URL
+
+```javascript
+const url = require('url')
+const http = require('http')
+
+const sizeOf = require('image-size')
+
+const imgUrl = 'http://my-amazing-website.com/image.jpeg'
+const options = url.parse(imgUrl)
+
+http.get(options, function (response) {
+  const chunks = []
+  response.on('data', function (chunk) {
+    chunks.push(chunk)
+  }).on('end', function() {
+    const buffer = Buffer.concat(chunks)
+    console.log(sizeOf(buffer))
+  })
+})
+```
+
+You can optionally check the buffer lengths & stop downloading the image after a few kilobytes.
+**You don't need to download the entire image**
+
+### Disabling certain image types
+```javascript
+const imageSize = require('image-size')
+imageSize.disableTypes(['tiff', 'ico'])
+```
+
+### Disabling all file-system reads
+```javascript
+const imageSize = require('image-size')
+imageSize.disableFS(true)
+```
+
+### JPEG image orientation
+
+If the orientation is present in the JPEG EXIF metadata, it will be returned by the function. The orientation value is a [number between 1 and 8](https://exiftool.org/TagNames/EXIF.html#:~:text=0x0112,8%20=%20Rotate%20270%20CW) representing a type of orientation.
+
+```javascript
+const sizeOf = require('image-size')
+const dimensions = sizeOf('images/photo.jpeg')
+console.log(dimensions.orientation)
+```
+
+## Command-Line Usage (CLI)
+
+```shell
+npm install image-size --global
+```
+
+or
+
+```shell
+yarn global add image-size
+```
+
+followed by
+
+```shell
+image-size image1 [image2] [image3] ...
+```
+
+## Hosted API
+
+ We also provide a hosted API for image-size which may simplify your use case.
+
+ <a href="https://image-size.saasify.sh">
+ 	<img src="https://badges.saasify.sh?text=View%20Hosted%20API" height="40"/>
+ </a>
+
+## Credits
+
+not a direct port, but an attempt to have something like
+[dabble's imagesize](https://github.com/dabble/imagesize/blob/master/lib/image_size.rb) as a node module.
+
+## [Contributors](Contributors.md)

package/node_modules/image-size/bin/image-size.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const { imageSize } = require('..')
+
+const files = process.argv.slice(2)
+
+if (!files.length) {
+  console.error('Usage: image-size image1 [image2] [image3] ...')
+  process.exit(-1)
+}
+
+const red = ['\x1B[31m', '\x1B[39m']
+// const bold = ['\x1B[1m',  '\x1B[22m']
+const grey = ['\x1B[90m', '\x1B[39m']
+const green = ['\x1B[32m', '\x1B[39m']
+
+function colorize(text, color) {
+  return color[0] + text + color[1]
+}
+
+files.forEach(function (image) {
+  try {
+    if (fs.existsSync(path.resolve(image))) {
+      const greyX = colorize('x', grey)
+      const greyImage = colorize(image, grey)
+      const size = imageSize(image)
+      const sizes = size.images || [size]
+      sizes.forEach(size => {
+        let greyType = ''
+        if (size.type) {
+          greyType = colorize(' (' + size.type + ')', grey)
+        }
+        console.info(
+          colorize(size.width, green) + greyX + colorize(size.height, green)
+            + ' - ' + greyImage + greyType
+        )
+      })
+    } else {
+      console.error('file doesn\'t exist - ', image)
+    }
+  } catch (e) {
+    // console.error(e.stack)
+    console.error(colorize(e.message, red), '-', image)
+  }
+})

package/node_modules/image-size/dist/detector.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import { imageType } from './types';
+export declare function detector(buffer: Buffer): imageType | undefined;

package/node_modules/image-size/dist/detector.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detector = void 0;
+const types_1 = require("./types");
+const keys = Object.keys(types_1.typeHandlers);
+// This map helps avoid validating for every single image type
+const firstBytes = {
+    0x38: 'psd',
+    0x42: 'bmp',
+    0x44: 'dds',
+    0x47: 'gif',
+    0x49: 'tiff',
+    0x4d: 'tiff',
+    0x52: 'webp',
+    0x69: 'icns',
+    0x89: 'png',
+    0xff: 'jpg'
+};
+function detector(buffer) {
+    const byte = buffer[0];
+    if (byte in firstBytes) {
+        const type = firstBytes[byte];
+        if (type && types_1.typeHandlers[type].validate(buffer)) {
+            return type;
+        }
+    }
+    const finder = (key) => types_1.typeHandlers[key].validate(buffer);
+    return keys.find(finder);
+}
+exports.detector = detector;

package/node_modules/image-size/dist/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { imageType } from './types';
+import { ISizeCalculationResult } from './types/interface';
+declare type CallbackFn = (e: Error | null, r?: ISizeCalculationResult) => void;
+export default imageSize;
+export declare function imageSize(input: Buffer | string): ISizeCalculationResult;
+export declare function imageSize(input: string, callback: CallbackFn): void;
+export declare const disableFS: (v: boolean) => void;
+export declare const disableTypes: (types: imageType[]) => void;
+export declare const setConcurrency: (c: number) => void;
+export declare const types: string[];

package/node_modules/image-size/dist/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.types = exports.setConcurrency = exports.disableTypes = exports.disableFS = exports.imageSize = void 0;
+const fs = require("fs");
+const path = require("path");
+const queue_1 = require("queue");
+const types_1 = require("./types");
+const detector_1 = require("./detector");
+// Maximum buffer size, with a default of 512 kilobytes.
+// TO-DO: make this adaptive based on the initial signature of the image
+const MaxBufferSize = 512 * 1024;
+// This queue is for async `fs` operations, to avoid reaching file-descriptor limits
+const queue = new queue_1.default({ concurrency: 100, autostart: true });
+const globalOptions = {
+    disabledFS: false,
+    disabledTypes: []
+};
+/**
+ * Return size information based on a buffer
+ *
+ * @param {Buffer} buffer
+ * @param {String} filepath
+ * @returns {Object}
+ */
+function lookup(buffer, filepath) {
+    // detect the file type.. don't rely on the extension
+    const type = (0, detector_1.detector)(buffer);
+    if (typeof type !== 'undefined') {
+        if (globalOptions.disabledTypes.indexOf(type) > -1) {
+            throw new TypeError('disabled file type: ' + type);
+        }
+        // find an appropriate handler for this file type
+        if (type in types_1.typeHandlers) {
+            const size = types_1.typeHandlers[type].calculate(buffer, filepath);
+            if (size !== undefined) {
+                size.type = type;
+                return size;
+            }
+        }
+    }
+    // throw up, if we don't understand the file
+    throw new TypeError('unsupported file type: ' + type + ' (file: ' + filepath + ')');
+}
+/**
+ * Reads a file into a buffer.
+ * @param {String} filepath
+ * @returns {Promise<Buffer>}
+ */
+function asyncFileToBuffer(filepath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const handle = yield fs.promises.open(filepath, 'r');
+        try {
+            const { size } = yield handle.stat();
+            if (size <= 0) {
+                throw new Error('Empty file');
+            }
+            const bufferSize = Math.min(size, MaxBufferSize);
+            const buffer = Buffer.alloc(bufferSize);
+            yield handle.read(buffer, 0, bufferSize, 0);
+            return buffer;
+        }
+        finally {
+            yield handle.close();
+        }
+    });
+}
+/**
+ * Synchronously reads a file into a buffer, blocking the nodejs process.
+ *
+ * @param {String} filepath
+ * @returns {Buffer}
+ */
+function syncFileToBuffer(filepath) {
+    // read from the file, synchronously
+    const descriptor = fs.openSync(filepath, 'r');
+    try {
+        const { size } = fs.fstatSync(descriptor);
+        if (size <= 0) {
+            throw new Error('Empty file');
+        }
+        const bufferSize = Math.min(size, MaxBufferSize);
+        const buffer = Buffer.alloc(bufferSize);
+        fs.readSync(descriptor, buffer, 0, bufferSize, 0);
+        return buffer;
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+module.exports = exports = imageSize; // backwards compatibility
+exports.default = imageSize;
+/**
+ * @param {Buffer|string} input - buffer or relative/absolute path of the image file
+ * @param {Function=} [callback] - optional function for async detection
+ */
+function imageSize(input, callback) {
+    // Handle buffer input
+    if (Buffer.isBuffer(input)) {
+        return lookup(input);
+    }
+    // input should be a string at this point
+    if (typeof input !== 'string' || globalOptions.disabledFS) {
+        throw new TypeError('invalid invocation. input should be a Buffer');
+    }
+    // resolve the file path
+    const filepath = path.resolve(input);
+    if (typeof callback === 'function') {
+        queue.push(() => asyncFileToBuffer(filepath)
+            .then((buffer) => process.nextTick(callback, null, lookup(buffer, filepath)))
+            .catch(callback));
+    }
+    else {
+        const buffer = syncFileToBuffer(filepath);
+        return lookup(buffer, filepath);
+    }
+}
+exports.imageSize = imageSize;
+const disableFS = (v) => { globalOptions.disabledFS = v; };
+exports.disableFS = disableFS;
+const disableTypes = (types) => { globalOptions.disabledTypes = types; };
+exports.disableTypes = disableTypes;
+const setConcurrency = (c) => { queue.concurrency = c; };
+exports.setConcurrency = setConcurrency;
+exports.types = Object.keys(types_1.typeHandlers);

package/node_modules/image-size/dist/readUInt.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+declare type Bits = 16 | 32;
+export declare function readUInt(buffer: Buffer, bits: Bits, offset: number, isBigEndian: boolean): number;
+export {};

package/node_modules/image-size/dist/readUInt.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUInt = void 0;
+// Abstract reading multi-byte unsigned integers
+function readUInt(buffer, bits, offset, isBigEndian) {
+    offset = offset || 0;
+    const endian = isBigEndian ? 'BE' : 'LE';
+    const methodName = ('readUInt' + bits + endian);
+    return buffer[methodName].call(buffer, offset);
+}
+exports.readUInt = readUInt;

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BMP = void 0;
+exports.BMP = {
+    validate(buffer) {
+        return ('BM' === buffer.toString('ascii', 0, 2));
+    },
+    calculate(buffer) {
+        return {
+            height: Math.abs(buffer.readInt32LE(22)),
+            width: buffer.readUInt32LE(18)
+        };
+    }
+};

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUR = void 0;
+const ico_1 = require("./ico");
+const TYPE_CURSOR = 2;
+exports.CUR = {
+    validate(buffer) {
+        if (buffer.readUInt16LE(0) !== 0) {
+            return false;
+        }
+        return buffer.readUInt16LE(2) === TYPE_CURSOR;
+    },
+    calculate(buffer) {
+        return ico_1.ICO.calculate(buffer);
+    }
+};

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DDS = void 0;
+exports.DDS = {
+    validate(buffer) {
+        return buffer.readUInt32LE(0) === 0x20534444;
+    },
+    calculate(buffer) {
+        return {
+            height: buffer.readUInt32LE(12),
+            width: buffer.readUInt32LE(16)
+        };
+    }
+};

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIF = void 0;
+const gifRegexp = /^GIF8[79]a/;
+exports.GIF = {
+    validate(buffer) {
+        const signature = buffer.toString('ascii', 0, 6);
+        return (gifRegexp.test(signature));
+    },
+    calculate(buffer) {
+        return {
+            height: buffer.readUInt16LE(8),
+            width: buffer.readUInt16LE(6)
+        };
+    }
+};

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

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

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICNS = void 0;
+/**
+ * ICNS Header
+ *
+ * | Offset | Size | Purpose                                                |
+ * | 0	    | 4    | Magic literal, must be "icns" (0x69, 0x63, 0x6e, 0x73) |
+ * | 4      | 4    | Length of file, in bytes, msb first.                   |
+ *
+ */
+const SIZE_HEADER = 4 + 4; // 8
+const FILE_LENGTH_OFFSET = 4; // MSB => BIG ENDIAN
+/**
+ * Image Entry
+ *
+ * | Offset | Size | Purpose                                                          |
+ * | 0	    | 4    | Icon type, see OSType below.                                     |
+ * | 4      | 4    | Length of data, in bytes (including type and length), msb first. |
+ * | 8      | n    | Icon data                                                        |
+ */
+const ENTRY_LENGTH_OFFSET = 4; // MSB => BIG ENDIAN
+const ICON_TYPE_SIZE = {
+    ICON: 32,
+    'ICN#': 32,
+    // m => 16 x 16
+    'icm#': 16,
+    icm4: 16,
+    icm8: 16,
+    // s => 16 x 16
+    'ics#': 16,
+    ics4: 16,
+    ics8: 16,
+    is32: 16,
+    s8mk: 16,
+    icp4: 16,
+    // l => 32 x 32
+    icl4: 32,
+    icl8: 32,
+    il32: 32,
+    l8mk: 32,
+    icp5: 32,
+    ic11: 32,
+    // h => 48 x 48
+    ich4: 48,
+    ich8: 48,
+    ih32: 48,
+    h8mk: 48,
+    // . => 64 x 64
+    icp6: 64,
+    ic12: 32,
+    // t => 128 x 128
+    it32: 128,
+    t8mk: 128,
+    ic07: 128,
+    // . => 256 x 256
+    ic08: 256,
+    ic13: 256,
+    // . => 512 x 512
+    ic09: 512,
+    ic14: 512,
+    // . => 1024 x 1024
+    ic10: 1024,
+};
+function readImageHeader(buffer, imageOffset) {
+    const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET;
+    return [
+        buffer.toString('ascii', imageOffset, imageLengthOffset),
+        buffer.readUInt32BE(imageLengthOffset)
+    ];
+}
+function getImageSize(type) {
+    const size = ICON_TYPE_SIZE[type];
+    return { width: size, height: size, type };
+}
+exports.ICNS = {
+    validate(buffer) {
+        return ('icns' === buffer.toString('ascii', 0, 4));
+    },
+    calculate(buffer) {
+        const bufferLength = buffer.length;
+        const fileLength = buffer.readUInt32BE(FILE_LENGTH_OFFSET);
+        let imageOffset = SIZE_HEADER;
+        let imageHeader = readImageHeader(buffer, imageOffset);
+        let imageSize = getImageSize(imageHeader[0]);
+        imageOffset += imageHeader[1];
+        if (imageOffset === fileLength) {
+            return imageSize;
+        }
+        const result = {
+            height: imageSize.height,
+            images: [imageSize],
+            width: imageSize.width
+        };
+        while (imageOffset < fileLength && imageOffset < bufferLength) {
+            imageHeader = readImageHeader(buffer, imageOffset);
+            imageSize = getImageSize(imageHeader[0]);
+            imageOffset += imageHeader[1];
+            result.images.push(imageSize);
+        }
+        return result;
+    }
+};

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

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