astro 4.3.7 → 4.4.1

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/@types/astro.d.ts

@@ -1374,7 +1374,7 @@ export interface AstroUserConfig {
              * URLs will be of the form `example.com/[locale]/content/` for every route, including the default language.
              * Localized folders are used for every language, including the default.
              */
-            prefixDefaultLocale: boolean;
+            prefixDefaultLocale?: boolean;
             /**
              * @docs
              * @name i18n.routing.redirectToDefaultLocale
@@ -1402,7 +1402,7 @@ export interface AstroUserConfig {
              * })
              *```
              * */
-            redirectToDefaultLocale: boolean;
+            redirectToDefaultLocale?: boolean;
             /**
              * @name i18n.routing.strategy
              * @type {"pathname"}
@@ -1412,47 +1412,47 @@ export interface AstroUserConfig {
              *
              * - `"pathname": The strategy is applied to the pathname of the URLs
              */
-            strategy: 'pathname';
-            /**
-             * @name i18n.domains
-             * @type {Record<string, string> }
-             * @default '{}'
-             * @version 4.3.0
-             * @description
-             *
-             * Configures the URL pattern of one or more supported languages to use a custom domain (or sub-domain).
-             *
-             * When a locale is mapped to a domain, a `/[locale]/` path prefix will not be used.
-             * However, localized folders within `src/pages/` are still required, including for your configured `defaultLocale`.
-             *
-             * Any other locale not configured will default to a localized path-based URL according to your `prefixDefaultLocale` strategy (e.g. `https://example.com/[locale]/blog`).
-             *
-             * ```js
-             * //astro.config.mjs
-             * export default defineConfig({
-             * 	 site: "https://example.com",
-             * 	 output: "server", // required, with no prerendered pages
-             *   adapter: node({
-             *     mode: 'standalone',
-             *   }),
-             * 	 i18n: {
-             *     defaultLocale: "en",
-             *     locales: ["en", "fr", "pt-br", "es"],
-             *     prefixDefaultLocale: false,
-             *     domains: {
-             *       fr: "https://fr.example.com",
-             *       es: "https://example.es"
-             *     }
-             *   },
-             * })
-             * ```
-             *
-             * Both page routes built and URLs returned by the `astro:i18n` helper functions [`getAbsoluteLocaleUrl()`](https://docs.astro.build/en/guides/internationalization/#getabsolutelocaleurl) and [`getAbsoluteLocaleUrlList()`](https://docs.astro.build/en/guides/internationalization/#getabsolutelocaleurllist) will use the options set in `i18n.domains`.
-             *
-             * See the [Internationalization Guide](https://docs.astro.build/en/guides/internationalization/#domains) for more details, including the limitations of this feature.
-             */
-            domains?: Record<string, string>;
+            strategy?: 'pathname';
         };
+        /**
+         * @name i18n.domains
+         * @type {Record<string, string> }
+         * @default '{}'
+         * @version 4.3.0
+         * @description
+         *
+         * Configures the URL pattern of one or more supported languages to use a custom domain (or sub-domain).
+         *
+         * When a locale is mapped to a domain, a `/[locale]/` path prefix will not be used.
+         * However, localized folders within `src/pages/` are still required, including for your configured `defaultLocale`.
+         *
+         * Any other locale not configured will default to a localized path-based URL according to your `prefixDefaultLocale` strategy (e.g. `https://example.com/[locale]/blog`).
+         *
+         * ```js
+         * //astro.config.mjs
+         * export default defineConfig({
+         * 	 site: "https://example.com",
+         * 	 output: "server", // required, with no prerendered pages
+         *   adapter: node({
+         *     mode: 'standalone',
+         *   }),
+         * 	 i18n: {
+         *     defaultLocale: "en",
+         *     locales: ["en", "fr", "pt-br", "es"],
+         *     prefixDefaultLocale: false,
+         *     domains: {
+         *       fr: "https://fr.example.com",
+         *       es: "https://example.es"
+         *     }
+         *   },
+         * })
+         * ```
+         *
+         * Both page routes built and URLs returned by the `astro:i18n` helper functions [`getAbsoluteLocaleUrl()`](https://docs.astro.build/en/guides/internationalization/#getabsolutelocaleurl) and [`getAbsoluteLocaleUrlList()`](https://docs.astro.build/en/guides/internationalization/#getabsolutelocaleurllist) will use the options set in `i18n.domains`.
+         *
+         * See the [Internationalization Guide](https://docs.astro.build/en/guides/internationalization/#domains) for more details, including the limitations of this feature.
+         */
+        domains?: Record<string, string>;
     };
     /** ⚠️ WARNING: SUBJECT TO CHANGE */
     db?: Config.Database;

package/dist/assets/build/generate.d.ts

@@ -1,6 +1,6 @@
 import type PQueue from 'p-queue';
 import type { AstroConfig } from '../../@types/astro.js';
-import type { BuildPipeline } from '../../core/build/buildPipeline.js';
+import type { BuildPipeline } from '../../core/build/pipeline.js';
 import type { Logger } from '../../core/logger/core.js';
 import type { MapValue } from '../../type-utils.js';
 import type { AssetsGlobalStaticImagesList } from '../types.js';

package/dist/assets/build/generate.js

@@ -11,8 +11,7 @@ import { getConfiguredImageService } from "../internal.js";
 import { isESMImportedImage } from "../utils/imageKind.js";
 import { loadRemoteImage } from "./remote.js";
 async function prepareAssetsGenerationEnv(pipeline, totalCount) {
-  const config = pipeline.getConfig();
-  const logger = pipeline.getLogger();
+  const { config, logger } = pipeline;
   let useCache = true;
   const assetsCacheDir = new URL("assets/", config.cacheDir);
   const count = { total: totalCount, current: 1 };

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
+};