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

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,19 @@
+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;
+    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,38 @@
+"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 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,
+    tiff: tiff_1.TIFF,
+    webp: webp_1.WEBP,
+};

package/node_modules/image-size/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "image-size",
+  "version": "1.0.1",
+  "description": "get dimensions of any image file",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "bin/image-size.js"
+  ],
+  "engines": {
+    "node": ">=12.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",
+    "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.0",
+    "@types/glob": "7.2.0",
+    "@types/mocha": "9.0.0",
+    "@types/node": "17.0.8",
+    "@types/sinon": "10.0.6",
+    "@typescript-eslint/eslint-plugin": "5.9.1",
+    "@typescript-eslint/parser": "5.9.1",
+    "chai": "4.3.4",
+    "eslint": "8.6.0",
+    "glob": "7.2.0",
+    "mocha": "9.1.3",
+    "nyc": "15.1.0",
+    "sinon": "12.0.1",
+    "ts-node": "10.4.0",
+    "typedoc": "0.22.10",
+    "typescript": "4.5.4"
+  },
+  "dependencies": {
+    "queue": "6.0.2"
+  },
+  "packageManager": "yarn@3.1.1"
+}

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"
+  ]
+}

package/node_modules/queue/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2014 Jesse Tane <jesse.tane@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/queue/index.d.ts

@@ -0,0 +1,173 @@
+// Type definitions for Queue 4.5.1
+// Project: https://github.com/jessetane/queue
+// Definitions by: Alex Miller <https://github.com/codex->
+
+import { EventEmitter } from "events";
+
+export interface Options {
+    /**
+     * Max number of jobs the queue should process concurrently.
+     *
+     * @default Infinity
+     */
+    concurrency?: number;
+
+    /**
+     * Milliseconds to wait for a job to execute its callback.
+     *
+     * @default 0
+     */
+    timeout?: number;
+
+    /**
+     * Ensures the queue is always running if jobs are available. Useful in situations where you are using a queue only for concurrency control.
+     *
+     * @default false
+     */
+    autostart?: boolean;
+
+    /**
+     * An array to set job callback arguments on.
+     *
+     * @default null
+     */
+    results?: any[];
+}
+
+interface Queue extends EventEmitter {
+    /**
+     * Max number of jobs the queue should process concurrently.
+     */
+    concurrency: number;
+
+    /**
+     * Milliseconds to wait for a job to execute its callback.
+     */
+    timeout: number;
+
+    /**
+     * Ensures the queue is always running if jobs are available.
+     */
+    autostart: boolean;
+
+    /**
+     * An array to set job callback arguments on.
+     */
+    results: any[] | null;
+
+    /**
+     * Jobs pending + jobs to process.
+     */
+    readonly length: number;
+
+    /**
+     * Adds one or more elements to the end of the Queue and returns the new length of the Queue.
+     *
+     * @param workers New workers of the Queue.
+     */
+    push(...workers: QueueWorker[]): number;
+
+    /**
+     * Adds one or more elements to the front of the Queue and returns the new length of the Queue.
+     *
+     * @param workers Workers to insert at the start of the Queue.
+     */
+    unshift(...workers: QueueWorker[]): number;
+
+    /**
+     * Adds and/or removes elements from the queue.
+     *
+     * @param start The zero-based location in the Queue from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     */
+    splice(start: number, deleteCount?: number): Queue;
+
+    /**
+     * Adds and/or removes elements from the queue.
+     *
+     * @param start The zero-based location in the Queue from which to start removing elements.
+     * @param deleteCount The number of elements to remove.
+     * @param workers Workers to insert into the Queue in place of the deleted elements.
+     */
+    splice(start: number, deleteCount: number, ...workers: QueueWorker[]): Queue;
+
+    /**
+     * Removes the last element from the Queue and returns that element.
+     */
+    pop(): QueueWorker | undefined;
+
+    /**
+     * Removes the first element from the Queue and returns that element.
+     */
+    shift(): QueueWorker | undefined;
+
+    /**
+     * Extracts a section of the Queue and returns Queue.
+     *
+     * @param start The beginning of the specified portion of the Queue.
+     * @param end The end of the specified portion of the Queue.
+     */
+    slice(start?: number, end?: number): Queue;
+
+    /**
+     * Reverses the order of the elements of the Queue in place.
+     */
+    reverse(): Queue;
+
+    /**
+     * Returns the first (least) index of an element within the Queue equal to the specified value, or -1 if none is found.
+     *
+     * @param searchElement The value to locate in the Queue.
+     * @param fromIndex The Queue index at which to begin the search. If omitted, the search starts at index 0.
+     */
+    indexOf(searchElement: QueueWorker, fromIndex?: number): number;
+
+    /**
+     * Returns the last (greatest) index of an element within the Queue equal to the specified value, or -1 if none is found.
+     *
+     * @param searchElement The value to locate in the Queue.
+     * @param fromIndex The Queue index at which to begin the search. If omitted, the search starts at the last index in the Queue.
+     */
+    lastIndexOf(searchElement: QueueWorker, fromIndex?: number): number;
+
+    /**
+     * Starts the queue.
+     *
+     * @param callback Callback to be called when the queue empties or when an error occurs.
+     */
+    start(callback?: (error?: Error) => void): void;
+
+    /**
+     * Stops the queue.
+     */
+    stop(): void;
+
+    /**
+     * Stop and empty the queue immediately.
+     *
+     * @param error error of why the stop has occurred, to be passed to start callback if supplied.
+     */
+    end(error?: Error): void;
+}
+
+interface QueueConstructor {
+    (options?: Options): Queue;
+    new (options?: Options): Queue;
+}
+
+declare const Queue: QueueConstructor;
+
+export default Queue;
+
+export interface QueueWorker {
+    (callback?: QueueWorkerCallback): void;
+
+    /**
+     * Override queue timeout.
+     */
+    timeout?: number;
+}
+
+export interface QueueWorkerCallback {
+    (error?: Error, data?: Object): void;
+}

package/node_modules/queue/index.js

@@ -0,0 +1,195 @@
+var inherits = require('inherits')
+var EventEmitter = require('events').EventEmitter
+
+module.exports = Queue
+module.exports.default = Queue
+
+function Queue (options) {
+  if (!(this instanceof Queue)) {
+    return new Queue(options)
+  }
+
+  EventEmitter.call(this)
+  options = options || {}
+  this.concurrency = options.concurrency || Infinity
+  this.timeout = options.timeout || 0
+  this.autostart = options.autostart || false
+  this.results = options.results || null
+  this.pending = 0
+  this.session = 0
+  this.running = false
+  this.jobs = []
+  this.timers = {}
+}
+inherits(Queue, EventEmitter)
+
+var arrayMethods = [
+  'pop',
+  'shift',
+  'indexOf',
+  'lastIndexOf'
+]
+
+arrayMethods.forEach(function (method) {
+  Queue.prototype[method] = function () {
+    return Array.prototype[method].apply(this.jobs, arguments)
+  }
+})
+
+Queue.prototype.slice = function (begin, end) {
+  this.jobs = this.jobs.slice(begin, end)
+  return this
+}
+
+Queue.prototype.reverse = function () {
+  this.jobs.reverse()
+  return this
+}
+
+var arrayAddMethods = [
+  'push',
+  'unshift',
+  'splice'
+]
+
+arrayAddMethods.forEach(function (method) {
+  Queue.prototype[method] = function () {
+    var methodResult = Array.prototype[method].apply(this.jobs, arguments)
+    if (this.autostart) {
+      this.start()
+    }
+    return methodResult
+  }
+})
+
+Object.defineProperty(Queue.prototype, 'length', {
+  get: function () {
+    return this.pending + this.jobs.length
+  }
+})
+
+Queue.prototype.start = function (cb) {
+  if (cb) {
+    callOnErrorOrEnd.call(this, cb)
+  }
+
+  this.running = true
+
+  if (this.pending >= this.concurrency) {
+    return
+  }
+
+  if (this.jobs.length === 0) {
+    if (this.pending === 0) {
+      done.call(this)
+    }
+    return
+  }
+
+  var self = this
+  var job = this.jobs.shift()
+  var once = true
+  var session = this.session
+  var timeoutId = null
+  var didTimeout = false
+  var resultIndex = null
+  var timeout = job.hasOwnProperty('timeout') ? job.timeout : this.timeout
+
+  function next (err, result) {
+    if (once && self.session === session) {
+      once = false
+      self.pending--
+      if (timeoutId !== null) {
+        delete self.timers[timeoutId]
+        clearTimeout(timeoutId)
+      }
+
+      if (err) {
+        self.emit('error', err, job)
+      } else if (didTimeout === false) {
+        if (resultIndex !== null) {
+          self.results[resultIndex] = Array.prototype.slice.call(arguments, 1)
+        }
+        self.emit('success', result, job)
+      }
+
+      if (self.session === session) {
+        if (self.pending === 0 && self.jobs.length === 0) {
+          done.call(self)
+        } else if (self.running) {
+          self.start()
+        }
+      }
+    }
+  }
+
+  if (timeout) {
+    timeoutId = setTimeout(function () {
+      didTimeout = true
+      if (self.listeners('timeout').length > 0) {
+        self.emit('timeout', next, job)
+      } else {
+        next()
+      }
+    }, timeout)
+    this.timers[timeoutId] = timeoutId
+  }
+
+  if (this.results) {
+    resultIndex = this.results.length
+    this.results[resultIndex] = null
+  }
+
+  this.pending++
+  self.emit('start', job)
+  var promise = job(next)
+  if (promise && promise.then && typeof promise.then === 'function') {
+    promise.then(function (result) {
+      return next(null, result)
+    }).catch(function (err) {
+      return next(err || true)
+    })
+  }
+
+  if (this.running && this.jobs.length > 0) {
+    this.start()
+  }
+}
+
+Queue.prototype.stop = function () {
+  this.running = false
+}
+
+Queue.prototype.end = function (err) {
+  clearTimers.call(this)
+  this.jobs.length = 0
+  this.pending = 0
+  done.call(this, err)
+}
+
+function clearTimers () {
+  for (var key in this.timers) {
+    var timeoutId = this.timers[key]
+    delete this.timers[key]
+    clearTimeout(timeoutId)
+  }
+}
+
+function callOnErrorOrEnd (cb) {
+  var self = this
+  this.on('error', onerror)
+  this.on('end', onend)
+
+  function onerror (err) { self.end(err) }
+  function onend (err) {
+    self.removeListener('error', onerror)
+    self.removeListener('end', onend)
+    cb(err, this.results)
+  }
+}
+
+function done (err) {
+  this.session++
+  this.running = false
+  this.emit('end', err)
+}