astro 5.16.6 → 5.16.8

package/dist/assets/utils/vendor/image-size/detector.d.ts

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

package/dist/assets/utils/vendor/image-size/detector.js

@@ -1,5 +1,6 @@
 import { typeHandlers, types } from "./types/index.js";
 const firstBytes = /* @__PURE__ */ new Map([
+  [0, "heif"],
   [56, "psd"],
   [66, "bmp"],
   [68, "dds"],
@@ -17,7 +18,7 @@ function detector(input) {
   if (type && typeHandlers.get(type).validate(input)) {
     return type;
   }
-  return types.find((fileType) => typeHandlers.get(fileType).validate(input));
+  return types.find((imageType) => typeHandlers.get(imageType).validate(input));
 }
 export {
   detector

package/dist/assets/utils/vendor/image-size/types/bmp.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readInt32LE, readUInt32LE } from "./utils.js";
+import { readInt32LE, readUInt32LE, toUTF8String } from "./utils.js";
 const BMP = {
   validate: (input) => toUTF8String(input, 0, 2) === "BM",
   calculate: (input) => ({

package/dist/assets/utils/vendor/image-size/types/gif.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readUInt16LE } from "./utils.js";
+import { readUInt16LE, toUTF8String } from "./utils.js";
 const gifRegexp = /^GIF8[79]a/;
 const GIF = {
   validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),

package/dist/assets/utils/vendor/image-size/types/heif.js

@@ -13,41 +13,63 @@ const brandMap = {
   hevx: "heic"
   // heic-sequence
 };
-function detectBrands(buffer, start, end) {
-  let brandsDetected = {};
+function detectType(input, start, end) {
+  let hasAvif = false;
+  let hasHeic = false;
+  let hasHeif = false;
   for (let i = start; i <= end; i += 4) {
-    const brand = toUTF8String(buffer, i, i + 4);
-    if (brand in brandMap) {
-      brandsDetected[brand] = 1;
-    }
-  }
-  if ("avif" in brandsDetected || "avis" in brandsDetected) {
-    return "avif";
-  } else if ("heic" in brandsDetected || "heix" in brandsDetected || "hevc" in brandsDetected || "hevx" in brandsDetected) {
-    return "heic";
-  } else if ("mif1" in brandsDetected || "msf1" in brandsDetected) {
-    return "heif";
+    const brand = toUTF8String(input, i, i + 4);
+    if (brand === "avif" || brand === "avis") hasAvif = true;
+    else if (brand === "heic" || brand === "heix" || brand === "hevc" || brand === "hevx") hasHeic = true;
+    else if (brand === "mif1" || brand === "msf1") hasHeif = true;
   }
+  if (hasAvif) return "avif";
+  if (hasHeic) return "heic";
+  if (hasHeif) return "heif";
 }
 const HEIF = {
-  validate(buffer) {
-    const ftype = toUTF8String(buffer, 4, 8);
-    const brand = toUTF8String(buffer, 8, 12);
-    return "ftyp" === ftype && brand in brandMap;
+  validate(input) {
+    const boxType = toUTF8String(input, 4, 8);
+    if (boxType !== "ftyp") return false;
+    const ftypBox = findBox(input, "ftyp", 0);
+    if (!ftypBox) return false;
+    const brand = toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12);
+    return brand in brandMap;
   },
-  calculate(buffer) {
-    const metaBox = findBox(buffer, "meta", 0);
-    const iprpBox = metaBox && findBox(buffer, "iprp", metaBox.offset + 12);
-    const ipcoBox = iprpBox && findBox(buffer, "ipco", iprpBox.offset + 8);
-    const ispeBox = ipcoBox && findBox(buffer, "ispe", ipcoBox.offset + 8);
-    if (ispeBox) {
-      return {
-        height: readUInt32BE(buffer, ispeBox.offset + 16),
-        width: readUInt32BE(buffer, ispeBox.offset + 12),
-        type: detectBrands(buffer, 8, metaBox.offset)
-      };
+  calculate(input) {
+    const metaBox = findBox(input, "meta", 0);
+    const iprpBox = metaBox && findBox(input, "iprp", metaBox.offset + 12);
+    const ipcoBox = iprpBox && findBox(input, "ipco", iprpBox.offset + 8);
+    if (!ipcoBox) {
+      throw new TypeError("Invalid HEIF, no ipco box found");
+    }
+    const type = detectType(input, 8, metaBox.offset);
+    const images = [];
+    let currentOffset = ipcoBox.offset + 8;
+    while (currentOffset < ipcoBox.offset + ipcoBox.size) {
+      const ispeBox = findBox(input, "ispe", currentOffset);
+      if (!ispeBox) break;
+      const rawWidth = readUInt32BE(input, ispeBox.offset + 12);
+      const rawHeight = readUInt32BE(input, ispeBox.offset + 16);
+      const clapBox = findBox(input, "clap", currentOffset);
+      let width = rawWidth;
+      let height = rawHeight;
+      if (clapBox && clapBox.offset < ipcoBox.offset + ipcoBox.size) {
+        const cropRight = readUInt32BE(input, clapBox.offset + 12);
+        width = rawWidth - cropRight;
+      }
+      images.push({ height, width });
+      currentOffset = ispeBox.offset + ispeBox.size;
+    }
+    if (images.length === 0) {
+      throw new TypeError("Invalid HEIF, no sizes found");
     }
-    throw new TypeError("Invalid HEIF, no size found");
+    return {
+      width: images[0].width,
+      height: images[0].height,
+      type,
+      ...images.length > 1 ? { images } : {}
+    };
   }
 };
 export {

package/dist/assets/utils/vendor/image-size/types/icns.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readUInt32BE } from "./utils.js";
+import { readUInt32BE, toUTF8String } from "./utils.js";
 const SIZE_HEADER = 4 + 4;
 const FILE_LENGTH_OFFSET = 4;
 const ENTRY_LENGTH_OFFSET = 4;
@@ -61,22 +61,21 @@ const ICNS = {
     const inputLength = input.length;
     const fileLength = 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
-    };
+    const images = [];
     while (imageOffset < fileLength && imageOffset < inputLength) {
-      imageHeader = readImageHeader(input, imageOffset);
-      imageSize = getImageSize(imageHeader[0]);
+      const imageHeader = readImageHeader(input, imageOffset);
+      const imageSize = getImageSize(imageHeader[0]);
+      images.push(imageSize);
       imageOffset += imageHeader[1];
-      result.images.push(imageSize);
     }
-    return result;
+    if (images.length === 0) {
+      throw new TypeError("Invalid ICNS, no sizes found");
+    }
+    return {
+      width: images[0].width,
+      height: images[0].height,
+      ...images.length > 1 ? { images } : {}
+    };
   }
 };
 export {

package/dist/assets/utils/vendor/image-size/types/ico.js

@@ -25,14 +25,14 @@ const ICO = {
     const nbImages = 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));
+    const images = [];
+    for (let imageIndex = 0; imageIndex < nbImages; imageIndex += 1) {
+      images.push(getImageSize(input, imageIndex));
     }
     return {
+      width: imageSize.width,
       height: imageSize.height,
-      images: imgs,
-      width: imageSize.width
+      images
     };
   }
 };

package/dist/assets/utils/vendor/image-size/types/index.d.ts

@@ -1,3 +1,3 @@
-export declare const typeHandlers: Map<"jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
-export declare const types: ("jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "pnm" | "psd" | "tga")[];
-export type imageType = typeof types[number];
+export declare const typeHandlers: Map<"jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "jxl" | "jxl-stream" | "pnm" | "psd" | "tga", import("./interface.js").IImage>;
+export declare const types: ("jpg" | "png" | "tiff" | "webp" | "gif" | "svg" | "heif" | "icns" | "ktx" | "bmp" | "cur" | "dds" | "ico" | "j2c" | "jp2" | "jxl" | "jxl-stream" | "pnm" | "psd" | "tga")[];
+export type imageType = (typeof types)[number];

package/dist/assets/utils/vendor/image-size/types/index.js

@@ -8,6 +8,8 @@ import { ICO } from "./ico.js";
 import { J2C } from "./j2c.js";
 import { JP2 } from "./jp2.js";
 import { JPG } from "./jpg.js";
+import { JXL } from "./jxl.js";
+import { JXLStream } from "./jxl-stream.js";
 import { KTX } from "./ktx.js";
 import { PNG } from "./png.js";
 import { PNM } from "./pnm.js";
@@ -27,6 +29,8 @@ const typeHandlers = /* @__PURE__ */ new Map([
   ["j2c", J2C],
   ["jp2", JP2],
   ["jpg", JPG],
+  ["jxl", JXL],
+  ["jxl-stream", JXLStream],
   ["ktx", KTX],
   ["png", PNG],
   ["pnm", PNM],

package/dist/assets/utils/vendor/image-size/types/interface.d.ts

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

package/dist/assets/utils/vendor/image-size/types/j2c.js

@@ -1,7 +1,7 @@
-import { toHexString, readUInt32BE } from "./utils.js";
+import { readUInt32BE } from "./utils.js";
 const J2C = {
   // TODO: this doesn't seem right. SIZ marker doesn't have to be right after the SOC
-  validate: (input) => toHexString(input, 0, 4) === "ff4fff51",
+  validate: (input) => readUInt32BE(input, 0) === 4283432785,
   calculate: (input) => ({
     height: readUInt32BE(input, 12),
     width: readUInt32BE(input, 8)

package/dist/assets/utils/vendor/image-size/types/jp2.js

@@ -1,10 +1,12 @@
-import { readUInt32BE, findBox } from "./utils.js";
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
 const JP2 = {
   validate(input) {
-    if (readUInt32BE(input, 4) !== 1783636e3 || readUInt32BE(input, 0) < 1) return false;
+    const boxType = toUTF8String(input, 4, 8);
+    if (boxType !== "jP  ") return false;
     const ftypBox = findBox(input, "ftyp", 0);
     if (!ftypBox) return false;
-    return readUInt32BE(input, ftypBox.offset + 4) === 1718909296;
+    const brand = toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12);
+    return brand === "jp2 ";
   },
   calculate(input) {
     const jp2hBox = findBox(input, "jp2h", 0);

package/dist/assets/utils/vendor/image-size/types/jpg.js

@@ -61,20 +61,20 @@ function validateInput(input, index) {
 }
 const JPG = {
   validate: (input) => toHexString(input, 0, 2) === "ffd8",
-  calculate(input) {
-    input = input.slice(4);
+  calculate(_input) {
+    let input = _input.slice(4);
     let orientation;
     let next;
     while (input.length) {
       const i = readUInt16BE(input, 0);
+      validateInput(input, i);
       if (input[i] !== 255) {
-        input = input.slice(i);
+        input = input.slice(1);
         continue;
       }
       if (isEXIF(input)) {
         orientation = validateExifBlock(input, i);
       }
-      validateInput(input, i);
       next = input[i + 1];
       if (next === 192 || next === 193 || next === 194) {
         const size = extractSize(input, i + 5);

package/dist/assets/utils/vendor/image-size/types/jxl-stream.d.ts

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

package/dist/assets/utils/vendor/image-size/types/jxl-stream.js

@@ -0,0 +1,36 @@
+import { BitReader } from "../utils/bit-reader.js";
+import { toHexString } from "./utils.js";
+function calculateImageDimension(reader, isSmallImage) {
+  if (isSmallImage) {
+    return 8 * (1 + reader.getBits(5));
+  }
+  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) {
+    return 8 * (1 + reader.getBits(5));
+  }
+  if (widthMode === 0) {
+    return calculateImageDimension(reader, false);
+  }
+  const aspectRatios = [1, 1.2, 4 / 3, 1.5, 16 / 9, 5 / 4, 2];
+  return Math.floor(height * aspectRatios[widthMode - 1]);
+}
+const JXLStream = {
+  validate: (input) => {
+    return toHexString(input, 0, 2) === "ff0a";
+  },
+  calculate(input) {
+    const reader = new 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 };
+  }
+};
+export {
+  JXLStream
+};

package/dist/assets/utils/vendor/image-size/types/jxl.d.ts

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

package/dist/assets/utils/vendor/image-size/types/jxl.js

@@ -0,0 +1,57 @@
+import { JXLStream } from "./jxl-stream.js";
+import { findBox, toUTF8String } from "./utils.js";
+function extractCodestream(input) {
+  const jxlcBox = 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 void 0;
+}
+function extractPartialStreams(input) {
+  const partialStreams = [];
+  let offset = 0;
+  while (offset < input.length) {
+    const jxlpBox = 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;
+}
+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;
+}
+const JXL = {
+  validate: (input) => {
+    const boxType = toUTF8String(input, 4, 8);
+    if (boxType !== "JXL ") return false;
+    const ftypBox = findBox(input, "ftyp", 0);
+    if (!ftypBox) return false;
+    const brand = toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12);
+    return brand === "jxl ";
+  },
+  calculate(input) {
+    const codestream = extractCodestream(input);
+    if (codestream) return JXLStream.calculate(codestream);
+    throw new Error("No codestream found in JXL container");
+  }
+};
+export {
+  JXL
+};

package/dist/assets/utils/vendor/image-size/types/ktx.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readUInt32LE } from "./utils.js";
+import { readUInt32LE, toUTF8String } from "./utils.js";
 const KTX = {
   validate: (input) => {
     const signature = toUTF8String(input, 1, 7);

package/dist/assets/utils/vendor/image-size/types/png.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readUInt32BE } from "./utils.js";
+import { readUInt32BE, toUTF8String } from "./utils.js";
 const pngSignature = "PNG\r\n\n";
 const pngImageHeaderChunkName = "IHDR";
 const pngFriedChunkName = "CgBI";

package/dist/assets/utils/vendor/image-size/types/pnm.js

@@ -22,12 +22,11 @@ const handlers = {
     }
     if (dimensions.length === 2) {
       return {
-        height: parseInt(dimensions[1], 10),
-        width: parseInt(dimensions[0], 10)
+        height: Number.parseInt(dimensions[1], 10),
+        width: Number.parseInt(dimensions[0], 10)
       };
-    } else {
-      throw new TypeError("Invalid PNM");
     }
+    throw new TypeError("Invalid PNM");
   },
   pam: (lines) => {
     const size = {};
@@ -38,7 +37,7 @@ const handlers = {
       }
       const [key, value] = line.split(" ");
       if (key && value) {
-        size[key.toLowerCase()] = parseInt(value, 10);
+        size[key.toLowerCase()] = Number.parseInt(value, 10);
       }
       if (size.height && size.width) {
         break;
@@ -49,9 +48,8 @@ const handlers = {
         height: size.height,
         width: size.width
       };
-    } else {
-      throw new TypeError("Invalid PAM");
     }
+    throw new TypeError("Invalid PAM");
   }
 };
 const PNM = {

package/dist/assets/utils/vendor/image-size/types/psd.js

@@ -1,4 +1,4 @@
-import { toUTF8String, readUInt32BE } from "./utils.js";
+import { readUInt32BE, toUTF8String } from "./utils.js";
 const PSD = {
   validate: (input) => toUTF8String(input, 0, 4) === "8BPS",
   calculate: (input) => ({

package/dist/assets/utils/vendor/image-size/types/tiff.js

@@ -1,64 +1,117 @@
-import { readUInt, toHexString, toUTF8String } from "./utils.js";
-function readIFD(input, isBigEndian) {
-  const ifdOffset = readUInt(input, 32, 4, isBigEndian);
-  return input.slice(ifdOffset + 2);
+import { readUInt, readUInt64, toHexString, toUTF8String } from "./utils.js";
+const CONSTANTS = {
+  TAG: {
+    WIDTH: 256,
+    HEIGHT: 257,
+    COMPRESSION: 259
+  },
+  TYPE: {
+    SHORT: 3,
+    LONG: 4,
+    LONG8: 16
+  },
+  ENTRY_SIZE: {
+    STANDARD: 12,
+    BIG: 20
+  },
+  COUNT_SIZE: {
+    STANDARD: 2,
+    BIG: 8
+  }
+};
+function readIFD(input, { isBigEndian, isBigTiff }) {
+  const ifdOffset = isBigTiff ? Number(readUInt64(input, 8, isBigEndian)) : readUInt(input, 32, 4, isBigEndian);
+  const entryCountSize = isBigTiff ? CONSTANTS.COUNT_SIZE.BIG : CONSTANTS.COUNT_SIZE.STANDARD;
+  return input.slice(ifdOffset + entryCountSize);
 }
-function readValue(input, isBigEndian) {
-  const low = readUInt(input, 16, 8, isBigEndian);
-  const high = readUInt(input, 16, 10, isBigEndian);
-  return (high << 16) + low;
+function readTagValue(input, type, offset, isBigEndian) {
+  switch (type) {
+    case CONSTANTS.TYPE.SHORT:
+      return readUInt(input, 16, offset, isBigEndian);
+    case CONSTANTS.TYPE.LONG:
+      return readUInt(input, 32, offset, isBigEndian);
+    case CONSTANTS.TYPE.LONG8: {
+      const value = Number(readUInt64(input, offset, isBigEndian));
+      if (value > Number.MAX_SAFE_INTEGER) {
+        throw new TypeError("Value too large");
+      }
+      return value;
+    }
+    default:
+      return 0;
+  }
 }
-function nextTag(input) {
-  if (input.length > 24) {
-    return input.slice(12);
+function nextTag(input, isBigTiff) {
+  const entrySize = isBigTiff ? CONSTANTS.ENTRY_SIZE.BIG : CONSTANTS.ENTRY_SIZE.STANDARD;
+  if (input.length > entrySize) {
+    return input.slice(entrySize);
   }
 }
-function extractTags(input, isBigEndian) {
+function extractTags(input, { isBigEndian, isBigTiff }) {
   const tags = {};
   let temp = input;
-  while (temp && temp.length) {
+  while (temp?.length) {
     const code = readUInt(temp, 16, 0, isBigEndian);
     const type = readUInt(temp, 16, 2, isBigEndian);
-    const length = readUInt(temp, 32, 4, isBigEndian);
-    if (code === 0) {
-      break;
-    } else {
-      if (length === 1 && (type === 3 || type === 4)) {
-        tags[code] = readValue(temp, isBigEndian);
-      }
-      temp = nextTag(temp);
+    const length = isBigTiff ? Number(readUInt64(temp, 4, isBigEndian)) : readUInt(temp, 32, 4, isBigEndian);
+    if (code === 0) break;
+    if (length === 1 && (type === CONSTANTS.TYPE.SHORT || type === CONSTANTS.TYPE.LONG || isBigTiff && type === CONSTANTS.TYPE.LONG8)) {
+      const valueOffset = isBigTiff ? 12 : 8;
+      tags[code] = readTagValue(temp, type, valueOffset, isBigEndian);
     }
+    temp = nextTag(temp, isBigTiff);
   }
   return tags;
 }
-function determineEndianness(input) {
+function determineFormat(input) {
   const signature = toUTF8String(input, 0, 2);
-  if ("II" === signature) {
-    return "LE";
-  } else if ("MM" === signature) {
-    return "BE";
+  const version = readUInt(input, 16, 2, signature === "MM");
+  return {
+    isBigEndian: signature === "MM",
+    isBigTiff: version === 43
+  };
+}
+function validateBigTIFFHeader(input, isBigEndian) {
+  const byteSize = readUInt(input, 16, 4, isBigEndian);
+  const reserved = readUInt(input, 16, 6, isBigEndian);
+  if (byteSize !== 8 || reserved !== 0) {
+    throw new TypeError("Invalid BigTIFF header");
   }
 }
-const signatures = [
-  // '492049', // currently not supported
+const signatures = /* @__PURE__ */ new Set([
   "49492a00",
-  // Little endian
-  "4d4d002a"
+  // Little Endian
+  "4d4d002a",
   // Big Endian
-  // '4d4d002a', // BigTIFF > 4GB. currently not supported
-];
+  "49492b00",
+  // BigTIFF Little Endian
+  "4d4d002b"
+  // BigTIFF Big Endian
+]);
 const TIFF = {
-  validate: (input) => signatures.includes(toHexString(input, 0, 4)),
+  validate: (input) => {
+    const signature = toHexString(input, 0, 4);
+    return signatures.has(signature);
+  },
   calculate(input) {
-    const isBigEndian = determineEndianness(input) === "BE";
-    const ifdBuffer = readIFD(input, isBigEndian);
-    const tags = extractTags(ifdBuffer, isBigEndian);
-    const width = tags[256];
-    const height = tags[257];
-    if (!width || !height) {
+    const format = determineFormat(input);
+    if (format.isBigTiff) {
+      validateBigTIFFHeader(input, format.isBigEndian);
+    }
+    const ifdBuffer = readIFD(input, format);
+    const tags = extractTags(ifdBuffer, format);
+    const info = {
+      height: tags[CONSTANTS.TAG.HEIGHT],
+      width: tags[CONSTANTS.TAG.WIDTH],
+      type: format.isBigTiff ? "bigtiff" : "tiff"
+    };
+    if (tags[CONSTANTS.TAG.COMPRESSION]) {
+      info.compression = tags[CONSTANTS.TAG.COMPRESSION];
+    }
+    if (!info.width || !info.height) {
       throw new TypeError("Invalid Tiff. Missing tags");
     }
-    return { height, width };
+    return info;
   }
 };
 export {

package/dist/assets/utils/vendor/image-size/types/utils.d.ts

@@ -7,8 +7,9 @@ export declare const readUInt24LE: (input: Uint8Array, offset?: number) => numbe
 export declare const readInt32LE: (input: Uint8Array, offset?: number) => number;
 export declare const readUInt32BE: (input: Uint8Array, offset?: number) => number;
 export declare const readUInt32LE: (input: Uint8Array, offset?: number) => number;
-export declare function readUInt(input: Uint8Array, bits: 16 | 32, offset: number, isBigEndian: boolean): number;
-export declare function findBox(buffer: Uint8Array, boxName: string, offset: number): {
+export declare const readUInt64: (input: Uint8Array, offset: number, isBigEndian: boolean) => bigint;
+export declare function readUInt(input: Uint8Array, bits: 16 | 32, offset?: number, isBigEndian?: boolean): number;
+export declare function findBox(input: Uint8Array, boxName: string, currentOffset: number): {
     name: string;
     offset: number;
     size: number;