astro 5.16.5 → 5.16.7

package/dist/assets/services/service.js

@@ -17,61 +17,64 @@ function parseQuality(quality) {
   return result;
 }
 const sortNumeric = (a, b) => a - b;
-const baseService = {
-  propertiesToHash: DEFAULT_HASH_PROPS,
-  validateOptions(options) {
-    if (!options.src || !isRemoteImage(options.src) && !isESMImportedImage(options.src)) {
+function verifyOptions(options) {
+  if (!options.src || !isRemoteImage(options.src) && !isESMImportedImage(options.src)) {
+    throw new AstroError({
+      ...AstroErrorData.ExpectedImage,
+      message: AstroErrorData.ExpectedImage.message(
+        JSON.stringify(options.src),
+        typeof options.src,
+        JSON.stringify(options, (_, v) => v === void 0 ? null : v)
+      )
+    });
+  }
+  if (!isESMImportedImage(options.src)) {
+    if (options.src.startsWith("/@fs/") || !isRemotePath(options.src) && !options.src.startsWith("/")) {
+      throw new AstroError({
+        ...AstroErrorData.LocalImageUsedWrongly,
+        message: AstroErrorData.LocalImageUsedWrongly.message(options.src)
+      });
+    }
+    let missingDimension;
+    if (!options.width && !options.height) {
+      missingDimension = "both";
+    } else if (!options.width && options.height) {
+      missingDimension = "width";
+    } else if (options.width && !options.height) {
+      missingDimension = "height";
+    }
+    if (missingDimension) {
       throw new AstroError({
-        ...AstroErrorData.ExpectedImage,
-        message: AstroErrorData.ExpectedImage.message(
-          JSON.stringify(options.src),
-          typeof options.src,
-          JSON.stringify(options, (_, v) => v === void 0 ? null : v)
+        ...AstroErrorData.MissingImageDimension,
+        message: AstroErrorData.MissingImageDimension.message(missingDimension, options.src)
+      });
+    }
+  } else {
+    if (!VALID_SUPPORTED_FORMATS.includes(options.src.format)) {
+      throw new AstroError({
+        ...AstroErrorData.UnsupportedImageFormat,
+        message: AstroErrorData.UnsupportedImageFormat.message(
+          options.src.format,
+          options.src.src,
+          VALID_SUPPORTED_FORMATS
         )
       });
     }
-    if (!isESMImportedImage(options.src)) {
-      if (options.src.startsWith("/@fs/") || !isRemotePath(options.src) && !options.src.startsWith("/")) {
-        throw new AstroError({
-          ...AstroErrorData.LocalImageUsedWrongly,
-          message: AstroErrorData.LocalImageUsedWrongly.message(options.src)
-        });
-      }
-      let missingDimension;
-      if (!options.width && !options.height) {
-        missingDimension = "both";
-      } else if (!options.width && options.height) {
-        missingDimension = "width";
-      } else if (options.width && !options.height) {
-        missingDimension = "height";
-      }
-      if (missingDimension) {
-        throw new AstroError({
-          ...AstroErrorData.MissingImageDimension,
-          message: AstroErrorData.MissingImageDimension.message(missingDimension, options.src)
-        });
-      }
-    } else {
-      if (!VALID_SUPPORTED_FORMATS.includes(options.src.format)) {
-        throw new AstroError({
-          ...AstroErrorData.UnsupportedImageFormat,
-          message: AstroErrorData.UnsupportedImageFormat.message(
-            options.src.format,
-            options.src.src,
-            VALID_SUPPORTED_FORMATS
-          )
-        });
-      }
-      if (options.widths && options.densities) {
-        throw new AstroError(AstroErrorData.IncompatibleDescriptorOptions);
-      }
-      if (options.src.format === "svg") {
-        options.format = "svg";
-      }
-      if (options.src.format === "svg" && options.format !== "svg" || options.src.format !== "svg" && options.format === "svg") {
-        throw new AstroError(AstroErrorData.UnsupportedImageConversion);
-      }
+    if (options.widths && options.densities) {
+      throw new AstroError(AstroErrorData.IncompatibleDescriptorOptions);
+    }
+    if (options.src.format === "svg" && options.format !== "svg" || options.src.format !== "svg" && options.format === "svg") {
+      throw new AstroError(AstroErrorData.UnsupportedImageConversion);
+    }
+  }
+}
+const baseService = {
+  propertiesToHash: DEFAULT_HASH_PROPS,
+  validateOptions(options) {
+    if (isESMImportedImage(options.src) && options.src.format === "svg") {
+      options.format = "svg";
     }
+    verifyOptions(options);
     if (!options.format) {
       options.format = DEFAULT_OUTPUT_FORMAT;
     }
@@ -234,5 +237,6 @@ function getTargetDimensions(options) {
 export {
   baseService,
   isLocalService,
-  parseQuality
+  parseQuality,
+  verifyOptions
 };

package/dist/assets/types.d.ts

@@ -72,7 +72,7 @@ export type ImageTransform = {
     fit?: ImageFit | undefined;
     position?: string | undefined;
     [key: string]: any;
-};
+} & Astro.CustomImageProps;
 export interface GetImageResult {
     rawOptions: ImageTransform;
     options: ImageTransform;
@@ -201,7 +201,7 @@ type ImageSharedProps<T> = T & {
     layout?: never;
     fit?: never;
     position?: never;
-});
+}) & Astro.CustomImageProps;
 export type LocalImageProps<T> = ImageSharedProps<T> & {
     /**
      * A reference to a local image imported through an ESM import.

package/dist/assets/utils/index.d.ts

@@ -4,6 +4,7 @@
  *
  * If some functions don't need to be exposed, just import the file that contains the functions.
  */
+export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from '@astrojs/internal-helpers/remote';
 export { isESMImportedImage, isRemoteImage, resolveSrc } from './imageKind.js';
 export { imageMetadata } from './metadata.js';
 export { 
@@ -12,6 +13,5 @@ export {
  */
 emitESMImage, emitImageMetadata, } from './node/emitAsset.js';
 export { getOrigQueryParams } from './queryParams.js';
-export { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern, } from './remotePattern.js';
 export { inferRemoteSize } from './remoteProbe.js';
 export { hashTransform, propsToFilename } from './transformToPath.js';

package/dist/assets/utils/index.js

@@ -1,10 +1,3 @@
-import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
-import { imageMetadata } from "./metadata.js";
-import {
-  emitESMImage,
-  emitImageMetadata
-} from "./node/emitAsset.js";
-import { getOrigQueryParams } from "./queryParams.js";
 import {
   isRemoteAllowed,
   matchHostname,
@@ -12,7 +5,14 @@ import {
   matchPattern,
   matchPort,
   matchProtocol
-} from "./remotePattern.js";
+} from "@astrojs/internal-helpers/remote";
+import { isESMImportedImage, isRemoteImage, resolveSrc } from "./imageKind.js";
+import { imageMetadata } from "./metadata.js";
+import {
+  emitESMImage,
+  emitImageMetadata
+} from "./node/emitAsset.js";
+import { getOrigQueryParams } from "./queryParams.js";
 import { inferRemoteSize } from "./remoteProbe.js";
 import { hashTransform, propsToFilename } from "./transformToPath.js";
 export {

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) => ({