astro 2.0.18 → 2.1.0

package/dist/assets/services/vendor/squoosh/codecs.d.ts

@@ -0,0 +1,158 @@
+/// <reference types="node" />
+interface DecodeModule extends EmscriptenWasm.Module {
+    decode: (data: Uint8Array) => ImageData;
+}
+export interface ResizeOptions {
+    width?: number;
+    height?: number;
+    method: 'triangle' | 'catrom' | 'mitchell' | 'lanczos3';
+    premultiply: boolean;
+    linearRGB: boolean;
+}
+export interface RotateOptions {
+    numRotations: number;
+}
+import type { MozJPEGModule as MozJPEGEncodeModule } from './mozjpeg/mozjpeg_enc';
+import type { WebPModule as WebPEncodeModule } from './webp/webp_enc';
+import type { AVIFModule as AVIFEncodeModule } from './avif/avif_enc';
+import ImageData from './image_data.js';
+export declare const preprocessors: {
+    readonly resize: {
+        readonly name: "Resize";
+        readonly description: "Resize the image before compressing";
+        readonly instantiate: () => Promise<(buffer: Uint8Array, input_width: number, input_height: number, { width, height, method, premultiply, linearRGB }: ResizeOptions) => ImageData>;
+        readonly defaultOptions: {
+            readonly method: "lanczos3";
+            readonly fitMethod: "stretch";
+            readonly premultiply: true;
+            readonly linearRGB: true;
+        };
+    };
+    readonly rotate: {
+        readonly name: "Rotate";
+        readonly description: "Rotate image";
+        readonly instantiate: () => Promise<(buffer: Uint8Array, width: number, height: number, { numRotations }: RotateOptions) => Promise<ImageData>>;
+        readonly defaultOptions: {
+            readonly numRotations: 0;
+        };
+    };
+};
+export declare const codecs: {
+    readonly mozjpeg: {
+        readonly name: "MozJPEG";
+        readonly extension: "jpg";
+        readonly detectors: readonly [RegExp];
+        readonly dec: () => Promise<DecodeModule>;
+        readonly enc: () => Promise<MozJPEGEncodeModule>;
+        readonly defaultEncoderOptions: {
+            readonly quality: 75;
+            readonly baseline: false;
+            readonly arithmetic: false;
+            readonly progressive: true;
+            readonly optimize_coding: true;
+            readonly smoothing: 0;
+            readonly color_space: 3;
+            readonly quant_table: 3;
+            readonly trellis_multipass: false;
+            readonly trellis_opt_zero: false;
+            readonly trellis_opt_table: false;
+            readonly trellis_loops: 1;
+            readonly auto_subsample: true;
+            readonly chroma_subsample: 2;
+            readonly separate_chroma_quality: false;
+            readonly chroma_quality: 75;
+        };
+        readonly autoOptimize: {
+            readonly option: "quality";
+            readonly min: 0;
+            readonly max: 100;
+        };
+    };
+    readonly webp: {
+        readonly name: "WebP";
+        readonly extension: "webp";
+        readonly detectors: readonly [RegExp];
+        readonly dec: () => Promise<DecodeModule>;
+        readonly enc: () => Promise<WebPEncodeModule>;
+        readonly defaultEncoderOptions: {
+            readonly quality: 75;
+            readonly target_size: 0;
+            readonly target_PSNR: 0;
+            readonly method: 4;
+            readonly sns_strength: 50;
+            readonly filter_strength: 60;
+            readonly filter_sharpness: 0;
+            readonly filter_type: 1;
+            readonly partitions: 0;
+            readonly segments: 4;
+            readonly pass: 1;
+            readonly show_compressed: 0;
+            readonly preprocessing: 0;
+            readonly autofilter: 0;
+            readonly partition_limit: 0;
+            readonly alpha_compression: 1;
+            readonly alpha_filtering: 1;
+            readonly alpha_quality: 100;
+            readonly lossless: 0;
+            readonly exact: 0;
+            readonly image_hint: 0;
+            readonly emulate_jpeg_size: 0;
+            readonly thread_level: 0;
+            readonly low_memory: 0;
+            readonly near_lossless: 100;
+            readonly use_delta_palette: 0;
+            readonly use_sharp_yuv: 0;
+        };
+        readonly autoOptimize: {
+            readonly option: "quality";
+            readonly min: 0;
+            readonly max: 100;
+        };
+    };
+    readonly avif: {
+        readonly name: "AVIF";
+        readonly extension: "avif";
+        readonly detectors: readonly [RegExp];
+        readonly dec: () => Promise<DecodeModule>;
+        readonly enc: () => Promise<AVIFEncodeModule>;
+        readonly defaultEncoderOptions: {
+            readonly cqLevel: 33;
+            readonly cqAlphaLevel: -1;
+            readonly denoiseLevel: 0;
+            readonly tileColsLog2: 0;
+            readonly tileRowsLog2: 0;
+            readonly speed: 6;
+            readonly subsample: 1;
+            readonly chromaDeltaQ: false;
+            readonly sharpness: 0;
+            readonly tune: 0;
+        };
+        readonly autoOptimize: {
+            readonly option: "cqLevel";
+            readonly min: 62;
+            readonly max: 0;
+        };
+    };
+    readonly oxipng: {
+        readonly name: "OxiPNG";
+        readonly extension: "png";
+        readonly detectors: readonly [RegExp];
+        readonly dec: () => Promise<{
+            decode: (buffer: Buffer | Uint8Array) => any;
+        }>;
+        readonly enc: () => Promise<{
+            encode: (buffer: Uint8ClampedArray | ArrayBuffer, width: number, height: number, opts: {
+                level: number;
+            }) => any;
+        }>;
+        readonly defaultEncoderOptions: {
+            readonly level: 2;
+        };
+        readonly autoOptimize: {
+            readonly option: "level";
+            readonly min: 6;
+            readonly max: 1;
+        };
+    };
+};
+export {};

package/dist/assets/services/vendor/squoosh/codecs.js

@@ -0,0 +1,284 @@
+import { promises as fsp } from "node:fs";
+import { getModuleURL, instantiateEmscriptenWasm, pathify } from "./emscripten-utils.js";
+import mozEnc from "./mozjpeg/mozjpeg_node_enc.js";
+const mozEncWasm = new URL("./mozjpeg/mozjpeg_node_enc.wasm", getModuleURL(import.meta.url));
+import mozDec from "./mozjpeg/mozjpeg_node_dec.js";
+const mozDecWasm = new URL("./mozjpeg/mozjpeg_node_dec.wasm", getModuleURL(import.meta.url));
+import webpEnc from "./webp/webp_node_enc.js";
+const webpEncWasm = new URL("./webp/webp_node_enc.wasm", getModuleURL(import.meta.url));
+import webpDec from "./webp/webp_node_dec.js";
+const webpDecWasm = new URL("./webp/webp_node_dec.wasm", getModuleURL(import.meta.url));
+import avifEnc from "./avif/avif_node_enc.js";
+const avifEncWasm = new URL("./avif/avif_node_enc.wasm", getModuleURL(import.meta.url));
+import avifDec from "./avif/avif_node_dec.js";
+const avifDecWasm = new URL("./avif/avif_node_dec.wasm", getModuleURL(import.meta.url));
+import * as pngEncDec from "./png/squoosh_png.js";
+const pngEncDecWasm = new URL("./png/squoosh_png_bg.wasm", getModuleURL(import.meta.url));
+const pngEncDecInit = () => pngEncDec.default(fsp.readFile(pathify(pngEncDecWasm.toString())));
+import * as oxipng from "./png/squoosh_oxipng.js";
+const oxipngWasm = new URL("./png/squoosh_oxipng_bg.wasm", getModuleURL(import.meta.url));
+const oxipngInit = () => oxipng.default(fsp.readFile(pathify(oxipngWasm.toString())));
+import * as resize from "./resize/squoosh_resize.js";
+const resizeWasm = new URL("./resize/squoosh_resize_bg.wasm", getModuleURL(import.meta.url));
+const resizeInit = () => resize.default(fsp.readFile(pathify(resizeWasm.toString())));
+const rotateWasm = new URL("./rotate/rotate.wasm", getModuleURL(import.meta.url));
+import ImageData from "./image_data.js";
+global.ImageData = ImageData;
+function resizeNameToIndex(name) {
+  switch (name) {
+    case "triangle":
+      return 0;
+    case "catrom":
+      return 1;
+    case "mitchell":
+      return 2;
+    case "lanczos3":
+      return 3;
+    default:
+      throw Error(`Unknown resize algorithm "${name}"`);
+  }
+}
+function resizeWithAspect({
+  input_width,
+  input_height,
+  target_width,
+  target_height
+}) {
+  if (!target_width && !target_height) {
+    throw Error("Need to specify at least width or height when resizing");
+  }
+  if (target_width && target_height) {
+    return { width: target_width, height: target_height };
+  }
+  if (!target_width) {
+    return {
+      width: Math.round(input_width / input_height * target_height),
+      height: target_height
+    };
+  }
+  return {
+    width: target_width,
+    height: Math.round(input_height / input_width * target_width)
+  };
+}
+const preprocessors = {
+  resize: {
+    name: "Resize",
+    description: "Resize the image before compressing",
+    instantiate: async () => {
+      await resizeInit();
+      return (buffer, input_width, input_height, { width, height, method, premultiply, linearRGB }) => {
+        ;
+        ({ width, height } = resizeWithAspect({
+          input_width,
+          input_height,
+          target_width: width,
+          target_height: height
+        }));
+        const imageData = new ImageData(
+          resize.resize(
+            buffer,
+            input_width,
+            input_height,
+            width,
+            height,
+            resizeNameToIndex(method),
+            premultiply,
+            linearRGB
+          ),
+          width,
+          height
+        );
+        resize.cleanup();
+        return imageData;
+      };
+    },
+    defaultOptions: {
+      method: "lanczos3",
+      fitMethod: "stretch",
+      premultiply: true,
+      linearRGB: true
+    }
+  },
+  rotate: {
+    name: "Rotate",
+    description: "Rotate image",
+    instantiate: async () => {
+      return async (buffer, width, height, { numRotations }) => {
+        const degrees = numRotations * 90 % 360;
+        const sameDimensions = degrees === 0 || degrees === 180;
+        const size = width * height * 4;
+        const instance = (await WebAssembly.instantiate(await fsp.readFile(pathify(rotateWasm.toString())))).instance;
+        const { memory } = instance.exports;
+        const additionalPagesNeeded = Math.ceil(
+          (size * 2 - memory.buffer.byteLength + 8) / (64 * 1024)
+        );
+        if (additionalPagesNeeded > 0) {
+          memory.grow(additionalPagesNeeded);
+        }
+        const view = new Uint8ClampedArray(memory.buffer);
+        view.set(buffer, 8);
+        instance.exports.rotate(width, height, degrees);
+        return new ImageData(
+          view.slice(size + 8, size * 2 + 8),
+          sameDimensions ? width : height,
+          sameDimensions ? height : width
+        );
+      };
+    },
+    defaultOptions: {
+      numRotations: 0
+    }
+  }
+};
+const codecs = {
+  mozjpeg: {
+    name: "MozJPEG",
+    extension: "jpg",
+    detectors: [/^\xFF\xD8\xFF/],
+    dec: () => instantiateEmscriptenWasm(mozDec, mozDecWasm.toString()),
+    enc: () => instantiateEmscriptenWasm(
+      mozEnc,
+      mozEncWasm.toString()
+    ),
+    defaultEncoderOptions: {
+      quality: 75,
+      baseline: false,
+      arithmetic: false,
+      progressive: true,
+      optimize_coding: true,
+      smoothing: 0,
+      color_space: 3,
+      quant_table: 3,
+      trellis_multipass: false,
+      trellis_opt_zero: false,
+      trellis_opt_table: false,
+      trellis_loops: 1,
+      auto_subsample: true,
+      chroma_subsample: 2,
+      separate_chroma_quality: false,
+      chroma_quality: 75
+    },
+    autoOptimize: {
+      option: "quality",
+      min: 0,
+      max: 100
+    }
+  },
+  webp: {
+    name: "WebP",
+    extension: "webp",
+    detectors: [/^RIFF....WEBPVP8[LX ]/s],
+    dec: () => instantiateEmscriptenWasm(webpDec, webpDecWasm.toString()),
+    enc: () => instantiateEmscriptenWasm(
+      webpEnc,
+      webpEncWasm.toString()
+    ),
+    defaultEncoderOptions: {
+      quality: 75,
+      target_size: 0,
+      target_PSNR: 0,
+      method: 4,
+      sns_strength: 50,
+      filter_strength: 60,
+      filter_sharpness: 0,
+      filter_type: 1,
+      partitions: 0,
+      segments: 4,
+      pass: 1,
+      show_compressed: 0,
+      preprocessing: 0,
+      autofilter: 0,
+      partition_limit: 0,
+      alpha_compression: 1,
+      alpha_filtering: 1,
+      alpha_quality: 100,
+      lossless: 0,
+      exact: 0,
+      image_hint: 0,
+      emulate_jpeg_size: 0,
+      thread_level: 0,
+      low_memory: 0,
+      near_lossless: 100,
+      use_delta_palette: 0,
+      use_sharp_yuv: 0
+    },
+    autoOptimize: {
+      option: "quality",
+      min: 0,
+      max: 100
+    }
+  },
+  avif: {
+    name: "AVIF",
+    extension: "avif",
+    detectors: [/^\x00\x00\x00 ftypavif\x00\x00\x00\x00/],
+    dec: () => instantiateEmscriptenWasm(avifDec, avifDecWasm.toString()),
+    enc: async () => {
+      return instantiateEmscriptenWasm(
+        avifEnc,
+        avifEncWasm.toString()
+      );
+    },
+    defaultEncoderOptions: {
+      cqLevel: 33,
+      cqAlphaLevel: -1,
+      denoiseLevel: 0,
+      tileColsLog2: 0,
+      tileRowsLog2: 0,
+      speed: 6,
+      subsample: 1,
+      chromaDeltaQ: false,
+      sharpness: 0,
+      tune: 0
+    },
+    autoOptimize: {
+      option: "cqLevel",
+      min: 62,
+      max: 0
+    }
+  },
+  oxipng: {
+    name: "OxiPNG",
+    extension: "png",
+    detectors: [/^\x89PNG\x0D\x0A\x1A\x0A/],
+    dec: async () => {
+      await pngEncDecInit();
+      return {
+        decode: (buffer) => {
+          const imageData = pngEncDec.decode(buffer);
+          pngEncDec.cleanup();
+          return imageData;
+        }
+      };
+    },
+    enc: async () => {
+      await pngEncDecInit();
+      await oxipngInit();
+      return {
+        encode: (buffer, width, height, opts) => {
+          const simplePng = pngEncDec.encode(
+            new Uint8Array(buffer),
+            width,
+            height
+          );
+          const imageData = oxipng.optimise(simplePng, opts.level, false);
+          oxipng.cleanup();
+          return imageData;
+        }
+      };
+    },
+    defaultEncoderOptions: {
+      level: 2
+    },
+    autoOptimize: {
+      option: "level",
+      min: 6,
+      max: 1
+    }
+  }
+};
+export {
+  codecs,
+  preprocessors
+};

package/dist/assets/services/vendor/squoosh/copy-wasm.d.ts

@@ -0,0 +1 @@
+export declare function copyWasmFiles(dir: URL): Promise<void>;

package/dist/assets/services/vendor/squoosh/copy-wasm.js

@@ -0,0 +1,24 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+async function copyWasmFiles(dir) {
+  const src = new URL("./", import.meta.url);
+  await copyDir(fileURLToPath(src), fileURLToPath(dir));
+}
+async function copyDir(src, dest) {
+  const itemNames = await fs.readdir(src);
+  await Promise.all(itemNames.map(async (srcName) => {
+    const srcPath = path.join(src, srcName);
+    const destPath = path.join(dest, srcName);
+    const s = await fs.stat(srcPath);
+    if (s.isFile() && /.wasm$/.test(srcPath)) {
+      await fs.mkdir(path.dirname(destPath), { recursive: true });
+      await fs.copyFile(srcPath, destPath);
+    } else if (s.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    }
+  }));
+}
+export {
+  copyWasmFiles
+};

package/dist/assets/services/vendor/squoosh/emscripten-utils.d.ts

@@ -0,0 +1,9 @@
+export declare function pathify(path: string): string;
+export declare function instantiateEmscriptenWasm<T extends EmscriptenWasm.Module>(factory: EmscriptenWasm.ModuleFactory<T>, path: string, workerJS?: string): Promise<T>;
+export declare function dirname(url: string): string;
+/**
+ * On certain serverless hosts, our ESM bundle is transpiled to CJS before being run, which means
+ * import.meta.url is undefined, so we'll fall back to __dirname in those cases
+ * We should be able to remove this once https://github.com/netlify/zip-it-and-ship-it/issues/750 is fixed
+ */
+export declare function getModuleURL(url: string | undefined): string;

package/dist/assets/services/vendor/squoosh/emscripten-utils.js

@@ -0,0 +1,33 @@
+import { fileURLToPath, pathToFileURL } from "node:url";
+function pathify(path) {
+  if (path.startsWith("file://")) {
+    path = fileURLToPath(path);
+  }
+  return path;
+}
+function instantiateEmscriptenWasm(factory, path, workerJS = "") {
+  return factory({
+    locateFile(requestPath) {
+      if (requestPath.endsWith(".wasm"))
+        return pathify(path);
+      if (requestPath.endsWith(".worker.js"))
+        return pathify(workerJS);
+      return requestPath;
+    }
+  });
+}
+function dirname(url) {
+  return url.substring(0, url.lastIndexOf("/"));
+}
+function getModuleURL(url) {
+  if (!url) {
+    return pathToFileURL(__dirname).toString();
+  }
+  return url;
+}
+export {
+  dirname,
+  getModuleURL,
+  instantiateEmscriptenWasm,
+  pathify
+};

package/dist/assets/services/vendor/squoosh/image-pool.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import type { OutputFormat } from '../../../types.js';
+import type { Operation } from './image.js';
+export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: OutputFormat, quality?: number): Promise<Uint8Array>;

package/dist/assets/services/vendor/squoosh/image-pool.js

@@ -0,0 +1,94 @@
+import { isMainThread } from "node:worker_threads";
+import { cpus } from "os";
+import { fileURLToPath } from "url";
+import { getModuleURL } from "./emscripten-utils.js";
+import * as impl from "./impl.js";
+import execOnce from "./utils/execOnce.js";
+import WorkerPool from "./utils/workerPool.js";
+const getWorker = execOnce(() => {
+  return new WorkerPool(
+    Math.max(1, Math.min(cpus().length - 1, 7)),
+    fileURLToPath(getModuleURL(import.meta.url))
+  );
+});
+function handleJob(params) {
+  switch (params.operation) {
+    case "decode":
+      return impl.decodeBuffer(params.buffer);
+    case "resize":
+      return impl.resize({
+        image: params.imageData,
+        width: params.width,
+        height: params.height
+      });
+    case "rotate":
+      return impl.rotate(params.imageData, params.numRotations);
+    case "encodeavif":
+      return impl.encodeAvif(params.imageData, { quality: params.quality });
+    case "encodejpeg":
+      return impl.encodeJpeg(params.imageData, { quality: params.quality });
+    case "encodepng":
+      return impl.encodePng(params.imageData);
+    case "encodewebp":
+      return impl.encodeWebp(params.imageData, { quality: params.quality });
+    default:
+      throw Error(`Invalid job "${params.operation}"`);
+  }
+}
+async function processBuffer(buffer, operations, encoding, quality) {
+  const worker = await getWorker();
+  let imageData = await worker.dispatchJob({
+    operation: "decode",
+    buffer
+  });
+  for (const operation of operations) {
+    if (operation.type === "rotate") {
+      imageData = await worker.dispatchJob({
+        operation: "rotate",
+        imageData,
+        numRotations: operation.numRotations
+      });
+    } else if (operation.type === "resize") {
+      imageData = await worker.dispatchJob({
+        operation: "resize",
+        imageData,
+        height: operation.height,
+        width: operation.width
+      });
+    }
+  }
+  switch (encoding) {
+    case "avif":
+      return await worker.dispatchJob({
+        operation: "encodeavif",
+        imageData,
+        quality
+      });
+    case "jpeg":
+    case "jpg":
+      return await worker.dispatchJob({
+        operation: "encodejpeg",
+        imageData,
+        quality
+      });
+    case "png":
+      return await worker.dispatchJob({
+        operation: "encodepng",
+        imageData
+      });
+    case "webp":
+      return await worker.dispatchJob({
+        operation: "encodewebp",
+        imageData,
+        quality
+      });
+    default:
+      throw Error(`Unsupported encoding format`);
+  }
+}
+if (!isMainThread) {
+  WorkerPool.useThisThreadAsWorker(handleJob);
+}
+export {
+  processBuffer
+};

package/dist/assets/services/vendor/squoosh/image.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import type { OutputFormat } from '../../../types.js';
+type RotateOperation = {
+    type: 'rotate';
+    numRotations: number;
+};
+type ResizeOperation = {
+    type: 'resize';
+    width?: number;
+    height?: number;
+};
+export type Operation = RotateOperation | ResizeOperation;
+export declare function processBuffer(buffer: Buffer, operations: Operation[], encoding: OutputFormat, quality?: number): Promise<Uint8Array>;
+export {};

package/dist/assets/services/vendor/squoosh/image.js

@@ -0,0 +1,27 @@
+import * as impl from "./impl.js";
+async function processBuffer(buffer, operations, encoding, quality) {
+  let imageData = await impl.decodeBuffer(buffer);
+  for (const operation of operations) {
+    if (operation.type === "rotate") {
+      imageData = await impl.rotate(imageData, operation.numRotations);
+    } else if (operation.type === "resize") {
+      imageData = await impl.resize({ image: imageData, width: operation.width, height: operation.height });
+    }
+  }
+  switch (encoding) {
+    case "avif":
+      return await impl.encodeAvif(imageData, { quality });
+    case "jpeg":
+    case "jpg":
+      return await impl.encodeJpeg(imageData, { quality });
+    case "png":
+      return await impl.encodePng(imageData);
+    case "webp":
+      return await impl.encodeWebp(imageData, { quality });
+    default:
+      throw Error(`Unsupported encoding format`);
+  }
+}
+export {
+  processBuffer
+};

package/dist/assets/services/vendor/squoosh/image_data.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export default class ImageData {
+    static from(input: ImageData): ImageData;
+    private _data;
+    width: number;
+    height: number;
+    get data(): Buffer;
+    constructor(data: Buffer | Uint8Array | Uint8ClampedArray, width: number, height: number);
+}

package/dist/assets/services/vendor/squoosh/image_data.js

@@ -0,0 +1,22 @@
+class ImageData {
+  static from(input) {
+    return new ImageData(input.data || input._data, input.width, input.height);
+  }
+  get data() {
+    if (Object.prototype.toString.call(this._data) === "[object Object]") {
+      return Buffer.from(Object.values(this._data));
+    }
+    if (this._data instanceof Buffer || this._data instanceof Uint8Array || this._data instanceof Uint8ClampedArray) {
+      return Buffer.from(this._data);
+    }
+    throw new Error("invariant");
+  }
+  constructor(data, width, height) {
+    this._data = data;
+    this.width = width;
+    this.height = height;
+  }
+}
+export {
+  ImageData as default
+};