astro 4.3.7 → 4.4.0

package/components/Image.astro

@@ -29,6 +29,10 @@ const additionalAttributes: HTMLAttributes<'img'> = {};
 if (image.srcSet.values.length > 0) {
 	additionalAttributes.srcset = image.srcSet.attribute;
 }
+
+if (import.meta.env.DEV) {
+	additionalAttributes['data-image-component'] = 'true';
+}
 ---
 
 <img src={image.src} {...additionalAttributes} {...image.attributes} />

package/components/Picture.astro

@@ -61,6 +61,10 @@ if (props.sizes) {
 if (fallbackImage.srcSet.values.length > 0) {
 	imgAdditionalAttributes.srcset = fallbackImage.srcSet.attribute;
 }
+
+if (import.meta.env.DEV) {
+	imgAdditionalAttributes['data-image-component'] = 'true';
+}
 ---
 
 <picture {...pictureAttributes}>

package/dist/assets/internal.js

@@ -2,6 +2,7 @@ import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { DEFAULT_HASH_PROPS } from "./consts.js";
 import { isLocalService } from "./services/service.js";
 import { isESMImportedImage, isRemoteImage } from "./utils/imageKind.js";
+import { probe } from "./utils/remoteProbe.js";
 async function getConfiguredImageService() {
   if (!globalThis?.astroAsset?.imageService) {
     const { default: service } = await import(
@@ -41,6 +42,19 @@ async function getImage(options, imageConfig) {
     ...options,
     src: typeof options.src === "object" && "then" in options.src ? (await options.src).default ?? await options.src : options.src
   };
+  if (options.inferSize && isRemoteImage(resolvedOptions.src)) {
+    try {
+      const result = await probe(resolvedOptions.src);
+      resolvedOptions.width ??= result.width;
+      resolvedOptions.height ??= result.height;
+      delete resolvedOptions.inferSize;
+    } catch {
+      throw new AstroError({
+        ...AstroErrorData.FailedToFetchRemoteImageDimensions,
+        message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(resolvedOptions.src)
+      });
+    }
+  }
   const originalPath = isESMImportedImage(resolvedOptions.src) ? resolvedOptions.src.fsPath : resolvedOptions.src;
   const clonedSrc = isESMImportedImage(resolvedOptions.src) ? (
     // @ts-expect-error - clone is a private, hidden prop

package/dist/assets/types.d.ts

@@ -48,6 +48,7 @@ export type UnresolvedImageTransform = Omit<ImageTransform, 'src'> & {
     src: ImageMetadata | string | Promise<{
         default: ImageMetadata;
     }>;
+    inferSize?: boolean;
 };
 /**
  * Options accepted by the image transformation service.
@@ -159,7 +160,7 @@ export type LocalImageProps<T> = ImageSharedProps<T> & {
      */
     quality?: ImageQuality;
 };
-export type RemoteImageProps<T> = WithRequired<ImageSharedProps<T>, 'width' | 'height'> & {
+export type RemoteImageProps<T> = (ImageSharedProps<T> & {
     /**
      * URL of a remote image. Can start with a protocol (ex: `https://`) or alternatively `/`, or `Astro.url`, for images in the `public` folder
      *
@@ -171,5 +172,25 @@ export type RemoteImageProps<T> = WithRequired<ImageSharedProps<T>, 'width' | 'h
      * ```
      */
     src: string;
-};
+    /**
+     * When inferSize is true width and height are not required
+     */
+    inferSize: true;
+}) | (WithRequired<ImageSharedProps<T>, 'width' | 'height'> & {
+    /**
+     * URL of a remote image. Can start with a protocol (ex: `https://`) or alternatively `/`, or `Astro.url`, for images in the `public` folder
+     *
+     * Remote images are not optimized, and require both `width` and `height` to be set.
+     *
+     * **Example**:
+     * ```
+     * <Image src="https://example.com/image.png" width={450} height={300} alt="..." />
+     * ```
+     */
+    src: string;
+    /**
+     * When inferSize is false or undefined width and height are required
+     */
+    inferSize?: false | undefined;
+});
 export {};

package/dist/assets/utils/metadata.js

@@ -1,8 +1,8 @@
-import probe from "probe-image-size";
+import { lookup as probe } from "../utils/vendor/image-size/lookup.js";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
 async function imageMetadata(data, src) {
-  const result = probe.sync(data);
-  if (result === null) {
+  const result = probe(data);
+  if (!result.height || !result.width || !result.type) {
     throw new AstroError({
       ...AstroErrorData.NoImageMetadata,
       message: AstroErrorData.NoImageMetadata.message(src)

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

@@ -0,0 +1,2 @@
+import type { ISize } from './vendor/image-size/types/interface.ts';
+export declare function probe(url: string): Promise<ISize>;

package/dist/assets/utils/remoteProbe.js

@@ -0,0 +1,35 @@
+import { lookup } from "./vendor/image-size/lookup.js";
+async function probe(url) {
+  const response = await fetch(url);
+  if (!response.body || !response.ok) {
+    throw new Error("Failed to fetch image");
+  }
+  const reader = response.body.getReader();
+  let done, value;
+  let accumulatedChunks = new Uint8Array();
+  while (!done) {
+    const readResult = await reader.read();
+    done = readResult.done;
+    if (done)
+      break;
+    if (readResult.value) {
+      value = readResult.value;
+      let tmp = new Uint8Array(accumulatedChunks.length + value.length);
+      tmp.set(accumulatedChunks, 0);
+      tmp.set(value, accumulatedChunks.length);
+      accumulatedChunks = tmp;
+      try {
+        const dimensions = lookup(accumulatedChunks);
+        if (dimensions) {
+          await reader.cancel();
+          return dimensions;
+        }
+      } catch (error) {
+      }
+    }
+  }
+  throw new Error("Failed to parse the size");
+}
+export {
+  probe
+};

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

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

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

@@ -0,0 +1,24 @@
+import { typeHandlers, types } from "./types/index.js";
+const firstBytes = /* @__PURE__ */ new Map([
+  [56, "psd"],
+  [66, "bmp"],
+  [68, "dds"],
+  [71, "gif"],
+  [73, "tiff"],
+  [77, "tiff"],
+  [82, "webp"],
+  [105, "icns"],
+  [137, "png"],
+  [255, "jpg"]
+]);
+function detector(input) {
+  const byte = input[0];
+  const type = firstBytes.get(byte);
+  if (type && typeHandlers.get(type).validate(input)) {
+    return type;
+  }
+  return types.find((fileType) => typeHandlers.get(fileType).validate(input));
+}
+export {
+  detector
+};

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

@@ -0,0 +1,10 @@
+import type { imageType } from './types/index.js';
+import type { ISizeCalculationResult } from './types/interface.ts';
+/**
+ * Return size information based on an Uint8Array
+ *
+ * @param {Uint8Array} input
+ * @returns {ISizeCalculationResult}
+ */
+export declare function lookup(input: Uint8Array): ISizeCalculationResult;
+export declare const disableTypes: (types: imageType[]) => void;

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

@@ -0,0 +1,26 @@
+import { typeHandlers } from "./types/index.js";
+import { detector } from "./detector.js";
+const globalOptions = {
+  disabledTypes: []
+};
+function lookup(input) {
+  const type = detector(input);
+  if (typeof type !== "undefined") {
+    if (globalOptions.disabledTypes.indexOf(type) > -1) {
+      throw new TypeError("disabled file type: " + type);
+    }
+    const size = typeHandlers.get(type).calculate(input);
+    if (size !== void 0) {
+      size.type = size.type ?? type;
+      return size;
+    }
+  }
+  throw new TypeError("unsupported file type: " + type);
+}
+const disableTypes = (types) => {
+  globalOptions.disabledTypes = types;
+};
+export {
+  disableTypes,
+  lookup
+};

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

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

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

@@ -0,0 +1,11 @@
+import { toUTF8String, readInt32LE, readUInt32LE } from "./utils.js";
+const BMP = {
+  validate: (input) => toUTF8String(input, 0, 2) === "BM",
+  calculate: (input) => ({
+    height: Math.abs(readInt32LE(input, 22)),
+    width: readUInt32LE(input, 18)
+  })
+};
+export {
+  BMP
+};

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

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

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

@@ -0,0 +1,17 @@
+import { ICO } from "./ico.js";
+import { readUInt16LE } from "./utils.js";
+const TYPE_CURSOR = 2;
+const CUR = {
+  validate(input) {
+    const reserved = readUInt16LE(input, 0);
+    const imageCount = readUInt16LE(input, 4);
+    if (reserved !== 0 || imageCount === 0)
+      return false;
+    const imageType = readUInt16LE(input, 2);
+    return imageType === TYPE_CURSOR;
+  },
+  calculate: (input) => ICO.calculate(input)
+};
+export {
+  CUR
+};

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

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

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

@@ -0,0 +1,11 @@
+import { readUInt32LE } from "./utils.js";
+const DDS = {
+  validate: (input) => readUInt32LE(input, 0) === 542327876,
+  calculate: (input) => ({
+    height: readUInt32LE(input, 12),
+    width: readUInt32LE(input, 16)
+  })
+};
+export {
+  DDS
+};

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

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

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

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

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

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

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

@@ -0,0 +1,53 @@
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
+const brandMap = {
+  avif: "avif",
+  mif1: "heif",
+  msf1: "heif",
+  // hief-sequence
+  heic: "heic",
+  heix: "heic",
+  hevc: "heic",
+  // heic-sequence
+  hevx: "heic"
+  // heic-sequence
+};
+function detectBrands(buffer, start, end) {
+  let brandsDetected = {};
+  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) {
+    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 HEIF = {
+  validate(buffer) {
+    const ftype = toUTF8String(buffer, 4, 8);
+    const brand = toUTF8String(buffer, 8, 12);
+    return "ftyp" === ftype && 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)
+      };
+    }
+    throw new TypeError("Invalid HEIF, no size found");
+  }
+};
+export {
+  HEIF
+};

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

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

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

@@ -0,0 +1,85 @@
+import { toUTF8String, readUInt32BE } from "./utils.js";
+const SIZE_HEADER = 4 + 4;
+const FILE_LENGTH_OFFSET = 4;
+const ENTRY_LENGTH_OFFSET = 4;
+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 [
+    toUTF8String(input, imageOffset, imageLengthOffset),
+    readUInt32BE(input, imageLengthOffset)
+  ];
+}
+function getImageSize(type) {
+  const size = ICON_TYPE_SIZE[type];
+  return { width: size, height: size, type };
+}
+const ICNS = {
+  validate: (input) => toUTF8String(input, 0, 4) === "icns",
+  calculate(input) {
+    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
+    };
+    while (imageOffset < fileLength && imageOffset < inputLength) {
+      imageHeader = readImageHeader(input, imageOffset);
+      imageSize = getImageSize(imageHeader[0]);
+      imageOffset += imageHeader[1];
+      result.images.push(imageSize);
+    }
+    return result;
+  }
+};
+export {
+  ICNS
+};

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

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

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

@@ -0,0 +1,43 @@
+import { readUInt16LE } from "./utils.js";
+const TYPE_ICON = 1;
+const SIZE_HEADER = 2 + 2 + 2;
+const SIZE_IMAGE_ENTRY = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4;
+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)
+  };
+}
+const ICO = {
+  validate(input) {
+    const reserved = readUInt16LE(input, 0);
+    const imageCount = readUInt16LE(input, 4);
+    if (reserved !== 0 || imageCount === 0)
+      return false;
+    const imageType = readUInt16LE(input, 2);
+    return imageType === TYPE_ICON;
+  },
+  calculate(input) {
+    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));
+    }
+    return {
+      height: imageSize.height,
+      images: imgs,
+      width: imageSize.width
+    };
+  }
+};
+export {
+  ICO
+};

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

@@ -0,0 +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];

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

@@ -0,0 +1,43 @@
+import { BMP } from "./bmp.js";
+import { CUR } from "./cur.js";
+import { DDS } from "./dds.js";
+import { GIF } from "./gif.js";
+import { HEIF } from "./heif.js";
+import { ICNS } from "./icns.js";
+import { ICO } from "./ico.js";
+import { J2C } from "./j2c.js";
+import { JP2 } from "./jp2.js";
+import { JPG } from "./jpg.js";
+import { KTX } from "./ktx.js";
+import { PNG } from "./png.js";
+import { PNM } from "./pnm.js";
+import { PSD } from "./psd.js";
+import { SVG } from "./svg.js";
+import { TGA } from "./tga.js";
+import { TIFF } from "./tiff.js";
+import { WEBP } from "./webp.js";
+const typeHandlers = /* @__PURE__ */ new Map([
+  ["bmp", BMP],
+  ["cur", CUR],
+  ["dds", DDS],
+  ["gif", GIF],
+  ["heif", HEIF],
+  ["icns", ICNS],
+  ["ico", ICO],
+  ["j2c", J2C],
+  ["jp2", JP2],
+  ["jpg", JPG],
+  ["ktx", KTX],
+  ["png", PNG],
+  ["pnm", PNM],
+  ["psd", PSD],
+  ["svg", SVG],
+  ["tga", TGA],
+  ["tiff", TIFF],
+  ["webp", WEBP]
+]);
+const types = Array.from(typeHandlers.keys());
+export {
+  typeHandlers,
+  types
+};

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { toHexString, 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",
+  calculate: (input) => ({
+    height: readUInt32BE(input, 12),
+    width: readUInt32BE(input, 8)
+  })
+};
+export {
+  J2C
+};

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

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

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

@@ -0,0 +1,25 @@
+import { readUInt32BE, findBox } from "./utils.js";
+const JP2 = {
+  validate(input) {
+    if (readUInt32BE(input, 4) !== 1783636e3 || readUInt32BE(input, 0) < 1)
+      return false;
+    const ftypBox = findBox(input, "ftyp", 0);
+    if (!ftypBox)
+      return false;
+    return readUInt32BE(input, ftypBox.offset + 4) === 1718909296;
+  },
+  calculate(input) {
+    const jp2hBox = findBox(input, "jp2h", 0);
+    const ihdrBox = jp2hBox && findBox(input, "ihdr", jp2hBox.offset + 8);
+    if (ihdrBox) {
+      return {
+        height: readUInt32BE(input, ihdrBox.offset + 8),
+        width: readUInt32BE(input, ihdrBox.offset + 12)
+      };
+    }
+    throw new TypeError("Unsupported JPEG 2000 format");
+  }
+};
+export {
+  JP2
+};

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

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