WIP: vendoring Squoosh to work with our build

packages/integrations/image/src/build/ssg.ts

@@ -9,6 +9,7 @@ import type { SSRImageService, TransformOptions } from '../loaders/index.js';
 import { loadLocalImage, loadRemoteImage } from '../utils/images.js';
 import { debug, info, LoggerLevel, warn } from '../utils/logger.js';
 import { isRemoteImage } from '../utils/paths.js';
+import { processBuffer } from '../vendor/squoosh/main.js';
 
 function getTimeStat(timeStart: number, timeEnd: number) {
 	const buildTime = timeEnd - timeStart;

packages/integrations/image/src/index.ts

@@ -1,9 +1,12 @@
 import type { AstroConfig, AstroIntegration } from 'astro';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 import { ssgBuild } from './build/ssg.js';
 import type { ImageService, TransformOptions } from './loaders/index.js';
 import type { LoggerLevel } from './utils/logger.js';
 import { joinPaths, prependForwardSlash, propsToFilename } from './utils/paths.js';
 import { createPlugin } from './vite-plugin-astro-image.js';
+import { copyLibFiles } from './vendor/squoosh/main.js';
 
 export { getImage } from './lib/get-image.js';
 export { getPicture } from './lib/get-picture.js';
@@ -101,6 +104,8 @@ export default function integration(options: IntegrationOptions = {}): AstroInte
 						: {};
 			},
 			'astro:build:done': async ({ dir }) => {
+				await copyLibFiles(dir);
+
 				if (_config.output === 'static') {
 					// for SSG builds, build all requested image transforms to dist
 					const loader = globalThis?.astroImage?.loader;

packages/integrations/image/src/loaders/squoosh.ts

@@ -1,15 +1,14 @@
 // @ts-ignore
-import { ImagePool } from '@squoosh/lib';
 import { red } from 'kleur/colors';
 import { BaseSSRService } from './index.js';
 import { error } from '../utils/logger.js';
 import { metadata } from '../utils/metadata.js';
-import type { OutputFormat, TransformOptions } from './index.js';
 import { isRemoteImage } from '../utils/paths.js';
+import type { OutputFormat, TransformOptions } from './index.js';
+import { processBuffer } from '../vendor/squoosh/main.js';
+import type { Operation } from '../vendor/squoosh/main.js';
 
 class SquooshService extends BaseSSRService {
-	#imagePool = new ImagePool();
-
 	async processAvif(image: any, transform: TransformOptions) {
 		const encodeOptions = transform.quality
 			? { avif: { quality: transform.quality } }
@@ -59,67 +58,61 @@ class SquooshService extends BaseSSRService {
 		};
 	}
 
-	async autorotate(image: any, transform: TransformOptions, inputBuffer: Buffer) {
+	async autorotate(transform: TransformOptions, inputBuffer: Buffer): Promise<Operation | undefined> {
 		// check EXIF orientation data and rotate the image if needed
-		const meta = await metadata(transform.src, inputBuffer);
+		try {
+			const meta = await metadata(transform.src, inputBuffer);
 
-		switch (meta?.orientation) {
-			case 3:
-			case 4:
-				await image.preprocess({ rotate: { numRotations: 2 } });
-				break;
-			case 5:
-			case 6:
-				await image.preprocess({ rotate: { numRotations: 1 } });
-				break;
-			case 7:
-			case 8:
-				await image.preprocess({ rotate: { numRotations: 3 } });
-				break;
-		}
+			switch (meta?.orientation) {
+				case 3:
+				case 4:
+					return { type: 'rotate', numRotations: 2 };
+				case 5:
+				case 6:
+					return { type: 'rotate', numRotations: 1 };
+				case 7:
+				case 8:
+					return { type: 'rotate', numRotations: 3 };
+			}
+		} catch { }
 	}
 
 	async transform(inputBuffer: Buffer, transform: TransformOptions) {
-		const image = this.#imagePool.ingestImage(inputBuffer);
-
-		let preprocessOptions: any = {};
+		const operations: Operation[] = [];
 
 		if (!isRemoteImage(transform.src)) {
-			try {
-				// Image files lie! Rotate the image based on EXIF data
-				await this.autorotate(image, transform, inputBuffer);
-			} catch { }
+			const autorotate = await this.autorotate(transform, inputBuffer)
+			
+			if (autorotate) {
+				operations.push(autorotate);
+			}
 		}
 
 		if (transform.width || transform.height) {
 			const width = transform.width && Math.round(transform.width);
 			const height = transform.height && Math.round(transform.height);
 
-			preprocessOptions.resize = {
+			operations.push({
+				type: 'resize',
 				width,
 				height,
-			};
-
-			await image.preprocess({ resize: { width, height } });
+			})
 		}
 
-		switch (transform.format) {
-			case 'avif':
-				return await this.processAvif(image, transform);
-			case 'jpg':
-			case 'jpeg':
-				return await this.processJpeg(image, transform);
-			case 'png':
-				return await this.processPng(image, transform);
-			case 'webp':
-				return await this.processWebp(image, transform);
-			default:
-				error({
-					level: 'info',
-					prefix: false,
-					message: red(`Unknown image output: "${transform.format}" used for ${transform.src}`),
-				});
-				throw new Error(`Unknown image output: "${transform.format}" used for ${transform.src}`);
+		if (!transform.format) {
+			error({
+				level: 'info',
+				prefix: false,
+				message: red(`Unknown image output: "${transform.format}" used for ${transform.src}`),
+			});
+			throw new Error(`Unknown image output: "${transform.format}" used for ${transform.src}`);
+		}
+
+		const data = await processBuffer(inputBuffer, operations, transform.format, transform.quality || 100);
+
+		return {
+			data,
+			format: transform.format
 		}
 	}
 }

packages/integrations/image/src/vendor/squoosh/LICENSE

@@ -0,0 +1,245 @@
+
+Skip to content
+Pull requests
+Issues
+Marketplace
+Explore
+@tony-sull
+vercel /
+next.js
+Public
+
+Code
+Issues 1.1k
+Pull requests 216
+Discussions
+Actions
+Security 8
+
+    Insights
+
+next.js/packages/next/server/lib/squoosh/LICENSE
+@timneutkens
+timneutkens Move next-server directory files to server directory (#26756)
+Latest commit 5b9ad8d on Jun 30, 2021
+History
+1 contributor
+202 lines (169 sloc) 11.1 KB
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+Footer
+© 2022 GitHub, Inc.
+Footer navigation
+
+    Terms
+    Privacy
+    Security
+    Status
+    Docs
+    Contact GitHub
+    Pricing
+    API
+    Training
+    Blog
+    About
+

packages/integrations/image/src/vendor/squoosh/avif/avif_enc.d.ts

@@ -0,0 +1,32 @@
+// eslint-disable-next-line no-shadow
+export const enum AVIFTune {
+  auto,
+  psnr,
+  ssim,
+}
+
+export interface EncodeOptions {
+  cqLevel: number
+  denoiseLevel: number
+  cqAlphaLevel: number
+  tileRowsLog2: number
+  tileColsLog2: number
+  speed: number
+  subsample: number
+  chromaDeltaQ: boolean
+  sharpness: number
+  tune: AVIFTune
+}
+
+export interface AVIFModule extends EmscriptenWasm.Module {
+  encode(
+    data: BufferSource,
+    width: number,
+    height: number,
+    options: EncodeOptions
+  ): Uint8Array
+}
+
+declare var moduleFactory: EmscriptenWasm.ModuleFactory<AVIFModule>
+
+export default moduleFactory

packages/integrations/image/src/vendor/squoosh/codecs.ts

@@ -0,0 +1,370 @@
+import { promises as fsp } from 'node:fs'
+import { instantiateEmscriptenWasm, pathify } from './emscripten-utils.js'
+
+interface DecodeModule extends EmscriptenWasm.Module {
+  decode: (data: Uint8Array) => ImageData
+}
+
+type DecodeModuleFactory = EmscriptenWasm.ModuleFactory<DecodeModule>
+
+interface RotateModuleInstance {
+  exports: {
+    memory: WebAssembly.Memory
+    rotate(width: number, height: number, rotate: number): void
+  }
+}
+
+interface ResizeWithAspectParams {
+  input_width: number
+  input_height: number
+  target_width?: number
+  target_height?: number
+}
+
+export interface ResizeOptions {
+  width?: number
+  height?: number
+  method: 'triangle' | 'catrom' | 'mitchell' | 'lanczos3'
+  premultiply: boolean
+  linearRGB: boolean
+}
+
+export interface RotateOptions {
+  numRotations: number
+}
+
+// MozJPEG
+import type { MozJPEGModule as MozJPEGEncodeModule } from './mozjpeg/mozjpeg_enc'
+// @ts-ignore
+import mozEnc from './mozjpeg/mozjpeg_node_enc.js'
+const mozEncWasm = new URL('./mozjpeg/mozjpeg_node_enc.wasm', import.meta.url)
+// @ts-ignore
+import mozDec from './mozjpeg/mozjpeg_node_dec.js'
+const mozDecWasm = new URL('./mozjpeg/mozjpeg_node_dec.wasm', import.meta.url)
+
+// WebP
+import type { WebPModule as WebPEncodeModule } from './webp/webp_enc'
+// @ts-ignore
+import webpEnc from './webp/webp_node_enc.js'
+const webpEncWasm = new URL('./webp/webp_node_enc.wasm', import.meta.url)
+// @ts-ignore
+import webpDec from './webp/webp_node_dec.js'
+const webpDecWasm = new URL('./webp/webp_node_dec.wasm', import.meta.url)
+
+// AVIF
+import type { AVIFModule as AVIFEncodeModule } from './avif/avif_enc'
+// @ts-ignore
+import avifEnc from './avif/avif_node_enc.js'
+const avifEncWasm = new URL('./avif/avif_node_enc.wasm', import.meta.url)
+// @ts-ignore
+import avifDec from './avif/avif_node_dec.js'
+const avifDecWasm = new URL('./avif/avif_node_dec.wasm', import.meta.url)
+
+// PNG
+// @ts-ignore
+import * as pngEncDec from './png/squoosh_png.js'
+const pngEncDecWasm = new URL('./png/squoosh_png_bg.wasm', import.meta.url)
+const pngEncDecInit = () =>
+  pngEncDec.default(fsp.readFile(pathify(pngEncDecWasm.toString())))
+
+// OxiPNG
+// @ts-ignore
+import * as oxipng from './png/squoosh_oxipng.js'
+const oxipngWasm = new URL('./png/squoosh_oxipng_bg.wasm', import.meta.url)
+const oxipngInit = () => oxipng.default(fsp.readFile(pathify(oxipngWasm.toString())))
+
+// Resize
+// @ts-ignore
+import * as resize from './resize/squoosh_resize.js'
+const resizeWasm = new URL('./resize/squoosh_resize_bg.wasm', import.meta.url)
+const resizeInit = () => resize.default(fsp.readFile(pathify(resizeWasm.toString())))
+
+// rotate
+const rotateWasm = new URL('./rotate/rotate.wasm', import.meta.url)
+
+// Our decoders currently rely on a `ImageData` global.
+import ImageData from './image_data.js'
+;(global as any).ImageData = ImageData
+
+function resizeNameToIndex(
+  name: 'triangle' | 'catrom' | 'mitchell' | 'lanczos3'
+) {
+  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,
+}: ResizeWithAspectParams): { width: number; height: number } {
+  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),
+  }
+}
+
+export const preprocessors = {
+  resize: {
+    name: 'Resize',
+    description: 'Resize the image before compressing',
+    instantiate: async () => {
+      await resizeInit()
+      return (
+        buffer: Uint8Array,
+        input_width: number,
+        input_height: number,
+        { width, height, method, premultiply, linearRGB }: ResizeOptions
+      ) => {
+        ;({ 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
+        )
+        return imageData
+      }
+    },
+    defaultOptions: {
+      method: 'lanczos3',
+      fitMethod: 'stretch',
+      premultiply: true,
+      linearRGB: true,
+    },
+  },
+  rotate: {
+    name: 'Rotate',
+    description: 'Rotate image',
+    instantiate: async () => {
+      return async (
+        buffer: Uint8Array,
+        width: number,
+        height: number,
+        { numRotations }: RotateOptions
+      ) => {
+        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 as RotateModuleInstance
+        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,
+    },
+  },
+} as const
+
+export const codecs = {
+  mozjpeg: {
+    name: 'MozJPEG',
+    extension: 'jpg',
+    detectors: [/^\xFF\xD8\xFF/],
+    dec: () =>
+      instantiateEmscriptenWasm(mozDec as DecodeModuleFactory, mozDecWasm.toString()),
+    enc: () =>
+      instantiateEmscriptenWasm(
+        mozEnc as EmscriptenWasm.ModuleFactory<MozJPEGEncodeModule>,
+        mozEncWasm.toString()
+      ),
+    defaultEncoderOptions: {
+      quality: 75,
+      baseline: false,
+      arithmetic: false,
+      progressive: true,
+      optimize_coding: true,
+      smoothing: 0,
+      color_space: 3 /*YCbCr*/,
+      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 as DecodeModuleFactory, webpDecWasm.toString()),
+    enc: () =>
+      instantiateEmscriptenWasm(
+        webpEnc as EmscriptenWasm.ModuleFactory<WebPEncodeModule>,
+        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',
+    // eslint-disable-next-line no-control-regex
+    detectors: [/^\x00\x00\x00 ftypavif\x00\x00\x00\x00/],
+    dec: () =>
+      instantiateEmscriptenWasm(avifDec as DecodeModuleFactory, avifDecWasm.toString()),
+    enc: async () => {
+      return instantiateEmscriptenWasm(
+        avifEnc as EmscriptenWasm.ModuleFactory<AVIFEncodeModule>,
+        avifEncWasm.toString()
+      )
+    },
+    defaultEncoderOptions: {
+      cqLevel: 33,
+      cqAlphaLevel: -1,
+      denoiseLevel: 0,
+      tileColsLog2: 0,
+      tileRowsLog2: 0,
+      speed: 6,
+      subsample: 1,
+      chromaDeltaQ: false,
+      sharpness: 0,
+      tune: 0 /* AVIFTune.auto */,
+    },
+    autoOptimize: {
+      option: 'cqLevel',
+      min: 62,
+      max: 0,
+    },
+  },
+  oxipng: {
+    name: 'OxiPNG',
+    extension: 'png',
+    // eslint-disable-next-line no-control-regex
+    detectors: [/^\x89PNG\x0D\x0A\x1A\x0A/],
+    dec: async () => {
+      await pngEncDecInit()
+      return {
+        decode: (buffer: Buffer | Uint8Array) => {
+          const imageData = pngEncDec.decode(buffer)
+          return imageData
+        },
+      }
+    },
+    enc: async () => {
+      await pngEncDecInit()
+      await oxipngInit()
+      return {
+        encode: (
+          buffer: Uint8ClampedArray | ArrayBuffer,
+          width: number,
+          height: number,
+          opts: { level: number }
+        ) => {
+          const simplePng = pngEncDec.encode(
+            new Uint8Array(buffer),
+            width,
+            height
+          )
+          const imageData = oxipng.optimise(simplePng, opts.level, false)
+          return imageData
+        },
+      }
+    },
+    defaultEncoderOptions: {
+      level: 2,
+    },
+    autoOptimize: {
+      option: 'level',
+      min: 6,
+      max: 1,
+    },
+  },
+} as const

packages/integrations/image/src/vendor/squoosh/emscripten-types.d.ts

@@ -0,0 +1,121 @@
+// These types roughly model the object that the JS files generated by Emscripten define. Copied from https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/emscripten/index.d.ts and turned into a type definition rather than a global to support our way of using Emscripten.
+declare namespace EmscriptenWasm {
+  type ModuleFactory<T extends Module = Module> = (
+    moduleOverrides?: ModuleOpts
+  ) => Promise<T>
+
+  type EnvironmentType = 'WEB' | 'NODE' | 'SHELL' | 'WORKER'
+
+  // Options object for modularized Emscripten files. Shoe-horned by @surma.
+  // FIXME: This an incomplete definition!
+  interface ModuleOpts {
+    mainScriptUrlOrBlob?: string
+    noInitialRun?: boolean
+    locateFile?: (url: string) => string
+    onRuntimeInitialized?: () => void
+  }
+
+  interface Module {
+    print(str: string): void
+    printErr(str: string): void
+    arguments: string[]
+    environment: EnvironmentType
+    preInit: { (): void }[]
+    preRun: { (): void }[]
+    postRun: { (): void }[]
+    preinitializedWebGLContext: WebGLRenderingContext
+    noInitialRun: boolean
+    noExitRuntime: boolean
+    logReadFiles: boolean
+    filePackagePrefixURL: string
+    wasmBinary: ArrayBuffer
+
+    destroy(object: object): void
+    getPreloadedPackage(
+      remotePackageName: string,
+      remotePackageSize: number
+    ): ArrayBuffer
+    instantiateWasm(
+      imports: WebAssembly.Imports,
+      successCallback: (module: WebAssembly.Module) => void
+    ): WebAssembly.Exports
+    locateFile(url: string): string
+    onCustomMessage(event: MessageEvent): void
+
+    Runtime: any
+
+    ccall(
+      ident: string,
+      returnType: string | null,
+      argTypes: string[],
+      args: any[]
+    ): any
+    cwrap(ident: string, returnType: string | null, argTypes: string[]): any
+
+    setValue(ptr: number, value: any, type: string, noSafe?: boolean): void
+    getValue(ptr: number, type: string, noSafe?: boolean): number
+
+    ALLOC_NORMAL: number
+    ALLOC_STACK: number
+    ALLOC_STATIC: number
+    ALLOC_DYNAMIC: number
+    ALLOC_NONE: number
+
+    allocate(slab: any, types: string, allocator: number, ptr: number): number
+    allocate(slab: any, types: string[], allocator: number, ptr: number): number
+
+    Pointer_stringify(ptr: number, length?: number): string
+    UTF16ToString(ptr: number): string
+    stringToUTF16(str: string, outPtr: number): void
+    UTF32ToString(ptr: number): string
+    stringToUTF32(str: string, outPtr: number): void
+
+    // USE_TYPED_ARRAYS == 1
+    HEAP: Int32Array
+    IHEAP: Int32Array
+    FHEAP: Float64Array
+
+    // USE_TYPED_ARRAYS == 2
+    HEAP8: Int8Array
+    HEAP16: Int16Array
+    HEAP32: Int32Array
+    HEAPU8: Uint8Array
+    HEAPU16: Uint16Array
+    HEAPU32: Uint32Array
+    HEAPF32: Float32Array
+    HEAPF64: Float64Array
+
+    TOTAL_STACK: number
+    TOTAL_MEMORY: number
+    FAST_MEMORY: number
+
+    addOnPreRun(cb: () => any): void
+    addOnInit(cb: () => any): void
+    addOnPreMain(cb: () => any): void
+    addOnExit(cb: () => any): void
+    addOnPostRun(cb: () => any): void
+
+    // Tools
+    intArrayFromString(
+      stringy: string,
+      dontAddNull?: boolean,
+      length?: number
+    ): number[]
+    intArrayToString(array: number[]): string
+    writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void
+    writeArrayToMemory(array: number[], buffer: number): void
+    writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void
+
+    addRunDependency(id: any): void
+    removeRunDependency(id: any): void
+
+    preloadedImages: any
+    preloadedAudios: any
+
+    _malloc(size: number): number
+    _free(ptr: number): void
+
+    // Augmentations below by @surma.
+    onRuntimeInitialized: () => void | null
+  }
+}

packages/integrations/image/src/vendor/squoosh/emscripten-utils.ts

@@ -0,0 +1,30 @@
+import { fileURLToPath } from 'node:url'
+
+export function pathify(path: string): string {
+  if (path.startsWith('file://')) {
+    path = fileURLToPath(path)
+  }
+  return path
+}
+
+export function instantiateEmscriptenWasm<T extends EmscriptenWasm.Module>(
+  factory: EmscriptenWasm.ModuleFactory<T>,
+  path: string,
+  workerJS: string = ''
+): Promise<T> {
+  return factory({
+    locateFile(requestPath) {
+      // The glue code generated by emscripten uses the original
+      // file names of the worker file and the wasm binary.
+      // These will have changed in the bundling process and
+      // we need to inject them here.
+      if (requestPath.endsWith('.wasm')) return pathify(path)
+      if (requestPath.endsWith('.worker.js')) return pathify(workerJS)
+      return requestPath
+    },
+  })
+}
+
+export function dirname(url: string) {
+	return url.substring(0, url.lastIndexOf('/'))
+}

packages/integrations/image/src/vendor/squoosh/image_data.ts

@@ -0,0 +1,33 @@
+export default class ImageData {
+  static from(input: ImageData): ImageData {
+    return new ImageData(input.data || input._data, input.width, input.height)
+  }
+
+  private _data: Buffer | Uint8Array | Uint8ClampedArray
+  width: number
+  height: number
+
+  get data(): Buffer {
+    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: Buffer | Uint8Array | Uint8ClampedArray,
+    width: number,
+    height: number
+  ) {
+    this._data = data
+    this.width = width
+    this.height = height
+  }
+}

packages/integrations/image/src/vendor/squoosh/impl.ts

@@ -0,0 +1,135 @@
+import { codecs as supportedFormats, preprocessors } from './codecs.js'
+import ImageData from './image_data.js'
+
+type EncoderKey = keyof typeof supportedFormats
+
+const DELAY_MS = 1000
+let _promise: Promise<void> | undefined
+
+function delayOnce(ms: number): Promise<void> {
+  if (!_promise) {
+    _promise = new Promise((resolve) => {
+      setTimeout(resolve, ms)
+    })
+  }
+  return _promise
+}
+
+function maybeDelay(): Promise<void> {
+  const isAppleM1 = process.arch === 'arm64' && process.platform === 'darwin'
+  if (isAppleM1) {
+    return delayOnce(DELAY_MS)
+  }
+  return Promise.resolve()
+}
+
+export async function decodeBuffer(
+  _buffer: Buffer | Uint8Array
+): Promise<ImageData> {
+  const buffer = Buffer.from(_buffer)
+  const firstChunk = buffer.slice(0, 16)
+  const firstChunkString = Array.from(firstChunk)
+    .map((v) => String.fromCodePoint(v))
+    .join('')
+  const key = Object.entries(supportedFormats).find(([, { detectors }]) =>
+    detectors.some((detector) => detector.exec(firstChunkString))
+  )?.[0] as EncoderKey | undefined
+  if (!key) {
+    throw Error(`Buffer has an unsupported format`)
+  }
+  const encoder = supportedFormats[key]
+  const mod = await encoder.dec()
+  const rgba = mod.decode(new Uint8Array(buffer))
+	// @ts-ignore
+  return rgba
+}
+
+export async function rotate(
+  image: ImageData,
+  numRotations: number
+): Promise<ImageData> {
+  image = ImageData.from(image)
+
+  const m = await preprocessors['rotate'].instantiate()
+  return await m(image.data, image.width, image.height, { numRotations })
+}
+
+type ResizeOpts = { image: ImageData } & { width?: number; height?: number }
+
+export async function resize({ image, width, height }: ResizeOpts) {
+  image = ImageData.from(image)
+
+  const p = preprocessors['resize']
+  const m = await p.instantiate()
+  await maybeDelay()
+  return await m(image.data, image.width, image.height, {
+    ...p.defaultOptions,
+    width,
+    height,
+  })
+}
+
+export async function encodeJpeg(
+  image: ImageData,
+  { quality }: { quality: number }
+): Promise<Buffer | Uint8Array> {
+  image = ImageData.from(image)
+
+  const e = supportedFormats['mozjpeg']
+  const m = await e.enc()
+  await maybeDelay()
+  const r = await m.encode(image.data, image.width, image.height, {
+    ...e.defaultEncoderOptions,
+    quality,
+  })
+  return Buffer.from(r)
+}
+
+export async function encodeWebp(
+  image: ImageData,
+  { quality }: { quality: number }
+): Promise<Buffer | Uint8Array> {
+  image = ImageData.from(image)
+
+  const e = supportedFormats['webp']
+  const m = await e.enc()
+  await maybeDelay()
+  const r = await m.encode(image.data, image.width, image.height, {
+    ...e.defaultEncoderOptions,
+    quality,
+  })
+  return Buffer.from(r)
+}
+
+export async function encodeAvif(
+  image: ImageData,
+  { quality }: { quality: number }
+): Promise<Buffer | Uint8Array> {
+  image = ImageData.from(image)
+
+  const e = supportedFormats['avif']
+  const m = await e.enc()
+  await maybeDelay()
+  const val = e.autoOptimize.min
+  const r = await m.encode(image.data, image.width, image.height, {
+    ...e.defaultEncoderOptions,
+    // Think of cqLevel as the "amount" of quantization (0 to 62),
+    // so a lower value yields higher quality (0 to 100).
+    cqLevel: quality === 0 ? val : Math.round(val - (quality / 100) * val),
+  })
+  return Buffer.from(r)
+}
+
+export async function encodePng(
+  image: ImageData
+): Promise<Buffer | Uint8Array> {
+  image = ImageData.from(image)
+
+  const e = supportedFormats['oxipng']
+  const m = await e.enc()
+  await maybeDelay()
+  const r = await m.encode(image.data, image.width, image.height, {
+    ...e.defaultEncoderOptions,
+  })
+  return Buffer.from(r)
+}

packages/integrations/image/src/vendor/squoosh/main.ts

@@ -0,0 +1,67 @@
+import * as worker from './impl.js';
+import type { OutputFormat } from '../../loaders/index.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+type RotateOperation = {
+  type: 'rotate'
+  numRotations: number
+}
+type ResizeOperation = {
+  type: 'resize'
+	width?: number
+	height?: number
+}
+export type Operation = RotateOperation | ResizeOperation
+
+export async function processBuffer(
+  buffer: Buffer,
+  operations: Operation[],
+  encoding: OutputFormat,
+  quality: number
+): Promise<Buffer> {
+  let imageData = await worker.decodeBuffer(buffer)
+  for (const operation of operations) {
+    if (operation.type === 'rotate') {
+      imageData = await worker.rotate(imageData, operation.numRotations)
+    } else if (operation.type === 'resize') {
+			imageData = await worker.resize({ image: imageData, height: operation.height, width: operation.width})
+    }
+  }
+
+  switch (encoding) {
+    case 'jpeg':
+		case 'jpg':
+      return Buffer.from(await worker.encodeJpeg(imageData, { quality }))
+    case 'webp':
+      return Buffer.from(await worker.encodeWebp(imageData, { quality }))
+    case 'avif':
+      return Buffer.from(await worker.encodeAvif(imageData, { quality }))
+    case 'png':
+      return Buffer.from(await worker.encodePng(imageData))
+    default:
+      throw Error(`Unsupported encoding format`)
+  }
+}
+
+export async function copyLibFiles(dir: URL) {
+	const src = new URL('../../../lib/', import.meta.url);
+	await copyLibDir(fileURLToPath(src), fileURLToPath(dir));
+}
+
+async function copyLibDir(src: string, dest: string) {
+	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()) {
+			await fs.mkdir(path.dirname(destPath), { recursive: true });
+			await fs.copyFile(srcPath, destPath);
+		}
+		else if (s.isDirectory()) {
+			await copyLibDir(srcPath, destPath);
+		}
+}));
+}

packages/integrations/image/src/vendor/squoosh/mozjpeg/mozjpeg_enc.d.ts

@@ -0,0 +1,38 @@
+// eslint-disable-next-line no-shadow
+export const enum MozJpegColorSpace {
+  GRAYSCALE = 1,
+  RGB,
+  YCbCr,
+}
+
+export interface EncodeOptions {
+  quality: number
+  baseline: boolean
+  arithmetic: boolean
+  progressive: boolean
+  optimize_coding: boolean
+  smoothing: number
+  color_space: MozJpegColorSpace
+  quant_table: number
+  trellis_multipass: boolean
+  trellis_opt_zero: boolean
+  trellis_opt_table: boolean
+  trellis_loops: number
+  auto_subsample: boolean
+  chroma_subsample: number
+  separate_chroma_quality: boolean
+  chroma_quality: number
+}
+
+export interface MozJPEGModule extends EmscriptenWasm.Module {
+  encode(
+    data: BufferSource,
+    width: number,
+    height: number,
+    options: EncodeOptions
+  ): Uint8Array
+}
+
+declare var moduleFactory: EmscriptenWasm.ModuleFactory<MozJPEGModule>
+
+export default moduleFactory

packages/integrations/image/src/vendor/squoosh/png/squoosh_oxipng.ts

@@ -0,0 +1,120 @@
+// @ts-nocheck
+let wasm
+
+let cachedTextDecoder = new TextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true,
+})
+
+cachedTextDecoder.decode()
+
+let cachegetUint8Memory0 = null
+function getUint8Memory0() {
+  if (
+    cachegetUint8Memory0 === null ||
+    cachegetUint8Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer)
+  }
+  return cachegetUint8Memory0
+}
+
+function getStringFromWasm0(ptr, len) {
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len))
+}
+
+let WASM_VECTOR_LEN = 0
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1)
+  getUint8Memory0().set(arg, ptr / 1)
+  WASM_VECTOR_LEN = arg.length
+  return ptr
+}
+
+let cachegetInt32Memory0 = null
+function getInt32Memory0() {
+  if (
+    cachegetInt32Memory0 === null ||
+    cachegetInt32Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer)
+  }
+  return cachegetInt32Memory0
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len)
+}
+/**
+ * @param {Uint8Array} data
+ * @param {number} level
+ * @param {boolean} interlace
+ * @returns {Uint8Array}
+ */
+export function optimise(data, level, interlace) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
+    var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc)
+    var len0 = WASM_VECTOR_LEN
+    wasm.optimise(retptr, ptr0, len0, level, interlace)
+    var r0 = getInt32Memory0()[retptr / 4 + 0]
+    var r1 = getInt32Memory0()[retptr / 4 + 1]
+    var v1 = getArrayU8FromWasm0(r0, r1).slice()
+    wasm.__wbindgen_free(r0, r1 * 1)
+    return v1
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16)
+  }
+}
+
+async function load(module, imports) {
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      return await WebAssembly.instantiateStreaming(module, imports)
+    }
+
+    const bytes = await module.arrayBuffer()
+    return await WebAssembly.instantiate(bytes, imports)
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports)
+
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module }
+    } else {
+      return instance
+    }
+  }
+}
+
+async function init(input) {
+  const imports = {}
+  imports.wbg = {}
+  imports.wbg.__wbindgen_throw = function (arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1))
+  }
+
+  if (
+    typeof input === 'string' ||
+    (typeof Request === 'function' && input instanceof Request) ||
+    (typeof URL === 'function' && input instanceof URL)
+  ) {
+    input = fetch(input)
+  }
+
+  const { instance, module } = await load(await input, imports)
+
+  wasm = instance.exports
+  init.__wbindgen_wasm_module = module
+
+  return wasm
+}
+
+export default init
+
+// Manually remove the wasm and memory references to trigger GC
+export function cleanup() {
+  wasm = null
+  cachegetUint8Memory0 = null
+  cachegetInt32Memory0 = null
+}

packages/integrations/image/src/vendor/squoosh/png/squoosh_png.ts

@@ -0,0 +1,184 @@
+// @ts-nocheck
+let wasm
+
+let cachedTextDecoder = new TextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true,
+})
+
+cachedTextDecoder.decode()
+
+let cachegetUint8Memory0 = null
+function getUint8Memory0() {
+  if (
+    cachegetUint8Memory0 === null ||
+    cachegetUint8Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer)
+  }
+  return cachegetUint8Memory0
+}
+
+function getStringFromWasm0(ptr, len) {
+  return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len))
+}
+
+let cachegetUint8ClampedMemory0 = null
+function getUint8ClampedMemory0() {
+  if (
+    cachegetUint8ClampedMemory0 === null ||
+    cachegetUint8ClampedMemory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetUint8ClampedMemory0 = new Uint8ClampedArray(wasm.memory.buffer)
+  }
+  return cachegetUint8ClampedMemory0
+}
+
+function getClampedArrayU8FromWasm0(ptr, len) {
+  return getUint8ClampedMemory0().subarray(ptr / 1, ptr / 1 + len)
+}
+
+const heap = new Array(32).fill(undefined)
+
+heap.push(undefined, null, true, false)
+
+let heap_next = heap.length
+
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1)
+  const idx = heap_next
+  heap_next = heap[idx]
+
+  heap[idx] = obj
+  return idx
+}
+
+let WASM_VECTOR_LEN = 0
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1)
+  getUint8Memory0().set(arg, ptr / 1)
+  WASM_VECTOR_LEN = arg.length
+  return ptr
+}
+
+let cachegetInt32Memory0 = null
+function getInt32Memory0() {
+  if (
+    cachegetInt32Memory0 === null ||
+    cachegetInt32Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer)
+  }
+  return cachegetInt32Memory0
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len)
+}
+/**
+ * @param {Uint8Array} data
+ * @param {number} width
+ * @param {number} height
+ * @returns {Uint8Array}
+ */
+export function encode(data, width, height) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
+    var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc)
+    var len0 = WASM_VECTOR_LEN
+    wasm.encode(retptr, ptr0, len0, width, height)
+    var r0 = getInt32Memory0()[retptr / 4 + 0]
+    var r1 = getInt32Memory0()[retptr / 4 + 1]
+    var v1 = getArrayU8FromWasm0(r0, r1).slice()
+    wasm.__wbindgen_free(r0, r1 * 1)
+    return v1
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16)
+  }
+}
+
+function getObject(idx) {
+  return heap[idx]
+}
+
+function dropObject(idx) {
+  if (idx < 36) return
+  heap[idx] = heap_next
+  heap_next = idx
+}
+
+function takeObject(idx) {
+  const ret = getObject(idx)
+  dropObject(idx)
+  return ret
+}
+/**
+ * @param {Uint8Array} data
+ * @returns {ImageData}
+ */
+export function decode(data) {
+  var ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc)
+  var len0 = WASM_VECTOR_LEN
+  var ret = wasm.decode(ptr0, len0)
+  return takeObject(ret)
+}
+
+async function load(module, imports) {
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      return await WebAssembly.instantiateStreaming(module, imports)
+    }
+
+    const bytes = await module.arrayBuffer()
+    return await WebAssembly.instantiate(bytes, imports)
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports)
+
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module }
+    } else {
+      return instance
+    }
+  }
+}
+
+async function init(input) {
+  const imports = {}
+  imports.wbg = {}
+  imports.wbg.__wbg_newwithownedu8clampedarrayandsh_787b2db8ea6bfd62 =
+    function (arg0, arg1, arg2, arg3) {
+      var v0 = getClampedArrayU8FromWasm0(arg0, arg1).slice()
+      wasm.__wbindgen_free(arg0, arg1 * 1)
+      var ret = new ImageData(v0, arg2 >>> 0, arg3 >>> 0)
+      return addHeapObject(ret)
+    }
+  imports.wbg.__wbindgen_throw = function (arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1))
+  }
+
+  if (
+    typeof input === 'string' ||
+    (typeof Request === 'function' && input instanceof Request) ||
+    (typeof URL === 'function' && input instanceof URL)
+  ) {
+    input = fetch(input)
+  }
+
+  const { instance, module } = await load(await input, imports)
+
+  wasm = instance.exports
+  init.__wbindgen_wasm_module = module
+
+  return wasm
+}
+
+export default init
+
+// Manually remove the wasm and memory references to trigger GC
+export function cleanup() {
+  wasm = null
+  cachegetUint8ClampedMemory0 = null
+  cachegetUint8Memory0 = null
+  cachegetInt32Memory0 = null
+}

packages/integrations/image/src/vendor/squoosh/resize/squoosh_resize.ts

@@ -0,0 +1,141 @@
+// @ts-nocheck
+let wasm
+
+let cachegetUint8Memory0 = null
+function getUint8Memory0() {
+  if (
+    cachegetUint8Memory0 === null ||
+    cachegetUint8Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetUint8Memory0 = new Uint8Array(wasm.memory.buffer)
+  }
+  return cachegetUint8Memory0
+}
+
+let WASM_VECTOR_LEN = 0
+
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1)
+  getUint8Memory0().set(arg, ptr / 1)
+  WASM_VECTOR_LEN = arg.length
+  return ptr
+}
+
+let cachegetInt32Memory0 = null
+function getInt32Memory0() {
+  if (
+    cachegetInt32Memory0 === null ||
+    cachegetInt32Memory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetInt32Memory0 = new Int32Array(wasm.memory.buffer)
+  }
+  return cachegetInt32Memory0
+}
+
+let cachegetUint8ClampedMemory0 = null
+function getUint8ClampedMemory0() {
+  if (
+    cachegetUint8ClampedMemory0 === null ||
+    cachegetUint8ClampedMemory0.buffer !== wasm.memory.buffer
+  ) {
+    cachegetUint8ClampedMemory0 = new Uint8ClampedArray(wasm.memory.buffer)
+  }
+  return cachegetUint8ClampedMemory0
+}
+
+function getClampedArrayU8FromWasm0(ptr, len) {
+  return getUint8ClampedMemory0().subarray(ptr / 1, ptr / 1 + len)
+}
+/**
+ * @param {Uint8Array} input_image
+ * @param {number} input_width
+ * @param {number} input_height
+ * @param {number} output_width
+ * @param {number} output_height
+ * @param {number} typ_idx
+ * @param {boolean} premultiply
+ * @param {boolean} color_space_conversion
+ * @returns {Uint8ClampedArray}
+ */
+export function resize(
+  input_image,
+  input_width,
+  input_height,
+  output_width,
+  output_height,
+  typ_idx,
+  premultiply,
+  color_space_conversion
+) {
+  try {
+    const retptr = wasm.__wbindgen_add_to_stack_pointer(-16)
+    var ptr0 = passArray8ToWasm0(input_image, wasm.__wbindgen_malloc)
+    var len0 = WASM_VECTOR_LEN
+    wasm.resize(
+      retptr,
+      ptr0,
+      len0,
+      input_width,
+      input_height,
+      output_width,
+      output_height,
+      typ_idx,
+      premultiply,
+      color_space_conversion
+    )
+    var r0 = getInt32Memory0()[retptr / 4 + 0]
+    var r1 = getInt32Memory0()[retptr / 4 + 1]
+    var v1 = getClampedArrayU8FromWasm0(r0, r1).slice()
+    wasm.__wbindgen_free(r0, r1 * 1)
+    return v1
+  } finally {
+    wasm.__wbindgen_add_to_stack_pointer(16)
+  }
+}
+
+async function load(module, imports) {
+  if (typeof Response === 'function' && module instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === 'function') {
+      return await WebAssembly.instantiateStreaming(module, imports)
+    }
+
+    const bytes = await module.arrayBuffer()
+    return await WebAssembly.instantiate(bytes, imports)
+  } else {
+    const instance = await WebAssembly.instantiate(module, imports)
+
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module }
+    } else {
+      return instance
+    }
+  }
+}
+
+async function init(input) {
+  const imports = {}
+
+  if (
+    typeof input === 'string' ||
+    (typeof Request === 'function' && input instanceof Request) ||
+    (typeof URL === 'function' && input instanceof URL)
+  ) {
+    input = fetch(input)
+  }
+
+  const { instance, module } = await load(await input, imports)
+
+  wasm = instance.exports
+  init.__wbindgen_wasm_module = module
+
+  return wasm
+}
+
+export default init
+
+// Manually remove the wasm and memory references to trigger GC
+export function cleanup() {
+  wasm = null
+  cachegetUint8Memory0 = null
+  cachegetInt32Memory0 = null
+}

packages/integrations/image/src/vendor/squoosh/webp/webp_enc.d.ts

@@ -0,0 +1,42 @@
+export interface EncodeOptions {
+  quality: number
+  target_size: number
+  target_PSNR: number
+  method: number
+  sns_strength: number
+  filter_strength: number
+  filter_sharpness: number
+  filter_type: number
+  partitions: number
+  segments: number
+  pass: number
+  show_compressed: number
+  preprocessing: number
+  autofilter: number
+  partition_limit: number
+  alpha_compression: number
+  alpha_filtering: number
+  alpha_quality: number
+  lossless: number
+  exact: number
+  image_hint: number
+  emulate_jpeg_size: number
+  thread_level: number
+  low_memory: number
+  near_lossless: number
+  use_delta_palette: number
+  use_sharp_yuv: number
+}
+
+export interface WebPModule extends EmscriptenWasm.Module {
+  encode(
+    data: BufferSource,
+    width: number,
+    height: number,
+    options: EncodeOptions
+  ): Uint8Array
+}
+
+declare var moduleFactory: EmscriptenWasm.ModuleFactory<WebPModule>
+
+export default moduleFactory

pnpm-lock.yaml

@@ -972,14 +972,6 @@ importers:
       '@astrojs/tailwind': link:../../../../integrations/tailwind
       astro: link:../../..
 
-  packages/astro/e2e/fixtures/third-party-astro:
-    specifiers:
-      astro: workspace:*
-      astro-embed: ^0.1.1
-    dependencies:
-      astro: link:../../..
-      astro-embed: 0.1.1_astro@packages+astro
-
   packages/astro/e2e/fixtures/ts-resolution:
     specifiers:
       '@astrojs/react': workspace:*