@finsemble/finsemble-electron-adapter 0.0.0

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/tga.d.ts

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

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

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

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;

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEBP = void 0;
+function calculateExtended(buffer) {
+    return {
+        height: 1 + buffer.readUIntLE(7, 3),
+        width: 1 + buffer.readUIntLE(4, 3)
+    };
+}
+function calculateLossless(buffer) {
+    return {
+        height: 1 + (((buffer[4] & 0xF) << 10) | (buffer[3] << 2) | ((buffer[2] & 0xC0) >> 6)),
+        width: 1 + (((buffer[2] & 0x3F) << 8) | buffer[1])
+    };
+}
+function calculateLossy(buffer) {
+    // `& 0x3fff` returns the last 14 bits
+    // TO-DO: include webp scaling in the calculations
+    return {
+        height: buffer.readInt16LE(8) & 0x3fff,
+        width: buffer.readInt16LE(6) & 0x3fff
+    };
+}
+exports.WEBP = {
+    validate(buffer) {
+        const riffHeader = 'RIFF' === buffer.toString('ascii', 0, 4);
+        const webpHeader = 'WEBP' === buffer.toString('ascii', 8, 12);
+        const vp8Header = 'VP8' === buffer.toString('ascii', 12, 15);
+        return (riffHeader && webpHeader && vp8Header);
+    },
+    calculate(buffer) {
+        const chunkHeader = buffer.toString('ascii', 12, 16);
+        buffer = buffer.slice(20, 30);
+        // Extended webp stream signature
+        if (chunkHeader === 'VP8X') {
+            const extendedHeader = buffer[0];
+            const validStart = (extendedHeader & 0xc0) === 0;
+            const validEnd = (extendedHeader & 0x01) === 0;
+            if (validStart && validEnd) {
+                return calculateExtended(buffer);
+            }
+            else {
+                // TODO: breaking change
+                throw new TypeError('Invalid WebP');
+            }
+        }
+        // Lossless webp stream signature
+        if (chunkHeader === 'VP8 ' && buffer[0] !== 0x2f) {
+            return calculateLossy(buffer);
+        }
+        // Lossy webp stream signature
+        const signature = buffer.toString('hex', 3, 6);
+        if (chunkHeader === 'VP8L' && signature !== '9d012a') {
+            return calculateLossless(buffer);
+        }
+        throw new TypeError('Invalid WebP');
+    }
+};

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

@@ -0,0 +1,20 @@
+export declare const typeHandlers: {
+    bmp: import("./types/interface").IImage;
+    cur: import("./types/interface").IImage;
+    dds: import("./types/interface").IImage;
+    gif: import("./types/interface").IImage;
+    icns: import("./types/interface").IImage;
+    ico: import("./types/interface").IImage;
+    j2c: import("./types/interface").IImage;
+    jp2: import("./types/interface").IImage;
+    jpg: import("./types/interface").IImage;
+    ktx: import("./types/interface").IImage;
+    png: import("./types/interface").IImage;
+    pnm: import("./types/interface").IImage;
+    psd: import("./types/interface").IImage;
+    svg: import("./types/interface").IImage;
+    tga: import("./types/interface").IImage;
+    tiff: import("./types/interface").IImage;
+    webp: import("./types/interface").IImage;
+};
+export declare type imageType = keyof typeof typeHandlers;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeHandlers = void 0;
+// load all available handlers explicitely for browserify support
+const bmp_1 = require("./types/bmp");
+const cur_1 = require("./types/cur");
+const dds_1 = require("./types/dds");
+const gif_1 = require("./types/gif");
+const icns_1 = require("./types/icns");
+const ico_1 = require("./types/ico");
+const j2c_1 = require("./types/j2c");
+const jp2_1 = require("./types/jp2");
+const jpg_1 = require("./types/jpg");
+const ktx_1 = require("./types/ktx");
+const png_1 = require("./types/png");
+const pnm_1 = require("./types/pnm");
+const psd_1 = require("./types/psd");
+const svg_1 = require("./types/svg");
+const tga_1 = require("./types/tga");
+const tiff_1 = require("./types/tiff");
+const webp_1 = require("./types/webp");
+exports.typeHandlers = {
+    bmp: bmp_1.BMP,
+    cur: cur_1.CUR,
+    dds: dds_1.DDS,
+    gif: gif_1.GIF,
+    icns: icns_1.ICNS,
+    ico: ico_1.ICO,
+    j2c: j2c_1.J2C,
+    jp2: jp2_1.JP2,
+    jpg: jpg_1.JPG,
+    ktx: ktx_1.KTX,
+    png: png_1.PNG,
+    pnm: pnm_1.PNM,
+    psd: psd_1.PSD,
+    svg: svg_1.SVG,
+    tga: tga_1.TGA,
+    tiff: tiff_1.TIFF,
+    webp: webp_1.WEBP,
+};

package/node_modules/image-size/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "image-size",
+  "version": "1.0.2",
+  "description": "get dimensions of any image file",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin/image-size.js"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "bin": "bin/image-size.js",
+  "scripts": {
+    "pretest": "eslint --ext .ts,.js bin lib specs",
+    "test": "nyc mocha",
+    "clean": "rm -rf dist docs",
+    "generate-docs": "typedoc",
+    "build": "tsc",
+    "prepack": "yarn clean && yarn build"
+  },
+  "keywords": [
+    "image",
+    "size",
+    "dimensions",
+    "resolution",
+    "width",
+    "height",
+    "png",
+    "jpeg",
+    "bmp",
+    "gif",
+    "psd",
+    "tga",
+    "tiff",
+    "webp",
+    "svg",
+    "icns",
+    "ico",
+    "cur"
+  ],
+  "repository": "git://github.com/image-size/image-size.git",
+  "author": "netroy <aditya@netroy.in> (http://netroy.in/)",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/chai": "4.3.1",
+    "@types/glob": "7.2.0",
+    "@types/mocha": "9.1.1",
+    "@types/node": "18.0.3",
+    "@types/sinon": "10.0.12",
+    "@typescript-eslint/eslint-plugin": "5.30.6",
+    "@typescript-eslint/parser": "5.30.6",
+    "chai": "4.3.6",
+    "eslint": "8.19.0",
+    "glob": "8.0.3",
+    "mocha": "10.0.0",
+    "nyc": "15.1.0",
+    "sinon": "14.0.0",
+    "ts-node": "10.8.2",
+    "typedoc": "0.23.7",
+    "typescript": "4.7.4"
+  },
+  "dependencies": {
+    "queue": "6.0.2"
+  },
+  "packageManager": "yarn@3.2.0"
+}

package/node_modules/inherits/LICENSE

@@ -0,0 +1,16 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+

package/node_modules/inherits/README.md

@@ -0,0 +1,42 @@
+Browser-friendly inheritance fully compatible with standard node.js
+[inherits](http://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor).
+
+This package exports standard `inherits` from node.js `util` module in
+node environment, but also provides alternative browser-friendly
+implementation through [browser
+field](https://gist.github.com/shtylman/4339901). Alternative
+implementation is a literal copy of standard one located in standalone
+module to avoid requiring of `util`. It also has a shim for old
+browsers with no `Object.create` support.
+
+While keeping you sure you are using standard `inherits`
+implementation in node.js environment, it allows bundlers such as
+[browserify](https://github.com/substack/node-browserify) to not
+include full `util` package to your client code if all you need is
+just `inherits` function. It worth, because browser shim for `util`
+package is large and `inherits` is often the single function you need
+from it.
+
+It's recommended to use this package instead of
+`require('util').inherits` for any code that has chances to be used
+not only in node.js but in browser too.
+
+## usage
+
+```js
+var inherits = require('inherits');
+// then use exactly as the standard one
+```
+
+## note on version ~1.0
+
+Version ~1.0 had completely different motivation and is not compatible
+neither with 2.0 nor with standard node.js `inherits`.
+
+If you are using version ~1.0 and planning to switch to ~2.0, be
+careful:
+
+* new version uses `super_` instead of `super` for referencing
+  superclass
+* new version overwrites current prototype while old one preserves any
+  existing fields on it

package/node_modules/inherits/inherits.js

@@ -0,0 +1,9 @@
+try {
+  var util = require('util');
+  /* istanbul ignore next */
+  if (typeof util.inherits !== 'function') throw '';
+  module.exports = util.inherits;
+} catch (e) {
+  /* istanbul ignore next */
+  module.exports = require('./inherits_browser.js');
+}

package/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,27 @@
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      })
+    }
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      var TempCtor = function () {}
+      TempCtor.prototype = superCtor.prototype
+      ctor.prototype = new TempCtor()
+      ctor.prototype.constructor = ctor
+    }
+  }
+}

package/node_modules/inherits/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "inherits",
+  "description": "Browser-friendly inheritance fully compatible with standard node.js inherits()",
+  "version": "2.0.4",
+  "keywords": [
+    "inheritance",
+    "class",
+    "klass",
+    "oop",
+    "object-oriented",
+    "inherits",
+    "browser",
+    "browserify"
+  ],
+  "main": "./inherits.js",
+  "browser": "./inherits_browser.js",
+  "repository": "git://github.com/isaacs/inherits",
+  "license": "ISC",
+  "scripts": {
+    "test": "tap"
+  },
+  "devDependencies": {
+    "tap": "^14.2.4"
+  },
+  "files": [
+    "inherits.js",
+    "inherits_browser.js"
+  ]
+}