blank project

node_modules/astro/dist/assets/utils/etag.d.ts

@@ -0,0 +1 @@
+export declare const etag: (payload: string, weak?: boolean) => string;

node_modules/astro/dist/assets/utils/etag.js

@@ -0,0 +1,27 @@
+const fnv1a52 = (str) => {
+  const len = str.length;
+  let i = 0, t0 = 0, v0 = 8997, t1 = 0, v1 = 33826, t2 = 0, v2 = 40164, t3 = 0, v3 = 52210;
+  while (i < len) {
+    v0 ^= str.charCodeAt(i++);
+    t0 = v0 * 435;
+    t1 = v1 * 435;
+    t2 = v2 * 435;
+    t3 = v3 * 435;
+    t2 += v0 << 8;
+    t3 += v1 << 8;
+    t1 += t0 >>> 16;
+    v0 = t0 & 65535;
+    t2 += t1 >>> 16;
+    v1 = t1 & 65535;
+    v3 = t3 + (t2 >>> 16) & 65535;
+    v2 = t2 & 65535;
+  }
+  return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+};
+const etag = (payload, weak = false) => {
+  const prefix = weak ? 'W/"' : '"';
+  return prefix + fnv1a52(payload).toString(36) + payload.length.toString(36) + '"';
+};
+export {
+  etag
+};

node_modules/astro/dist/assets/utils/getAssetsPrefix.d.ts

@@ -0,0 +1,2 @@
+import type { AssetsPrefix } from '../../core/app/types.js';
+export declare function getAssetsPrefix(fileExtension: string, assetsPrefix?: AssetsPrefix): string;

node_modules/astro/dist/assets/utils/getAssetsPrefix.js

@@ -0,0 +1,12 @@
+function getAssetsPrefix(fileExtension, assetsPrefix) {
+  if (!assetsPrefix) return "";
+  if (typeof assetsPrefix === "string") return assetsPrefix;
+  const dotLessFileExtension = fileExtension.slice(1);
+  if (assetsPrefix[dotLessFileExtension]) {
+    return assetsPrefix[dotLessFileExtension];
+  }
+  return assetsPrefix.fallback;
+}
+export {
+  getAssetsPrefix
+};

node_modules/astro/dist/assets/utils/imageAttributes.d.ts

@@ -0,0 +1,2 @@
+export declare const cssFitValues: string[];
+export declare function addCSSVarsToStyle(vars: Record<string, string | false | undefined>, styles?: string | Record<string, any>): string;

node_modules/astro/dist/assets/utils/imageAttributes.js

@@ -0,0 +1,14 @@
+import { toStyleString } from "../../runtime/server/render/util.js";
+const cssFitValues = ["fill", "contain", "cover", "scale-down"];
+function addCSSVarsToStyle(vars, styles) {
+  const cssVars = Object.entries(vars).filter(([_, value]) => value !== void 0 && value !== false).map(([key, value]) => `--${key}: ${value};`).join(" ");
+  if (!styles) {
+    return cssVars;
+  }
+  const style = typeof styles === "string" ? styles : toStyleString(styles);
+  return `${cssVars} ${style}`;
+}
+export {
+  addCSSVarsToStyle,
+  cssFitValues
+};

node_modules/astro/dist/assets/utils/imageKind.d.ts

@@ -0,0 +1,22 @@
+import type { ImageMetadata, UnresolvedImageTransform } from '../types.js';
+/**
+ * Determines if the given source is an ECMAScript Module (ESM) imported image.
+ *
+ * @param {ImageMetadata | string} src - The source to check. It can be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is an `ImageMetadata` object, otherwise `false`.
+ */
+export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
+/**
+ * Determines if the provided source is a remote image URL in the form of a string.
+ *
+ * @param {ImageMetadata | string} src - The source to check, which can either be an `ImageMetadata` object or a string.
+ * @return {boolean} Returns `true` if the source is a string, otherwise `false`.
+ */
+export declare function isRemoteImage(src: ImageMetadata | string): src is string;
+/**
+ * Resolves the source of an image transformation by handling asynchronous or synchronous inputs.
+ *
+ * @param {UnresolvedImageTransform['src']} src - The source of the image transformation.
+ * @return {Promise<string | ImageMetadata>} A promise that resolves to the image source. It returns either the default export of the resolved source or the resolved source itself if the default export doesn't exist.
+ */
+export declare function resolveSrc(src: UnresolvedImageTransform['src']): Promise<string | ImageMetadata>;

node_modules/astro/dist/assets/utils/imageKind.js

@@ -0,0 +1,18 @@
+function isESMImportedImage(src) {
+  return typeof src === "object" || typeof src === "function" && "src" in src;
+}
+function isRemoteImage(src) {
+  return typeof src === "string";
+}
+async function resolveSrc(src) {
+  if (typeof src === "object" && "then" in src) {
+    const resource = await src;
+    return resource.default ?? resource;
+  }
+  return src;
+}
+export {
+  isESMImportedImage,
+  isRemoteImage,
+  resolveSrc
+};

node_modules/astro/dist/assets/utils/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * NOTE: this is a public module exposed to the user, so all functions exposed
+ * here must be documented via JsDoc and in the docs website.
+ *
+ * If some functions don't need to be exposed, just import the file that contains the functions.
+ */
+export { isESMImportedImage, isRemoteImage, resolveSrc } from './imageKind.js';
+export { imageMetadata } from './metadata.js';
+export { 
+/**
+ * @deprecated
+ */
+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';

node_modules/astro/dist/assets/utils/index.js

@@ -0,0 +1,35 @@
+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,
+  matchPathname,
+  matchPattern,
+  matchPort,
+  matchProtocol
+} from "./remotePattern.js";
+import { inferRemoteSize } from "./remoteProbe.js";
+import { hashTransform, propsToFilename } from "./transformToPath.js";
+export {
+  emitESMImage,
+  emitImageMetadata,
+  getOrigQueryParams,
+  hashTransform,
+  imageMetadata,
+  inferRemoteSize,
+  isESMImportedImage,
+  isRemoteAllowed,
+  isRemoteImage,
+  matchHostname,
+  matchPathname,
+  matchPattern,
+  matchPort,
+  matchProtocol,
+  propsToFilename,
+  resolveSrc
+};

node_modules/astro/dist/assets/utils/metadata.d.ts

@@ -0,0 +1,10 @@
+import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts image metadata such as dimensions, format, and orientation from the provided image data.
+ *
+ * @param {Uint8Array} data - The binary data of the image.
+ * @param {string} [src] - The source path or URL of the image, used for error messages. Optional.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} A promise that resolves with the extracted metadata, excluding `src` and `fsPath`.
+ * @throws {AstroError} Throws an error if the image metadata cannot be extracted.
+ */
+export declare function imageMetadata(data: Uint8Array, src?: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

node_modules/astro/dist/assets/utils/metadata.js

@@ -0,0 +1,30 @@
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { lookup as probe } from "../utils/vendor/image-size/lookup.js";
+async function imageMetadata(data, src) {
+  let result;
+  try {
+    result = probe(data);
+  } catch {
+    throw new AstroError({
+      ...AstroErrorData.NoImageMetadata,
+      message: AstroErrorData.NoImageMetadata.message(src)
+    });
+  }
+  if (!result.height || !result.width || !result.type) {
+    throw new AstroError({
+      ...AstroErrorData.NoImageMetadata,
+      message: AstroErrorData.NoImageMetadata.message(src)
+    });
+  }
+  const { width, height, type, orientation } = result;
+  const isPortrait = (orientation || 0) >= 5;
+  return {
+    width: isPortrait ? height : width,
+    height: isPortrait ? width : height,
+    format: type,
+    orientation
+  };
+}
+export {
+  imageMetadata
+};

node_modules/astro/dist/assets/utils/node/emitAsset.d.ts

@@ -0,0 +1,29 @@
+import type * as vite from 'vite';
+import type { ImageMetadata } from '../../types.js';
+type FileEmitter = vite.Rollup.EmitFile;
+type ImageMetadataWithContents = ImageMetadata & {
+    contents?: Buffer;
+};
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @param {boolean} _watchMode - **Deprecated**: Indicates if the method is operating in watch mode. This parameter will be removed or updated in the future.
+ * @param {boolean} _experimentalSvgEnabled - **Deprecated**: A flag to enable experimental handling of SVG files. Embeds SVG file data if set to true.
+ * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
+ * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
+ */
+export declare function emitESMImage(id: string | undefined, 
+/** @deprecated */
+_watchMode: boolean, 
+/** @deprecated */
+_experimentalSvgEnabled: boolean, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
+/**
+ * Processes an image file and emits its metadata and optionally its contents. This function supports both build and development modes.
+ *
+ * @param {string | undefined} id - The identifier or path of the image file to process. If undefined, the function returns immediately.
+ * @param {FileEmitter | undefined} [fileEmitter] - Function for emitting files during the build process. May throw in certain scenarios.
+ * @return {Promise<ImageMetadataWithContents | undefined>} Resolves to metadata with optional image contents or `undefined` if processing fails.
+ */
+export declare function emitImageMetadata(id: string | undefined, fileEmitter?: FileEmitter): Promise<ImageMetadataWithContents | undefined>;
+export {};

node_modules/astro/dist/assets/utils/node/emitAsset.js

@@ -0,0 +1,142 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { generateContentHash } from "../../../core/encryption.js";
+import { prependForwardSlash, slash } from "../../../core/path.js";
+import { imageMetadata } from "../metadata.js";
+const svgContentCache = /* @__PURE__ */ new WeakMap();
+const keyRegistry = /* @__PURE__ */ new Map();
+function keyFor(hash) {
+  let key = keyRegistry.get(hash);
+  if (!key) {
+    key = { hash };
+    keyRegistry.set(hash, key);
+  }
+  return key;
+}
+async function handleSvgDeduplication(fileData, filename, fileEmitter) {
+  const contentHash = await generateContentHash(fileData.buffer);
+  const key = keyFor(contentHash);
+  const existing = svgContentCache.get(key);
+  if (existing) {
+    const handle = fileEmitter({
+      name: existing.filename,
+      source: fileData,
+      type: "asset"
+    });
+    return handle;
+  } else {
+    const handle = fileEmitter({
+      name: filename,
+      source: fileData,
+      type: "asset"
+    });
+    svgContentCache.set(key, { handle, filename });
+    return handle;
+  }
+}
+async function emitESMImage(id, _watchMode, _experimentalSvgEnabled, fileEmitter) {
+  if (!id) {
+    return void 0;
+  }
+  const url = pathToFileURL(id);
+  let fileData;
+  try {
+    fileData = await fs.readFile(url);
+  } catch {
+    return void 0;
+  }
+  const fileMetadata = await imageMetadata(fileData, id);
+  const emittedImage = {
+    src: "",
+    ...fileMetadata
+  };
+  Object.defineProperty(emittedImage, "fsPath", {
+    enumerable: false,
+    writable: false,
+    value: id
+  });
+  let isBuild = typeof fileEmitter === "function";
+  if (isBuild) {
+    const pathname = decodeURI(url.pathname);
+    const filename = path.basename(pathname, path.extname(pathname) + `.${fileMetadata.format}`);
+    try {
+      let handle;
+      if (fileMetadata.format === "svg") {
+        handle = await handleSvgDeduplication(fileData, filename, fileEmitter);
+      } else {
+        handle = fileEmitter({
+          name: filename,
+          source: fileData,
+          type: "asset"
+        });
+      }
+      emittedImage.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
+    } catch {
+      isBuild = false;
+    }
+  }
+  if (!isBuild) {
+    url.searchParams.append("origWidth", fileMetadata.width.toString());
+    url.searchParams.append("origHeight", fileMetadata.height.toString());
+    url.searchParams.append("origFormat", fileMetadata.format);
+    emittedImage.src = `/@fs` + prependForwardSlash(fileURLToNormalizedPath(url));
+  }
+  return emittedImage;
+}
+async function emitImageMetadata(id, fileEmitter) {
+  if (!id) {
+    return void 0;
+  }
+  const url = pathToFileURL(id);
+  let fileData;
+  try {
+    fileData = await fs.readFile(url);
+  } catch {
+    return void 0;
+  }
+  const fileMetadata = await imageMetadata(fileData, id);
+  const emittedImage = {
+    src: "",
+    ...fileMetadata
+  };
+  Object.defineProperty(emittedImage, "fsPath", {
+    enumerable: false,
+    writable: false,
+    value: id
+  });
+  let isBuild = typeof fileEmitter === "function";
+  if (isBuild) {
+    const pathname = decodeURI(url.pathname);
+    const filename = path.basename(pathname, path.extname(pathname) + `.${fileMetadata.format}`);
+    try {
+      let handle;
+      if (fileMetadata.format === "svg") {
+        handle = await handleSvgDeduplication(fileData, filename, fileEmitter);
+      } else {
+        handle = fileEmitter({
+          name: filename,
+          source: fileData,
+          type: "asset"
+        });
+      }
+      emittedImage.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
+    } catch {
+      isBuild = false;
+    }
+  }
+  if (!isBuild) {
+    url.searchParams.append("origWidth", fileMetadata.width.toString());
+    url.searchParams.append("origHeight", fileMetadata.height.toString());
+    url.searchParams.append("origFormat", fileMetadata.format);
+    emittedImage.src = `/@fs` + prependForwardSlash(fileURLToNormalizedPath(url));
+  }
+  return emittedImage;
+}
+function fileURLToNormalizedPath(filePath) {
+  return slash(fileURLToPath(filePath) + filePath.search).replace(/\\/g, "/");
+}
+export {
+  emitESMImage,
+  emitImageMetadata
+};

node_modules/astro/dist/assets/utils/proxy.d.ts

@@ -0,0 +1,2 @@
+import type { ImageMetadata } from '../types.js';
+export declare function getProxyCode(options: ImageMetadata, isSSR: boolean): string;

node_modules/astro/dist/assets/utils/proxy.js

@@ -0,0 +1,20 @@
+function getProxyCode(options, isSSR) {
+  const stringifiedFSPath = JSON.stringify(options.fsPath);
+  return `
+						new Proxy(${JSON.stringify(options)}, {
+						get(target, name, receiver) {
+							if (name === 'clone') {
+								return structuredClone(target);
+							}
+							if (name === 'fsPath') {
+								return ${stringifiedFSPath};
+							}
+							${!isSSR ? `if (target[name] !== undefined && globalThis.astroAsset) globalThis.astroAsset?.referencedImages.add(${stringifiedFSPath});` : ""}
+							return target[name];
+						}
+					})
+					`;
+}
+export {
+  getProxyCode
+};

node_modules/astro/dist/assets/utils/queryParams.d.ts

@@ -0,0 +1,11 @@
+import type { ImageMetadata } from '../types.js';
+/**
+ * Extracts the original image query parameters (width, height, format) from the given `URLSearchParams` object
+ * and returns them as an object. If any of the required parameters are missing or invalid, the function returns undefined.
+ *
+ * The `width` and `height` are parsed to integer values.
+ *
+ * @param {URLSearchParams} params - The `URLSearchParams` object containing the query parameters.
+ * @return {Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined} An object with the original image parameters (width, height, format) or undefined if any parameter is missing.
+ */
+export declare function getOrigQueryParams(params: URLSearchParams): Pick<ImageMetadata, 'width' | 'height' | 'format'> | undefined;

node_modules/astro/dist/assets/utils/queryParams.js

@@ -0,0 +1,16 @@
+function getOrigQueryParams(params) {
+  const width = params.get("origWidth");
+  const height = params.get("origHeight");
+  const format = params.get("origFormat");
+  if (!width || !height || !format) {
+    return void 0;
+  }
+  return {
+    width: parseInt(width),
+    height: parseInt(height),
+    format
+  };
+}
+export {
+  getOrigQueryParams
+};

node_modules/astro/dist/assets/utils/remotePattern.d.ts

@@ -0,0 +1,3 @@
+import { isRemoteAllowed, matchHostname, matchPathname, matchPattern, matchPort, matchProtocol, type RemotePattern } from '@astrojs/internal-helpers/remote';
+export { isRemoteAllowed, matchHostname, matchPort, matchPathname, matchProtocol, matchPattern };
+export type { RemotePattern };

node_modules/astro/dist/assets/utils/remotePattern.js

@@ -0,0 +1,16 @@
+import {
+  isRemoteAllowed,
+  matchHostname,
+  matchPathname,
+  matchPattern,
+  matchPort,
+  matchProtocol
+} from "@astrojs/internal-helpers/remote";
+export {
+  isRemoteAllowed,
+  matchHostname,
+  matchPathname,
+  matchPattern,
+  matchPort,
+  matchProtocol
+};

node_modules/astro/dist/assets/utils/remoteProbe.d.ts

@@ -0,0 +1,9 @@
+import type { ImageMetadata } from '../types.js';
+/**
+ * Infers the dimensions of a remote image by streaming its data and analyzing it progressively until sufficient metadata is available.
+ *
+ * @param {string} url - The URL of the remote image from which to infer size metadata.
+ * @return {Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>} Returns a promise that resolves to an object containing the image dimensions metadata excluding `src` and `fsPath`.
+ * @throws {AstroError} Thrown when the fetching fails or metadata cannot be extracted.
+ */
+export declare function inferRemoteSize(url: string): Promise<Omit<ImageMetadata, 'src' | 'fsPath'>>;

node_modules/astro/dist/assets/utils/remoteProbe.js

@@ -0,0 +1,41 @@
+import { AstroError, AstroErrorData } from "../../core/errors/index.js";
+import { imageMetadata } from "./metadata.js";
+async function inferRemoteSize(url) {
+  const response = await fetch(url);
+  if (!response.body || !response.ok) {
+    throw new AstroError({
+      ...AstroErrorData.FailedToFetchRemoteImageDimensions,
+      message: AstroErrorData.FailedToFetchRemoteImageDimensions.message(url)
+    });
+  }
+  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 = await imageMetadata(accumulatedChunks, url);
+        if (dimensions) {
+          await reader.cancel();
+          return dimensions;
+        }
+      } catch {
+      }
+    }
+  }
+  throw new AstroError({
+    ...AstroErrorData.NoImageMetadata,
+    message: AstroErrorData.NoImageMetadata.message(url)
+  });
+}
+export {
+  inferRemoteSize
+};

node_modules/astro/dist/assets/utils/resolveImports.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Resolves an image src from a content file (such as markdown) to a module ID or import that can be resolved by Vite.
+ *
+ * @param imageSrc The src attribute of an image tag
+ * @param filePath The path to the file that contains the imagem relative to the site root
+ * @returns A module id of the image that can be rsolved by Vite, or undefined if it is not a local image
+ */
+export declare function imageSrcToImportId(imageSrc: string, filePath?: string): string | undefined;
+export declare const importIdToSymbolName: (importId: string) => string;

node_modules/astro/dist/assets/utils/resolveImports.js

@@ -0,0 +1,24 @@
+import { isRemotePath, removeBase } from "@astrojs/internal-helpers/path";
+import { CONTENT_IMAGE_FLAG, IMAGE_IMPORT_PREFIX } from "../../content/consts.js";
+import { shorthash } from "../../runtime/server/shorthash.js";
+import { VALID_INPUT_FORMATS } from "../consts.js";
+function imageSrcToImportId(imageSrc, filePath) {
+  imageSrc = removeBase(imageSrc, IMAGE_IMPORT_PREFIX);
+  if (isRemotePath(imageSrc)) {
+    return;
+  }
+  const ext = imageSrc.split(".").at(-1)?.toLowerCase();
+  if (!ext || !VALID_INPUT_FORMATS.includes(ext)) {
+    return;
+  }
+  const params = new URLSearchParams(CONTENT_IMAGE_FLAG);
+  if (filePath) {
+    params.set("importer", filePath);
+  }
+  return `${imageSrc}?${params.toString()}`;
+}
+const importIdToSymbolName = (importId) => `__ASTRO_IMAGE_IMPORT_${shorthash(importId)}`;
+export {
+  imageSrcToImportId,
+  importIdToSymbolName
+};

node_modules/astro/dist/assets/utils/svg.d.ts

@@ -0,0 +1,2 @@
+import type { ImageMetadata } from '../types.js';
+export declare function makeSvgComponent(meta: ImageMetadata, contents: Buffer | string): string;

node_modules/astro/dist/assets/utils/svg.js

@@ -0,0 +1,28 @@
+import { parse, renderSync } from "ultrahtml";
+import { dropAttributes } from "../runtime.js";
+function parseSvg(contents) {
+  const root = parse(contents);
+  const svgNode = root.children.find(
+    ({ name, type }) => type === 1 && name === "svg"
+  );
+  if (!svgNode) {
+    throw new Error("SVG file does not contain an <svg> element");
+  }
+  const { attributes, children } = svgNode;
+  const body = renderSync({ ...root, children });
+  return { attributes, body };
+}
+function makeSvgComponent(meta, contents) {
+  const file = typeof contents === "string" ? contents : contents.toString("utf-8");
+  const { attributes, body: children } = parseSvg(file);
+  const props = {
+    meta,
+    attributes: dropAttributes(attributes),
+    children
+  };
+  return `import { createSvgComponent } from 'astro/assets/runtime';
+export default createSvgComponent(${JSON.stringify(props)})`;
+}
+export {
+  makeSvgComponent
+};

node_modules/astro/dist/assets/utils/transformToPath.d.ts

@@ -0,0 +1,33 @@
+import type { ImageTransform } from '../types.js';
+/**
+ * Converts a file path and transformation properties of the transformation image service, into a formatted filename.
+ *
+ * The formatted filename follows this structure:
+ *
+ * `<prefixDirname>/<baseFilename>_<hash><outputExtension>`
+ *
+ * - `prefixDirname`: If the image is an ESM imported image, this is the directory name of the original file path; otherwise, it will be an empty string.
+ * - `baseFilename`: The base name of the file or a hashed short name if the file is a `data:` URI.
+ * - `hash`: A unique hash string generated to distinguish the transformed file.
+ * - `outputExtension`: The desired output file extension derived from the `transform.format` or the original file extension.
+ *
+ * ## Example
+ * - Input: `filePath = '/images/photo.jpg'`, `transform = { format: 'png', src: '/images/photo.jpg' }`, `hash = 'abcd1234'`.
+ * - Output: `/images/photo_abcd1234.png`
+ *
+ * @param {string} filePath - The original file path or data URI of the source image.
+ * @param {ImageTransform} transform - An object representing the transformation properties, including format and source.
+ * @param {string} hash - A unique hash used to differentiate the transformed file.
+ * @return {string} The generated filename based on the provided input, transformations, and hash.
+ */
+export declare function propsToFilename(filePath: string, transform: ImageTransform, hash: string): string;
+/**
+ * Transforms the provided `transform` object into a hash string based on selected properties
+ * and the specified `imageService`.
+ *
+ * @param {ImageTransform} transform - The transform object containing various image transformation properties.
+ * @param {string} imageService - The name of the image service related to the transform.
+ * @param {string[]} propertiesToHash - An array of property names from the `transform` object that should be used to generate the hash.
+ * @return {string} A hashed string created from the specified properties of the `transform` object and the image service.
+ */
+export declare function hashTransform(transform: ImageTransform, imageService: string, propertiesToHash: string[]): string;

node_modules/astro/dist/assets/utils/transformToPath.js

@@ -0,0 +1,32 @@
+import { basename, dirname, extname } from "node:path";
+import { deterministicString } from "deterministic-object-hash";
+import { removeQueryString } from "../../core/path.js";
+import { shorthash } from "../../runtime/server/shorthash.js";
+import { isESMImportedImage } from "./imageKind.js";
+const INVALID_CHAR_REGEX = /[\u0000-\u001F"#$%&*+,:;<=>?[\]^`{|}\u007F]/g;
+function propsToFilename(filePath, transform, hash) {
+  let filename = decodeURIComponent(removeQueryString(filePath));
+  const ext = extname(filename);
+  if (filePath.startsWith("data:")) {
+    filename = shorthash(filePath);
+  } else {
+    filename = basename(filename, ext).replace(INVALID_CHAR_REGEX, "_");
+  }
+  const prefixDirname = isESMImportedImage(transform.src) ? dirname(filePath) : "";
+  let outputExt = transform.format ? `.${transform.format}` : ext;
+  return `${prefixDirname}/${filename}_${hash}${outputExt}`;
+}
+function hashTransform(transform, imageService, propertiesToHash) {
+  const hashFields = propertiesToHash.reduce(
+    (acc, prop) => {
+      acc[prop] = transform[prop];
+      return acc;
+    },
+    { imageService }
+  );
+  return shorthash(deterministicString(hashFields));
+}
+export {
+  hashTransform,
+  propsToFilename
+};

node_modules/astro/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;

node_modules/astro/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
+};

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

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

node_modules/astro/dist/assets/utils/vendor/image-size/lookup.js

@@ -0,0 +1,16 @@
+import { typeHandlers } from "./types/index.js";
+import { detector } from "./detector.js";
+function lookup(input) {
+  const type = detector(input);
+  if (typeof type !== "undefined") {
+    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);
+}
+export {
+  lookup
+};

node_modules/astro/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;

node_modules/astro/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
+};

node_modules/astro/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;

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

@@ -0,0 +1,16 @@
+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
+};

node_modules/astro/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;

node_modules/astro/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
+};

node_modules/astro/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;

node_modules/astro/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
+};

node_modules/astro/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;

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

@@ -0,0 +1,55 @@
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
+const brandMap = {
+  avif: "avif",
+  avis: "avif",
+  // avif-sequence
+  mif1: "heif",
+  msf1: "heif",
+  // heif-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 || "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 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
+};

node_modules/astro/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;

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

@@ -0,0 +1,84 @@
+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
+};

node_modules/astro/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;

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

@@ -0,0 +1,41 @@
+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
+};

node_modules/astro/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];

node_modules/astro/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
+};

node_modules/astro/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;
+};

node_modules/astro/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;

node_modules/astro/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
+};

node_modules/astro/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;

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

@@ -0,0 +1,23 @@
+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
+};

node_modules/astro/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;

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

@@ -0,0 +1,97 @@
+import { readUInt, readUInt16BE, toHexString } from "./utils.js";
+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";
+const IDF_ENTRY_BYTES = 12;
+const NUM_DIRECTORY_ENTRIES_BYTES = 2;
+function isEXIF(input) {
+  return toHexString(input, 2, 6) === EXIF_MARKER;
+}
+function extractSize(input, index) {
+  return {
+    height: readUInt16BE(input, index),
+    width: readUInt16BE(input, index + 2)
+  };
+}
+function extractOrientation(exifBlock, isBigEndian) {
+  const idfOffset = 8;
+  const offset = EXIF_HEADER_BYTES + idfOffset;
+  const idfDirectoryEntries = 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;
+    if (start > exifBlock.length) {
+      return;
+    }
+    const block = exifBlock.slice(start, end);
+    const tagNumber = readUInt(block, 16, 0, isBigEndian);
+    if (tagNumber === 274) {
+      const dataFormat = readUInt(block, 16, 2, isBigEndian);
+      if (dataFormat !== 3) {
+        return;
+      }
+      const numberOfComponents = readUInt(block, 32, 4, isBigEndian);
+      if (numberOfComponents !== 1) {
+        return;
+      }
+      return readUInt(block, 16, 8, isBigEndian);
+    }
+  }
+}
+function validateExifBlock(input, index) {
+  const exifBlock = input.slice(APP1_DATA_SIZE_BYTES, index);
+  const byteAlign = toHexString(
+    exifBlock,
+    EXIF_HEADER_BYTES,
+    EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES
+  );
+  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) {
+  if (index > input.length) {
+    throw new TypeError("Corrupt JPG, exceeded buffer limits");
+  }
+}
+const JPG = {
+  validate: (input) => toHexString(input, 0, 2) === "ffd8",
+  calculate(input) {
+    input = input.slice(4);
+    let orientation;
+    let next;
+    while (input.length) {
+      const i = readUInt16BE(input, 0);
+      if (input[i] !== 255) {
+        input = input.slice(i);
+        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);
+        if (!orientation) {
+          return size;
+        }
+        return {
+          height: size.height,
+          orientation,
+          width: size.width
+        };
+      }
+      input = input.slice(i + 2);
+    }
+    throw new TypeError("Invalid JPG, no size found");
+  }
+};
+export {
+  JPG
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/ktx.d.ts

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

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

@@ -0,0 +1,19 @@
+import { toUTF8String, readUInt32LE } from "./utils.js";
+const KTX = {
+  validate: (input) => {
+    const signature = toUTF8String(input, 1, 7);
+    return ["KTX 11", "KTX 20"].includes(signature);
+  },
+  calculate: (input) => {
+    const type = input[5] === 49 ? "ktx" : "ktx2";
+    const offset = type === "ktx" ? 36 : 20;
+    return {
+      height: readUInt32LE(input, offset + 4),
+      width: readUInt32LE(input, offset),
+      type
+    };
+  }
+};
+export {
+  KTX
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/png.d.ts

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

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

@@ -0,0 +1,34 @@
+import { toUTF8String, readUInt32BE } from "./utils.js";
+const pngSignature = "PNG\r\n\n";
+const pngImageHeaderChunkName = "IHDR";
+const pngFriedChunkName = "CgBI";
+const PNG = {
+  validate(input) {
+    if (pngSignature === toUTF8String(input, 1, 8)) {
+      let chunkName = toUTF8String(input, 12, 16);
+      if (chunkName === pngFriedChunkName) {
+        chunkName = toUTF8String(input, 28, 32);
+      }
+      if (chunkName !== pngImageHeaderChunkName) {
+        throw new TypeError("Invalid PNG");
+      }
+      return true;
+    }
+    return false;
+  },
+  calculate(input) {
+    if (toUTF8String(input, 12, 16) === pngFriedChunkName) {
+      return {
+        height: readUInt32BE(input, 36),
+        width: readUInt32BE(input, 32)
+      };
+    }
+    return {
+      height: readUInt32BE(input, 20),
+      width: readUInt32BE(input, 16)
+    };
+  }
+};
+export {
+  PNG
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/pnm.d.ts

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

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

@@ -0,0 +1,69 @@
+import { toUTF8String } from "./utils.js";
+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");
+    }
+  }
+};
+const PNM = {
+  validate: (input) => toUTF8String(input, 0, 2) in PNMTypes,
+  calculate(input) {
+    const signature = toUTF8String(input, 0, 2);
+    const type = PNMTypes[signature];
+    const lines = toUTF8String(input, 3).split(/[\r\n]+/);
+    const handler = handlers[type] || handlers.default;
+    return handler(lines);
+  }
+};
+export {
+  PNM
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/psd.d.ts

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

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

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

node_modules/astro/dist/assets/utils/vendor/image-size/types/svg.d.ts

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

node_modules/astro/dist/assets/utils/vendor/image-size/types/svg.js

@@ -0,0 +1,92 @@
+import { toUTF8String } from "./utils.js";
+const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
+const extractorRegExps = {
+  height: /\sheight=(['"])([^%]+?)\1/,
+  root: svgReg,
+  viewbox: /\sviewBox=(['"])(.+?)\1/i,
+  width: /\swidth=(['"])([^%]+?)\1/
+};
+const INCH_CM = 2.54;
+const units = {
+  in: 96,
+  cm: 96 / INCH_CM,
+  em: 16,
+  ex: 8,
+  m: 96 / INCH_CM * 100,
+  mm: 96 / INCH_CM / 10,
+  pc: 96 / 72 / 12,
+  pt: 96 / 72,
+  px: 1
+};
+const unitsReg = new RegExp(
+  `^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join("|")})?$`
+);
+function parseLength(len) {
+  const m = unitsReg.exec(len);
+  if (!m) {
+    return void 0;
+  }
+  return Math.round(Number(m[1]) * (units[m[2]] || 1));
+}
+function parseViewbox(viewbox) {
+  const bounds = viewbox.split(" ");
+  return {
+    height: parseLength(bounds[3]),
+    width: parseLength(bounds[2])
+  };
+}
+function parseAttributes(root) {
+  const width = extractorRegExps.width.exec(root);
+  const height = extractorRegExps.height.exec(root);
+  const viewbox = extractorRegExps.viewbox.exec(root);
+  return {
+    height: height && parseLength(height[2]),
+    viewbox: viewbox && parseViewbox(viewbox[2]),
+    width: width && parseLength(width[2])
+  };
+}
+function calculateByDimensions(attrs) {
+  return {
+    height: attrs.height,
+    width: attrs.width
+  };
+}
+function calculateByViewbox(attrs, viewbox) {
+  const ratio = viewbox.width / viewbox.height;
+  if (attrs.width) {
+    return {
+      height: Math.floor(attrs.width / ratio),
+      width: attrs.width
+    };
+  }
+  if (attrs.height) {
+    return {
+      height: attrs.height,
+      width: Math.floor(attrs.height * ratio)
+    };
+  }
+  return {
+    height: viewbox.height,
+    width: viewbox.width
+  };
+}
+const SVG = {
+  // Scan only the first kilo-byte to speed up the check on larger files
+  validate: (input) => svgReg.test(toUTF8String(input, 0, 1e3)),
+  calculate(input) {
+    const root = extractorRegExps.root.exec(toUTF8String(input));
+    if (root) {
+      const attrs = parseAttributes(root[0]);
+      if (attrs.width && attrs.height) {
+        return calculateByDimensions(attrs);
+      }
+      if (attrs.viewbox) {
+        return calculateByViewbox(attrs, attrs.viewbox);
+      }
+    }
+    throw new TypeError("Invalid SVG");
+  }
+};
+export {
+  SVG
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/tga.d.ts

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

node_modules/astro/dist/assets/utils/vendor/image-size/types/tga.js

@@ -0,0 +1,15 @@
+import { readUInt16LE } from "./utils.js";
+const TGA = {
+  validate(input) {
+    return readUInt16LE(input, 0) === 0 && readUInt16LE(input, 4) === 0;
+  },
+  calculate(input) {
+    return {
+      height: readUInt16LE(input, 14),
+      width: readUInt16LE(input, 12)
+    };
+  }
+};
+export {
+  TGA
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/tiff.d.ts

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

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

@@ -0,0 +1,66 @@
+import { readUInt, toHexString, toUTF8String } from "./utils.js";
+function readIFD(input, isBigEndian) {
+  const ifdOffset = readUInt(input, 32, 4, isBigEndian);
+  return input.slice(ifdOffset + 2);
+}
+function readValue(input, isBigEndian) {
+  const low = readUInt(input, 16, 8, isBigEndian);
+  const high = readUInt(input, 16, 10, isBigEndian);
+  return (high << 16) + low;
+}
+function nextTag(input) {
+  if (input.length > 24) {
+    return input.slice(12);
+  }
+}
+function extractTags(input, isBigEndian) {
+  const tags = {};
+  let temp = input;
+  while (temp && 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);
+    }
+  }
+  return tags;
+}
+function determineEndianness(input) {
+  const signature = toUTF8String(input, 0, 2);
+  if ("II" === signature) {
+    return "LE";
+  } else if ("MM" === signature) {
+    return "BE";
+  }
+}
+const signatures = [
+  // '492049', // currently not supported
+  "49492a00",
+  // Little endian
+  "4d4d002a"
+  // Big Endian
+  // '4d4d002a', // BigTIFF > 4GB. currently not supported
+];
+const TIFF = {
+  validate: (input) => signatures.includes(toHexString(input, 0, 4)),
+  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) {
+      throw new TypeError("Invalid Tiff. Missing tags");
+    }
+    return { height, width };
+  }
+};
+export {
+  TIFF
+};

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

@@ -0,0 +1,15 @@
+export declare const toUTF8String: (input: Uint8Array, start?: number, end?: number) => string;
+export declare const toHexString: (input: Uint8Array, start?: number, end?: number) => string;
+export declare const readInt16LE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt16BE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt16LE: (input: Uint8Array, offset?: number) => number;
+export declare const readUInt24LE: (input: Uint8Array, offset?: number) => number;
+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): {
+    name: string;
+    offset: number;
+    size: number;
+} | undefined;

node_modules/astro/dist/assets/utils/vendor/image-size/types/utils.js

@@ -0,0 +1,56 @@
+const decoder = new TextDecoder();
+const toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
+const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + ("0" + i.toString(16)).slice(-2), "");
+const readInt16LE = (input, offset = 0) => {
+  const val = input[offset] + input[offset + 1] * 2 ** 8;
+  return val | (val & 2 ** 15) * 131070;
+};
+const readUInt16BE = (input, offset = 0) => input[offset] * 2 ** 8 + input[offset + 1];
+const readUInt16LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8;
+const readUInt24LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16;
+const readInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16 + (input[offset + 3] << 24);
+const readUInt32BE = (input, offset = 0) => input[offset] * 2 ** 24 + input[offset + 1] * 2 ** 16 + input[offset + 2] * 2 ** 8 + input[offset + 3];
+const readUInt32LE = (input, offset = 0) => input[offset] + input[offset + 1] * 2 ** 8 + input[offset + 2] * 2 ** 16 + input[offset + 3] * 2 ** 24;
+const methods = {
+  readUInt16BE,
+  readUInt16LE,
+  readUInt32BE,
+  readUInt32LE
+};
+function readUInt(input, bits, offset, isBigEndian) {
+  offset = offset || 0;
+  const endian = isBigEndian ? "BE" : "LE";
+  const methodName = "readUInt" + bits + endian;
+  return methods[methodName](input, offset);
+}
+function readBox(buffer, offset) {
+  if (buffer.length - offset < 4) return;
+  const boxSize = readUInt32BE(buffer, offset);
+  if (buffer.length - offset < boxSize) return;
+  return {
+    name: toUTF8String(buffer, 4 + offset, 8 + offset),
+    offset,
+    size: boxSize
+  };
+}
+function findBox(buffer, boxName, offset) {
+  while (offset < buffer.length) {
+    const box = readBox(buffer, offset);
+    if (!box) break;
+    if (box.name === boxName) return box;
+    offset += box.size;
+  }
+}
+export {
+  findBox,
+  readInt16LE,
+  readInt32LE,
+  readUInt,
+  readUInt16BE,
+  readUInt16LE,
+  readUInt24LE,
+  readUInt32BE,
+  readUInt32LE,
+  toHexString,
+  toUTF8String
+};

node_modules/astro/dist/assets/utils/vendor/image-size/types/webp.d.ts

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

node_modules/astro/dist/assets/utils/vendor/image-size/types/webp.js

@@ -0,0 +1,52 @@
+import { toHexString, toUTF8String, readInt16LE, readUInt24LE } from "./utils.js";
+function calculateExtended(input) {
+  return {
+    height: 1 + readUInt24LE(input, 7),
+    width: 1 + readUInt24LE(input, 4)
+  };
+}
+function calculateLossless(input) {
+  return {
+    height: 1 + ((input[4] & 15) << 10 | input[3] << 2 | (input[2] & 192) >> 6),
+    width: 1 + ((input[2] & 63) << 8 | input[1])
+  };
+}
+function calculateLossy(input) {
+  return {
+    height: readInt16LE(input, 8) & 16383,
+    width: readInt16LE(input, 6) & 16383
+  };
+}
+const WEBP = {
+  validate(input) {
+    const riffHeader = "RIFF" === toUTF8String(input, 0, 4);
+    const webpHeader = "WEBP" === toUTF8String(input, 8, 12);
+    const vp8Header = "VP8" === toUTF8String(input, 12, 15);
+    return riffHeader && webpHeader && vp8Header;
+  },
+  calculate(input) {
+    const chunkHeader = toUTF8String(input, 12, 16);
+    input = input.slice(20, 30);
+    if (chunkHeader === "VP8X") {
+      const extendedHeader = input[0];
+      const validStart = (extendedHeader & 192) === 0;
+      const validEnd = (extendedHeader & 1) === 0;
+      if (validStart && validEnd) {
+        return calculateExtended(input);
+      } else {
+        throw new TypeError("Invalid WebP");
+      }
+    }
+    if (chunkHeader === "VP8 " && input[0] !== 47) {
+      return calculateLossy(input);
+    }
+    const signature = toHexString(input, 3, 6);
+    if (chunkHeader === "VP8L" && signature !== "9d012a") {
+      return calculateLossless(input);
+    }
+    throw new TypeError("Invalid WebP");
+  }
+};
+export {
+  WEBP
+};