groove-dev 0.26.14 → 0.26.16

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ICO = void 0;
+const utils_1 = require("./utils");
+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(input, offset) {
+    const value = input[offset];
+    return value === 0 ? 256 : value;
+}
+function getImageSize(input, imageIndex) {
+    const offset = SIZE_HEADER + imageIndex * SIZE_IMAGE_ENTRY;
+    return {
+        height: getSizeFromOffset(input, offset + 1),
+        width: getSizeFromOffset(input, offset),
+    };
+}
+exports.ICO = {
+    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_ICON;
+    },
+    calculate(input) {
+        const nbImages = (0, utils_1.readUInt16LE)(input, 4);
+        const imageSize = getImageSize(input, 0);
+        if (nbImages === 1)
+            return imageSize;
+        const imgs = [imageSize];
+        for (let imageIndex = 1; imageIndex < nbImages; imageIndex += 1) {
+            imgs.push(getImageSize(input, imageIndex));
+        }
+        return {
+            height: imageSize.height,
+            images: imgs,
+            width: imageSize.width,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typeHandlers = void 0;
+// load all available handlers explicitly for browserify support
+const bmp_1 = require("./bmp");
+const cur_1 = require("./cur");
+const dds_1 = require("./dds");
+const gif_1 = require("./gif");
+const heif_1 = require("./heif");
+const icns_1 = require("./icns");
+const ico_1 = require("./ico");
+const j2c_1 = require("./j2c");
+const jp2_1 = require("./jp2");
+const jpg_1 = require("./jpg");
+const jxl_1 = require("./jxl");
+const jxl_stream_1 = require("./jxl-stream");
+const ktx_1 = require("./ktx");
+const png_1 = require("./png");
+const pnm_1 = require("./pnm");
+const psd_1 = require("./psd");
+const svg_1 = require("./svg");
+const tga_1 = require("./tga");
+const tiff_1 = require("./tiff");
+const webp_1 = require("./webp");
+exports.typeHandlers = {
+    bmp: bmp_1.BMP,
+    cur: cur_1.CUR,
+    dds: dds_1.DDS,
+    gif: gif_1.GIF,
+    heif: heif_1.HEIF,
+    icns: icns_1.ICNS,
+    ico: ico_1.ICO,
+    j2c: j2c_1.J2C,
+    jp2: jp2_1.JP2,
+    jpg: jpg_1.JPG,
+    jxl: jxl_1.JXL,
+    'jxl-stream': jxl_stream_1.JXLStream,
+    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/pitch-deck-groove/node_modules/image-size/dist/types/interface.d.ts

@@ -0,0 +1,13 @@
+export interface ISize {
+    width: number | undefined;
+    height: number | undefined;
+    orientation?: number;
+    type?: string;
+}
+export type ISizeCalculationResult = {
+    images?: ISize[];
+} & ISize;
+export interface IImage {
+    validate: (input: Uint8Array) => boolean;
+    calculate: (input: Uint8Array, filepath?: string) => ISizeCalculationResult;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.J2C = void 0;
+const utils_1 = require("./utils");
+exports.J2C = {
+    // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
+    validate: (input) => (0, utils_1.readUInt32BE)(input, 0) === 0xff4fff51,
+    calculate: (input) => ({
+        height: (0, utils_1.readUInt32BE)(input, 12),
+        width: (0, utils_1.readUInt32BE)(input, 8),
+    }),
+};

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JP2 = void 0;
+const utils_1 = require("./utils");
+exports.JP2 = {
+    validate(input) {
+        const boxType = (0, utils_1.toUTF8String)(input, 4, 8);
+        if (boxType !== 'jP  ')
+            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 === 'jp2 ';
+    },
+    calculate(input) {
+        const jp2hBox = (0, utils_1.findBox)(input, 'jp2h', 0);
+        const ihdrBox = jp2hBox && (0, utils_1.findBox)(input, 'ihdr', jp2hBox.offset + 8);
+        if (ihdrBox) {
+            return {
+                height: (0, utils_1.readUInt32BE)(input, ihdrBox.offset + 8),
+                width: (0, utils_1.readUInt32BE)(input, ihdrBox.offset + 12),
+            };
+        }
+        throw new TypeError('Unsupported JPEG 2000 format');
+    },
+};

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

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

package/pitch-deck-groove/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 utils_1 = require("./utils");
+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(input) {
+    return (0, utils_1.toHexString)(input, 2, 6) === EXIF_MARKER;
+}
+function extractSize(input, index) {
+    return {
+        height: (0, utils_1.readUInt16BE)(input, index),
+        width: (0, utils_1.readUInt16BE)(input, 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, utils_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, utils_1.readUInt)(block, 16, 0, isBigEndian);
+        // 0x0112 (decimal: 274) is the `orientation` tag ID
+        if (tagNumber === 274) {
+            const dataFormat = (0, utils_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, utils_1.readUInt)(block, 32, 4, isBigEndian);
+            if (numberOfComponents !== 1) {
+                return;
+            }
+            return (0, utils_1.readUInt)(block, 16, 8, isBigEndian);
+        }
+    }
+}
+function validateExifBlock(input, index) {
+    // Skip APP1 Data Size
+    const exifBlock = input.slice(APP1_DATA_SIZE_BYTES, index);
+    // Consider byte alignment
+    const byteAlign = (0, utils_1.toHexString)(exifBlock, 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 validateInput(input, index) {
+    // index should be within buffer limits
+    if (index > input.length) {
+        throw new TypeError('Corrupt JPG, exceeded buffer limits');
+    }
+}
+exports.JPG = {
+    validate: (input) => (0, utils_1.toHexString)(input, 0, 2) === 'ffd8',
+    calculate(input) {
+        // Skip 4 chars, they are for signature
+        input = input.slice(4);
+        let orientation;
+        let next;
+        while (input.length) {
+            // read length of the next block
+            const i = (0, utils_1.readUInt16BE)(input, 0);
+            // Every JPEG block must begin with a 0xFF
+            if (input[i] !== 0xff) {
+                input = input.slice(1);
+                continue;
+            }
+            if (isEXIF(input)) {
+                orientation = validateExifBlock(input, i);
+            }
+            // ensure correct format
+            validateInput(input, i);
+            // 0xFFC0 is baseline standard(SOF)
+            // 0xFFC1 is baseline optimized(SOF)
+            // 0xFFC2 is progressive(SOF2)
+            next = input[i + 1];
+            if (next === 0xc0 || next === 0xc1 || next === 0xc2) {
+                const size = extractSize(input, 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
+            input = input.slice(i + 2);
+        }
+        throw new TypeError('Invalid JPG, no size found');
+    },
+};

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JXLStream = void 0;
+const utils_1 = require("./utils");
+const bit_reader_1 = require("../utils/bit-reader");
+function calculateImageDimension(reader, isSmallImage) {
+    if (isSmallImage) {
+        // Small images are multiples of 8 pixels, up to 256 pixels
+        return 8 * (1 + reader.getBits(5));
+    }
+    else {
+        // Larger images use a variable bit-length encoding
+        const sizeClass = reader.getBits(2);
+        const extraBits = [9, 13, 18, 30][sizeClass];
+        return 1 + reader.getBits(extraBits);
+    }
+}
+function calculateImageWidth(reader, isSmallImage, widthMode, height) {
+    if (isSmallImage && widthMode === 0) {
+        // Small square images
+        return 8 * (1 + reader.getBits(5));
+    }
+    else if (widthMode === 0) {
+        // Non-small images with explicitly coded width
+        return calculateImageDimension(reader, false);
+    }
+    else {
+        // Images with width derived from height and aspect ratio
+        const aspectRatios = [1, 1.2, 4 / 3, 1.5, 16 / 9, 5 / 4, 2];
+        return Math.floor(height * aspectRatios[widthMode - 1]);
+    }
+}
+exports.JXLStream = {
+    validate: (input) => {
+        return (0, utils_1.toHexString)(input, 0, 2) === 'ff0a';
+    },
+    calculate(input) {
+        const reader = new bit_reader_1.BitReader(input, 'little-endian');
+        const isSmallImage = reader.getBits(1) === 1;
+        const height = calculateImageDimension(reader, isSmallImage);
+        const widthMode = reader.getBits(3);
+        const width = calculateImageWidth(reader, isSmallImage, widthMode, height);
+        return { width, height };
+    },
+};

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

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

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JXL = void 0;
+const utils_1 = require("./utils");
+const jxl_stream_1 = require("./jxl-stream");
+/** Extracts the codestream from a containerized JPEG XL image */
+function extractCodestream(input) {
+    const jxlcBox = (0, utils_1.findBox)(input, 'jxlc', 0);
+    if (jxlcBox) {
+        return input.slice(jxlcBox.offset + 8, jxlcBox.offset + jxlcBox.size);
+    }
+    const partialStreams = extractPartialStreams(input);
+    if (partialStreams.length > 0) {
+        return concatenateCodestreams(partialStreams);
+    }
+    return undefined;
+}
+/** Extracts partial codestreams from jxlp boxes */
+function extractPartialStreams(input) {
+    const partialStreams = [];
+    let offset = 0;
+    while (offset < input.length) {
+        const jxlpBox = (0, utils_1.findBox)(input, 'jxlp', offset);
+        if (!jxlpBox)
+            break;
+        partialStreams.push(input.slice(jxlpBox.offset + 12, jxlpBox.offset + jxlpBox.size));
+        offset = jxlpBox.offset + jxlpBox.size;
+    }
+    return partialStreams;
+}
+/** Concatenates partial codestreams into a single codestream */
+function concatenateCodestreams(partialCodestreams) {
+    const totalLength = partialCodestreams.reduce((acc, curr) => acc + curr.length, 0);
+    const codestream = new Uint8Array(totalLength);
+    let position = 0;
+    for (const partial of partialCodestreams) {
+        codestream.set(partial, position);
+        position += partial.length;
+    }
+    return codestream;
+}
+exports.JXL = {
+    validate: (input) => {
+        const boxType = (0, utils_1.toUTF8String)(input, 4, 8);
+        if (boxType !== 'JXL ')
+            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 === 'jxl ';
+    },
+    calculate(input) {
+        const codestream = extractCodestream(input);
+        if (codestream)
+            return jxl_stream_1.JXLStream.calculate(codestream);
+        throw new Error('No codestream found in JXL container');
+    },
+};

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KTX = void 0;
+const utils_1 = require("./utils");
+exports.KTX = {
+    validate: (input) => {
+        const signature = (0, utils_1.toUTF8String)(input, 1, 7);
+        return ['KTX 11', 'KTX 20'].includes(signature);
+    },
+    calculate: (input) => {
+        const type = input[5] === 0x31 ? 'ktx' : 'ktx2';
+        const offset = type === 'ktx' ? 36 : 20;
+        return {
+            height: (0, utils_1.readUInt32LE)(input, offset + 4),
+            width: (0, utils_1.readUInt32LE)(input, offset),
+            type,
+        };
+    },
+};

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

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

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNG = void 0;
+const utils_1 = require("./utils");
+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(input) {
+        if (pngSignature === (0, utils_1.toUTF8String)(input, 1, 8)) {
+            let chunkName = (0, utils_1.toUTF8String)(input, 12, 16);
+            if (chunkName === pngFriedChunkName) {
+                chunkName = (0, utils_1.toUTF8String)(input, 28, 32);
+            }
+            if (chunkName !== pngImageHeaderChunkName) {
+                throw new TypeError('Invalid PNG');
+            }
+            return true;
+        }
+        return false;
+    },
+    calculate(input) {
+        if ((0, utils_1.toUTF8String)(input, 12, 16) === pngFriedChunkName) {
+            return {
+                height: (0, utils_1.readUInt32BE)(input, 36),
+                width: (0, utils_1.readUInt32BE)(input, 32),
+            };
+        }
+        return {
+            height: (0, utils_1.readUInt32BE)(input, 20),
+            width: (0, utils_1.readUInt32BE)(input, 16),
+        };
+    },
+};

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNM = void 0;
+const utils_1 = require("./utils");
+const PNMTypes = {
+    P1: 'pbm/ascii',
+    P2: 'pgm/ascii',
+    P3: 'ppm/ascii',
+    P4: 'pbm',
+    P5: 'pgm',
+    P6: 'ppm',
+    P7: 'pam',
+    PF: 'pfm',
+};
+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: (input) => (0, utils_1.toUTF8String)(input, 0, 2) in PNMTypes,
+    calculate(input) {
+        const signature = (0, utils_1.toUTF8String)(input, 0, 2);
+        const type = PNMTypes[signature];
+        // TODO: this probably generates garbage. move to a stream based parser
+        const lines = (0, utils_1.toUTF8String)(input, 3).split(/[\r\n]+/);
+        const handler = handlers[type] || handlers.default;
+        return handler(lines);
+    },
+};

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PSD = void 0;
+const utils_1 = require("./utils");
+exports.PSD = {
+    validate: (input) => (0, utils_1.toUTF8String)(input, 0, 4) === '8BPS',
+    calculate: (input) => ({
+        height: (0, utils_1.readUInt32BE)(input, 14),
+        width: (0, utils_1.readUInt32BE)(input, 18),
+    }),
+};

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

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