groove-dev 0.26.14 → 0.26.16

package/pitch-deck-groove/node_modules/image-size/Readme.md

@@ -0,0 +1,184 @@
+# 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
+- HEIC (HEIF, AVCI, AVIF)
+- ICNS
+- ICO
+- J2C
+- JPEG-2000 (JP2)
+- JPEG
+- JPEG-XL
+- KTX (1 and 2)
+- PNG
+- PNM (PAM, PBM, PFM, PGM, PPM)
+- PSD
+- SVG
+- TGA
+- 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] ...
+```
+
+## 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/pitch-deck-groove/node_modules/image-size/bin/image-size.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/* eslint-disable @typescript-eslint/no-var-requires */
+'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/pitch-deck-groove/node_modules/image-size/dist/detector.d.ts

@@ -0,0 +1,2 @@
+import type { imageType } from './types/index';
+export declare function detector(input: Uint8Array): imageType | undefined;

package/pitch-deck-groove/node_modules/image-size/dist/detector.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detector = void 0;
+const index_1 = require("./types/index");
+const keys = Object.keys(index_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(input) {
+    const byte = input[0];
+    if (byte in firstBytes) {
+        const type = firstBytes[byte];
+        if (type && index_1.typeHandlers[type].validate(input)) {
+            return type;
+        }
+    }
+    const finder = (key) => index_1.typeHandlers[key].validate(input);
+    return keys.find(finder);
+}
+exports.detector = detector;

package/pitch-deck-groove/node_modules/image-size/dist/index.d.ts

@@ -0,0 +1,10 @@
+import type { imageType } from './types/index';
+import type { ISizeCalculationResult } from './types/interface';
+type CallbackFn = (e: Error | null, r?: ISizeCalculationResult) => void;
+export default imageSize;
+export declare function imageSize(input: Uint8Array | 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/pitch-deck-groove/node_modules/image-size/dist/index.js

@@ -0,0 +1,129 @@
+"use strict";
+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 index_1 = require("./types/index");
+const detector_1 = require("./detector");
+// Maximum input size, with a default of 512 kilobytes.
+// TO-DO: make this adaptive based on the initial signature of the image
+const MaxInputSize = 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 an Uint8Array
+ *
+ * @param {Uint8Array} input
+ * @param {String} filepath
+ * @returns {Object}
+ */
+function lookup(input, filepath) {
+    // detect the file type.. don't rely on the extension
+    const type = (0, detector_1.detector)(input);
+    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 index_1.typeHandlers) {
+            const size = index_1.typeHandlers[type].calculate(input, filepath);
+            if (size !== undefined) {
+                size.type = 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 an Uint8Array.
+ * @param {String} filepath
+ * @returns {Promise<Uint8Array>}
+ */
+async function readFileAsync(filepath) {
+    const handle = await fs.promises.open(filepath, 'r');
+    try {
+        const { size } = await handle.stat();
+        if (size <= 0) {
+            throw new Error('Empty file');
+        }
+        const inputSize = Math.min(size, MaxInputSize);
+        const input = new Uint8Array(inputSize);
+        await handle.read(input, 0, inputSize, 0);
+        return input;
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Synchronously reads a file into an Uint8Array, blocking the nodejs process.
+ *
+ * @param {String} filepath
+ * @returns {Uint8Array}
+ */
+function readFileSync(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 inputSize = Math.min(size, MaxInputSize);
+        const input = new Uint8Array(inputSize);
+        fs.readSync(descriptor, input, 0, inputSize, 0);
+        return input;
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-use-before-define
+module.exports = exports = imageSize; // backwards compatibility
+exports.default = imageSize;
+/**
+ * @param {Uint8Array|string} input - Uint8Array or relative/absolute path of the image file
+ * @param {Function=} [callback] - optional function for async detection
+ */
+function imageSize(input, callback) {
+    // Handle Uint8Array input
+    if (input instanceof Uint8Array) {
+        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 Uint8Array');
+    }
+    // resolve the file path
+    const filepath = path.resolve(input);
+    if (typeof callback === 'function') {
+        queue.push(() => readFileAsync(filepath)
+            .then((input) => process.nextTick(callback, null, lookup(input, filepath)))
+            .catch(callback));
+    }
+    else {
+        const input = readFileSync(filepath);
+        return lookup(input, 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(index_1.typeHandlers);

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

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

package/pitch-deck-groove/node_modules/image-size/dist/types/bmp.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BMP = void 0;
+const utils_1 = require("./utils");
+exports.BMP = {
+    validate: (input) => (0, utils_1.toUTF8String)(input, 0, 2) === 'BM',
+    calculate: (input) => ({
+        height: Math.abs((0, utils_1.readInt32LE)(input, 22)),
+        width: (0, utils_1.readUInt32LE)(input, 18),
+    }),
+};

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

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

package/pitch-deck-groove/node_modules/image-size/dist/types/cur.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUR = void 0;
+const ico_1 = require("./ico");
+const utils_1 = require("./utils");
+const TYPE_CURSOR = 2;
+exports.CUR = {
+    validate(input) {
+        const reserved = (0, utils_1.readUInt16LE)(input, 0);
+        const imageCount = (0, utils_1.readUInt16LE)(input, 4);
+        if (reserved !== 0 || imageCount === 0)
+            return false;
+        const imageType = (0, utils_1.readUInt16LE)(input, 2);
+        return imageType === TYPE_CURSOR;
+    },
+    calculate: (input) => ico_1.ICO.calculate(input),
+};

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

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

package/pitch-deck-groove/node_modules/image-size/dist/types/dds.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DDS = void 0;
+const utils_1 = require("./utils");
+exports.DDS = {
+    validate: (input) => (0, utils_1.readUInt32LE)(input, 0) === 0x20534444,
+    calculate: (input) => ({
+        height: (0, utils_1.readUInt32LE)(input, 12),
+        width: (0, utils_1.readUInt32LE)(input, 16),
+    }),
+};

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

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

package/pitch-deck-groove/node_modules/image-size/dist/types/gif.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GIF = void 0;
+const utils_1 = require("./utils");
+const gifRegexp = /^GIF8[79]a/;
+exports.GIF = {
+    validate: (input) => gifRegexp.test((0, utils_1.toUTF8String)(input, 0, 6)),
+    calculate: (input) => ({
+        height: (0, utils_1.readUInt16LE)(input, 8),
+        width: (0, utils_1.readUInt16LE)(input, 6),
+    }),
+};

package/pitch-deck-groove/node_modules/image-size/dist/types/heif.d.ts

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

package/pitch-deck-groove/node_modules/image-size/dist/types/heif.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEIF = void 0;
+const utils_1 = require("./utils");
+const brandMap = {
+    avif: 'avif',
+    mif1: 'heif',
+    msf1: 'heif', // heif-sequence
+    heic: 'heic',
+    heix: 'heic',
+    hevc: 'heic', // heic-sequence
+    hevx: 'heic', // heic-sequence
+};
+exports.HEIF = {
+    validate(input) {
+        const boxType = (0, utils_1.toUTF8String)(input, 4, 8);
+        if (boxType !== 'ftyp')
+            return false;
+        const ftypBox = (0, utils_1.findBox)(input, 'ftyp', 0);
+        if (!ftypBox)
+            return false;
+        const brand = (0, utils_1.toUTF8String)(input, ftypBox.offset + 8, ftypBox.offset + 12);
+        return brand in brandMap;
+    },
+    calculate(input) {
+        // Based on https://nokiatech.github.io/heif/technical.html
+        const metaBox = (0, utils_1.findBox)(input, 'meta', 0);
+        const iprpBox = metaBox && (0, utils_1.findBox)(input, 'iprp', metaBox.offset + 12);
+        const ipcoBox = iprpBox && (0, utils_1.findBox)(input, 'ipco', iprpBox.offset + 8);
+        const ispeBox = ipcoBox && (0, utils_1.findBox)(input, 'ispe', ipcoBox.offset + 8);
+        if (ispeBox) {
+            return {
+                height: (0, utils_1.readUInt32BE)(input, ispeBox.offset + 16),
+                width: (0, utils_1.readUInt32BE)(input, ispeBox.offset + 12),
+                type: (0, utils_1.toUTF8String)(input, 8, 12),
+            };
+        }
+        throw new TypeError('Invalid HEIF, no size found');
+    },
+};

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

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

package/pitch-deck-groove/node_modules/image-size/dist/types/icns.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICNS = void 0;
+const utils_1 = require("./utils");
+/**
+ * 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(input, imageOffset) {
+    const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET;
+    return [
+        (0, utils_1.toUTF8String)(input, imageOffset, imageLengthOffset),
+        (0, utils_1.readUInt32BE)(input, imageLengthOffset),
+    ];
+}
+function getImageSize(type) {
+    const size = ICON_TYPE_SIZE[type];
+    return { width: size, height: size, type };
+}
+exports.ICNS = {
+    validate: (input) => (0, utils_1.toUTF8String)(input, 0, 4) === 'icns',
+    calculate(input) {
+        const inputLength = input.length;
+        const fileLength = (0, utils_1.readUInt32BE)(input, FILE_LENGTH_OFFSET);
+        let imageOffset = SIZE_HEADER;
+        let imageHeader = readImageHeader(input, 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 < inputLength) {
+            imageHeader = readImageHeader(input, imageOffset);
+            imageSize = getImageSize(imageHeader[0]);
+            imageOffset += imageHeader[1];
+            result.images.push(imageSize);
+        }
+        return result;
+    },
+};

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

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