🎉 initiate project *astro_rewrite*

This commit is contained in:
sindrekjelsrud 2023-07-19 21:31:30 +02:00
parent ffd4d5e86c
commit 2ba37bfbe3
8658 changed files with 2268794 additions and 2538 deletions

0
node_modules/astro/dist/@types/app.d.js generated vendored Normal file
View file

1846
node_modules/astro/dist/@types/astro.d.ts generated vendored Normal file

File diff suppressed because it is too large Load diff

0
node_modules/astro/dist/@types/astro.js generated vendored Normal file
View file

41
node_modules/astro/dist/@types/typed-emitter.d.ts generated vendored Normal file
View file

@ -0,0 +1,41 @@
/**
* The MIT License (MIT)
* Copyright (c) 2018 Andy Wermke
* https://github.com/andywer/typed-emitter/blob/9a139b6fa0ec6b0db6141b5b756b784e4f7ef4e4/LICENSE
*/
export type EventMap = {
[key: string]: (...args: any[]) => void;
};
/**
* Type-safe event emitter.
*
* Use it like this:
*
* ```typescript
* type MyEvents = {
* error: (error: Error) => void;
* message: (from: string, content: string) => void;
* }
*
* const myEmitter = new EventEmitter() as TypedEmitter<MyEvents>;
*
* myEmitter.emit("error", "x") // <- Will catch this type error;
* ```
*/
export interface TypedEventEmitter<Events extends EventMap> {
addListener<E extends keyof Events>(event: E, listener: Events[E]): this;
on<E extends keyof Events>(event: E, listener: Events[E]): this;
once<E extends keyof Events>(event: E, listener: Events[E]): this;
prependListener<E extends keyof Events>(event: E, listener: Events[E]): this;
prependOnceListener<E extends keyof Events>(event: E, listener: Events[E]): this;
off<E extends keyof Events>(event: E, listener: Events[E]): this;
removeAllListeners<E extends keyof Events>(event?: E): this;
removeListener<E extends keyof Events>(event: E, listener: Events[E]): this;
emit<E extends keyof Events>(event: E, ...args: Parameters<Events[E]>): boolean;
eventNames(): (keyof Events | string | symbol)[];
rawListeners<E extends keyof Events>(event: E): Events[E][];
listeners<E extends keyof Events>(event: E): Events[E][];
listenerCount<E extends keyof Events>(event: E): number;
getMaxListeners(): number;
setMaxListeners(maxListeners: number): this;
}

0
node_modules/astro/dist/@types/typed-emitter.js generated vendored Normal file
View file

9
node_modules/astro/dist/assets/consts.d.ts generated vendored Normal file
View file

@ -0,0 +1,9 @@
export declare const VIRTUAL_MODULE_ID = "astro:assets";
export declare const VIRTUAL_SERVICE_ID = "virtual:image-service";
export declare const VALID_INPUT_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg"];
/**
* Valid formats that our base services support.
* Certain formats can be imported (namely SVGs) but will not be processed.
*/
export declare const VALID_SUPPORTED_FORMATS: readonly ["jpeg", "jpg", "png", "tiff", "webp", "gif", "svg"];
export declare const VALID_OUTPUT_FORMATS: readonly ["avif", "png", "webp", "jpeg", "jpg", "svg"];

36
node_modules/astro/dist/assets/consts.js generated vendored Normal file
View file

@ -0,0 +1,36 @@
const VIRTUAL_MODULE_ID = "astro:assets";
const VIRTUAL_SERVICE_ID = "virtual:image-service";
const VALID_INPUT_FORMATS = [
// TODO: `image-size` does not support the following formats, so users can't import them.
// However, it would be immensely useful to add, for three reasons:
// - `heic` and `heif` are common formats, especially among Apple users.
// - AVIF is a common format on the web that's bound to become more and more common.
// - It's totally reasonable for an user's provided image service to want to support more image types.
//'heic',
//'heif',
//'avif',
"jpeg",
"jpg",
"png",
"tiff",
"webp",
"gif",
"svg"
];
const VALID_SUPPORTED_FORMATS = [
"jpeg",
"jpg",
"png",
"tiff",
"webp",
"gif",
"svg"
];
const VALID_OUTPUT_FORMATS = ["avif", "png", "webp", "jpeg", "jpg", "svg"];
export {
VALID_INPUT_FORMATS,
VALID_OUTPUT_FORMATS,
VALID_SUPPORTED_FORMATS,
VIRTUAL_MODULE_ID,
VIRTUAL_SERVICE_ID
};

22
node_modules/astro/dist/assets/generate.d.ts generated vendored Normal file
View file

@ -0,0 +1,22 @@
import type { StaticBuildOptions } from '../core/build/types.js';
import type { ImageTransform } from './types.js';
interface GenerationDataUncached {
cached: false;
weight: {
before: number;
after: number;
};
}
interface GenerationDataCached {
cached: true;
}
type GenerationData = GenerationDataUncached | GenerationDataCached;
export declare function generateImage(buildOpts: StaticBuildOptions, options: ImageTransform, filepath: string): Promise<GenerationData | undefined>;
export declare function getStaticImageList(): Iterable<[
string,
{
path: string;
options: ImageTransform;
}
]>;
export {};

90
node_modules/astro/dist/assets/generate.js generated vendored Normal file
View file

@ -0,0 +1,90 @@
import fs from "node:fs";
import { basename, join } from "node:path/posix";
import { warn } from "../core/logger/core.js";
import { prependForwardSlash } from "../core/path.js";
import { isServerLikeOutput } from "../prerender/utils.js";
import { getConfiguredImageService, isESMImportedImage } from "./internal.js";
async function generateImage(buildOpts, options, filepath) {
if (!isESMImportedImage(options.src)) {
return void 0;
}
let useCache = true;
const assetsCacheDir = new URL("assets/", buildOpts.settings.config.cacheDir);
try {
await fs.promises.mkdir(assetsCacheDir, { recursive: true });
} catch (err) {
warn(
buildOpts.logging,
"astro:assets",
`An error was encountered while creating the cache directory. Proceeding without caching. Error: ${err}`
);
useCache = false;
}
let serverRoot, clientRoot;
if (isServerLikeOutput(buildOpts.settings.config)) {
serverRoot = buildOpts.settings.config.build.server;
clientRoot = buildOpts.settings.config.build.client;
} else {
serverRoot = buildOpts.settings.config.outDir;
clientRoot = buildOpts.settings.config.outDir;
}
const finalFileURL = new URL("." + filepath, clientRoot);
const finalFolderURL = new URL("./", finalFileURL);
const cachedFileURL = new URL(basename(filepath), assetsCacheDir);
try {
await fs.promises.copyFile(cachedFileURL, finalFileURL);
return {
cached: true
};
} catch (e) {
}
const originalImagePath = options.src.src;
const fileData = await fs.promises.readFile(
new URL(
"." + prependForwardSlash(
join(buildOpts.settings.config.build.assets, basename(originalImagePath))
),
serverRoot
)
);
const imageService = await getConfiguredImageService();
const resultData = await imageService.transform(
fileData,
{ ...options, src: originalImagePath },
buildOpts.settings.config.image.service.config
);
await fs.promises.mkdir(finalFolderURL, { recursive: true });
if (useCache) {
try {
await fs.promises.writeFile(cachedFileURL, resultData.data);
await fs.promises.copyFile(cachedFileURL, finalFileURL);
} catch (e) {
warn(
buildOpts.logging,
"astro:assets",
`An error was encountered while creating the cache directory. Proceeding without caching. Error: ${e}`
);
await fs.promises.writeFile(finalFileURL, resultData.data);
}
} else {
await fs.promises.writeFile(finalFileURL, resultData.data);
}
return {
cached: false,
weight: {
before: Math.trunc(fileData.byteLength / 1024),
after: Math.trunc(resultData.data.byteLength / 1024)
}
};
}
function getStaticImageList() {
var _a, _b;
if (!((_a = globalThis == null ? void 0 : globalThis.astroAsset) == null ? void 0 : _a.staticImages)) {
return [];
}
return (_b = globalThis.astroAsset.staticImages) == null ? void 0 : _b.entries();
}
export {
generateImage,
getStaticImageList
};

5
node_modules/astro/dist/assets/image-endpoint.d.ts generated vendored Normal file
View file

@ -0,0 +1,5 @@
import type { APIRoute } from '../@types/astro.js';
/**
* Endpoint used in SSR to serve optimized images
*/
export declare const get: APIRoute;

55
node_modules/astro/dist/assets/image-endpoint.js generated vendored Normal file
View file

@ -0,0 +1,55 @@
import mime from "mime/lite.js";
import { isRemotePath } from "../core/path.js";
import { getConfiguredImageService } from "./internal.js";
import { isLocalService } from "./services/service.js";
import { etag } from "./utils/etag.js";
import { imageServiceConfig } from "astro:assets";
async function loadRemoteImage(src) {
try {
const res = await fetch(src);
if (!res.ok) {
return void 0;
}
return Buffer.from(await res.arrayBuffer());
} catch (err) {
return void 0;
}
}
const get = async ({ request }) => {
try {
const imageService = await getConfiguredImageService();
if (!isLocalService(imageService)) {
throw new Error("Configured image service is not a local service");
}
const url = new URL(request.url);
const transform = await imageService.parseURL(url, imageServiceConfig);
if (!(transform == null ? void 0 : transform.src)) {
throw new Error("Incorrect transform returned by `parseURL`");
}
let inputBuffer = void 0;
const sourceUrl = isRemotePath(transform.src) ? new URL(transform.src) : new URL(transform.src, url.origin);
inputBuffer = await loadRemoteImage(sourceUrl);
if (!inputBuffer) {
return new Response("Not Found", { status: 404 });
}
const { data, format } = await imageService.transform(
inputBuffer,
transform,
imageServiceConfig
);
return new Response(data, {
status: 200,
headers: {
"Content-Type": mime.getType(format) ?? `image/${format}`,
"Cache-Control": "public, max-age=31536000",
ETag: etag(data.toString()),
Date: (/* @__PURE__ */ new Date()).toUTCString()
}
});
} catch (err) {
return new Response(`Server Error: ${err}`, { status: 500 });
}
};
export {
get
};

3
node_modules/astro/dist/assets/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
export { getConfiguredImageService, getImage } from './internal.js';
export { baseService, isLocalService } from './services/service.js';
export { type LocalImageProps, type RemoteImageProps } from './types.js';

9
node_modules/astro/dist/assets/index.js generated vendored Normal file
View file

@ -0,0 +1,9 @@
import { getConfiguredImageService, getImage } from "./internal.js";
import { baseService, isLocalService } from "./services/service.js";
import {} from "./types.js";
export {
baseService,
getConfiguredImageService,
getImage,
isLocalService
};

5
node_modules/astro/dist/assets/internal.d.ts generated vendored Normal file
View file

@ -0,0 +1,5 @@
import { type ImageService } from './services/service.js';
import type { GetImageResult, ImageMetadata, ImageTransform } from './types.js';
export declare function isESMImportedImage(src: ImageMetadata | string): src is ImageMetadata;
export declare function getConfiguredImageService(): Promise<ImageService>;
export declare function getImage(options: ImageTransform, serviceConfig: Record<string, any>): Promise<GetImageResult>;

48
node_modules/astro/dist/assets/internal.js generated vendored Normal file
View file

@ -0,0 +1,48 @@
import { AstroError, AstroErrorData } from "../core/errors/index.js";
import { isLocalService } from "./services/service.js";
function isESMImportedImage(src) {
return typeof src === "object";
}
async function getConfiguredImageService() {
var _a;
if (!((_a = globalThis == null ? void 0 : globalThis.astroAsset) == null ? void 0 : _a.imageService)) {
const { default: service } = await import(
// @ts-expect-error
"virtual:image-service"
).catch((e) => {
const error = new AstroError(AstroErrorData.InvalidImageService);
error.cause = e;
throw error;
});
if (!globalThis.astroAsset)
globalThis.astroAsset = {};
globalThis.astroAsset.imageService = service;
return service;
}
return globalThis.astroAsset.imageService;
}
async function getImage(options, serviceConfig) {
if (!options || typeof options !== "object") {
throw new AstroError({
...AstroErrorData.ExpectedImageOptions,
message: AstroErrorData.ExpectedImageOptions.message(JSON.stringify(options))
});
}
const service = await getConfiguredImageService();
const validatedOptions = service.validateOptions ? service.validateOptions(options, serviceConfig) : options;
let imageURL = service.getURL(validatedOptions, serviceConfig);
if (isLocalService(service) && globalThis.astroAsset.addStaticImage) {
imageURL = globalThis.astroAsset.addStaticImage(validatedOptions);
}
return {
rawOptions: options,
options: validatedOptions,
src: imageURL,
attributes: service.getHTMLAttributes !== void 0 ? service.getHTMLAttributes(validatedOptions, serviceConfig) : {}
};
}
export {
getConfiguredImageService,
getImage,
isESMImportedImage
};

82
node_modules/astro/dist/assets/services/service.d.ts generated vendored Normal file
View file

@ -0,0 +1,82 @@
/// <reference types="node" />
import type { ImageOutputFormat, ImageTransform } from '../types.js';
export type ImageService = LocalImageService | ExternalImageService;
export declare function isLocalService(service: ImageService | undefined): service is LocalImageService;
export declare function parseQuality(quality: string): string | number;
interface SharedServiceProps {
/**
* Return the URL to the endpoint or URL your images are generated from.
*
* For a local service, your service should expose an endpoint handling the image requests, or use Astro's at `/_image`.
*
* For external services, this should point to the URL your images are coming from, for instance, `/_vercel/image`
*
*/
getURL: (options: ImageTransform, serviceConfig: Record<string, any>) => string;
/**
* Return any additional HTML attributes separate from `src` that your service requires to show the image properly.
*
* For example, you might want to return the `width` and `height` to avoid CLS, or a particular `class` or `style`.
* In most cases, you'll want to return directly what your user supplied you, minus the attributes that were used to generate the image.
*/
getHTMLAttributes?: (options: ImageTransform, serviceConfig: Record<string, any>) => Record<string, any>;
/**
* Validate and return the options passed by the user.
*
* This method is useful to present errors to users who have entered invalid options.
* For instance, if they are missing a required property or have entered an invalid image format.
*
* This method should returns options, and can be used to set defaults (ex: a default output format to be used if the user didn't specify one.)
*/
validateOptions?: (options: ImageTransform, serviceConfig: Record<string, any>) => ImageTransform;
}
export type ExternalImageService = SharedServiceProps;
export type LocalImageTransform = {
src: string;
[key: string]: any;
};
export interface LocalImageService extends SharedServiceProps {
/**
* Parse the requested parameters passed in the URL from `getURL` back into an object to be used later by `transform`
*
* In most cases, this will get query parameters using, for example, `params.get('width')` and return those.
*/
parseURL: (url: URL, serviceConfig: Record<string, any>) => LocalImageTransform | undefined;
/**
* Performs the image transformations on the input image and returns both the binary data and
* final image format of the optimized image.
*/
transform: (inputBuffer: Buffer, transform: LocalImageTransform, serviceConfig: Record<string, any>) => Promise<{
data: Buffer;
format: ImageOutputFormat;
}>;
}
export type BaseServiceTransform = {
src: string;
width?: number;
height?: number;
format: string;
quality?: string | null;
};
/**
* Basic local service using the included `_image` endpoint.
* This service intentionally does not implement `transform`.
*
* Example usage:
* ```ts
* const service = {
* getURL: baseService.getURL,
* parseURL: baseService.parseURL,
* getHTMLAttributes: baseService.getHTMLAttributes,
* async transform(inputBuffer, transformOptions) {...}
* }
* ```
*
* This service adhere to the included services limitations:
* - Remote images are passed as is.
* - Only a limited amount of formats are supported.
* - For remote images, `width` and `height` are always required.
*
*/
export declare const baseService: Omit<LocalImageService, 'transform'>;
export {};

121
node_modules/astro/dist/assets/services/service.js generated vendored Normal file
View file

@ -0,0 +1,121 @@
import { AstroError, AstroErrorData } from "../../core/errors/index.js";
import { joinPaths } from "../../core/path.js";
import { VALID_SUPPORTED_FORMATS } from "../consts.js";
import { isESMImportedImage } from "../internal.js";
function isLocalService(service) {
if (!service) {
return false;
}
return "transform" in service;
}
function parseQuality(quality) {
let result = parseInt(quality);
if (Number.isNaN(result)) {
return quality;
}
return result;
}
const baseService = {
validateOptions(options) {
if (!options.src || typeof options.src !== "string" && typeof options.src !== "object") {
throw new AstroError({
...AstroErrorData.ExpectedImage,
message: AstroErrorData.ExpectedImage.message(JSON.stringify(options.src))
});
}
if (!isESMImportedImage(options.src)) {
if (options.src.startsWith("/@fs/")) {
throw new AstroError({
...AstroErrorData.LocalImageUsedWrongly,
message: AstroErrorData.LocalImageUsedWrongly.message(options.src)
});
}
let missingDimension;
if (!options.width && !options.height) {
missingDimension = "both";
} else if (!options.width && options.height) {
missingDimension = "width";
} else if (options.width && !options.height) {
missingDimension = "height";
}
if (missingDimension) {
throw new AstroError({
...AstroErrorData.MissingImageDimension,
message: AstroErrorData.MissingImageDimension.message(missingDimension, options.src)
});
}
} else {
if (!VALID_SUPPORTED_FORMATS.includes(options.src.format)) {
throw new AstroError({
...AstroErrorData.UnsupportedImageFormat,
message: AstroErrorData.UnsupportedImageFormat.message(
options.src.format,
options.src.src,
VALID_SUPPORTED_FORMATS
)
});
}
if (options.src.format === "svg") {
options.format = "svg";
}
}
if (!options.format) {
options.format = "webp";
}
return options;
},
getHTMLAttributes(options) {
let targetWidth = options.width;
let targetHeight = options.height;
if (isESMImportedImage(options.src)) {
const aspectRatio = options.src.width / options.src.height;
if (targetHeight && !targetWidth) {
targetWidth = Math.round(targetHeight * aspectRatio);
} else if (targetWidth && !targetHeight) {
targetHeight = Math.round(targetWidth / aspectRatio);
} else if (!targetWidth && !targetHeight) {
targetWidth = options.src.width;
targetHeight = options.src.height;
}
}
const { src, width, height, format, quality, ...attributes } = options;
return {
...attributes,
width: targetWidth,
height: targetHeight,
loading: attributes.loading ?? "lazy",
decoding: attributes.decoding ?? "async"
};
},
getURL(options) {
if (!isESMImportedImage(options.src)) {
return options.src;
}
const searchParams = new URLSearchParams();
searchParams.append("href", options.src.src);
options.width && searchParams.append("w", options.width.toString());
options.height && searchParams.append("h", options.height.toString());
options.quality && searchParams.append("q", options.quality.toString());
options.format && searchParams.append("f", options.format);
return joinPaths(import.meta.env.BASE_URL, "/_image?") + searchParams;
},
parseURL(url) {
const params = url.searchParams;
if (!params.has("href")) {
return void 0;
}
const transform = {
src: params.get("href"),
width: params.has("w") ? parseInt(params.get("w")) : void 0,
height: params.has("h") ? parseInt(params.get("h")) : void 0,
format: params.get("f"),
quality: params.get("q")
};
return transform;
}
};
export {
baseService,
isLocalService,
parseQuality
};

3
node_modules/astro/dist/assets/services/sharp.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
import { type LocalImageService } from './service.js';
declare const sharpService: LocalImageService;
export default sharpService;

61
node_modules/astro/dist/assets/services/sharp.js generated vendored Normal file
View file

@ -0,0 +1,61 @@
import {
baseService,
parseQuality
} from "./service.js";
let sharp;
const qualityTable = {
low: 25,
mid: 50,
high: 80,
max: 100
};
async function loadSharp() {
let sharpImport;
try {
sharpImport = (await import("sharp")).default;
} catch (e) {
throw new Error("Could not find Sharp. Please install Sharp manually into your project.");
}
return sharpImport;
}
const sharpService = {
validateOptions: baseService.validateOptions,
getURL: baseService.getURL,
parseURL: baseService.parseURL,
getHTMLAttributes: baseService.getHTMLAttributes,
async transform(inputBuffer, transformOptions) {
if (!sharp)
sharp = await loadSharp();
const transform = transformOptions;
if (transform.format === "svg")
return { data: inputBuffer, format: "svg" };
let result = sharp(inputBuffer, { failOnError: false, pages: -1 });
result.rotate();
if (transform.height && !transform.width) {
result.resize({ height: transform.height });
} else if (transform.width) {
result.resize({ width: transform.width });
}
if (transform.format) {
let quality = void 0;
if (transform.quality) {
const parsedQuality = parseQuality(transform.quality);
if (typeof parsedQuality === "number") {
quality = parsedQuality;
} else {
quality = transform.quality in qualityTable ? qualityTable[transform.quality] : void 0;
}
}
result.toFormat(transform.format, { quality });
}
const { data, info } = await result.toBuffer({ resolveWithObject: true });
return {
data,
format: info.format
};
}
};
var sharp_default = sharpService;
export {
sharp_default as default
};

3
node_modules/astro/dist/assets/services/squoosh.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
import { type LocalImageService } from './service.js';
declare const service: LocalImageService;
export default service;

84
node_modules/astro/dist/assets/services/squoosh.js generated vendored Normal file
View file

@ -0,0 +1,84 @@
import { imageMetadata } from "../utils/metadata.js";
import {
baseService,
parseQuality
} from "./service.js";
import { processBuffer } from "./vendor/squoosh/image-pool.js";
const baseQuality = { low: 25, mid: 50, high: 80, max: 100 };
const qualityTable = {
avif: {
// Squoosh's AVIF encoder has a bit of a weird behavior where `62` is technically the maximum, and anything over is overkill
max: 62,
high: 45,
mid: 35,
low: 20
},
jpeg: baseQuality,
jpg: baseQuality,
webp: baseQuality
// Squoosh's PNG encoder does not support a quality setting, so we can skip that here
};
async function getRotationForEXIF(transform, inputBuffer) {
const filePath = transform.src.slice("/@fs".length);
const filePathURL = new URL("." + filePath, "file:");
const meta = await imageMetadata(filePathURL, inputBuffer);
if (!meta)
return void 0;
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 };
}
}
const service = {
validateOptions: baseService.validateOptions,
getURL: baseService.getURL,
parseURL: baseService.parseURL,
getHTMLAttributes: baseService.getHTMLAttributes,
async transform(inputBuffer, transformOptions) {
const transform = transformOptions;
let format = transform.format;
if (format === "svg")
return { data: inputBuffer, format: "svg" };
const operations = [];
const rotation = await getRotationForEXIF(transform, inputBuffer);
if (rotation) {
operations.push(rotation);
}
if (transform.height && !transform.width) {
operations.push({
type: "resize",
height: transform.height
});
} else if (transform.width) {
operations.push({
type: "resize",
width: transform.width
});
}
let quality = void 0;
if (transform.quality) {
const parsedQuality = parseQuality(transform.quality);
if (typeof parsedQuality === "number") {
quality = parsedQuality;
} else {
quality = transform.quality in qualityTable[format] ? qualityTable[format][transform.quality] : void 0;
}
}
const data = await processBuffer(inputBuffer, operations, format, quality);
return {
data: Buffer.from(data),
format
};
}
};
var squoosh_default = service;
export {
squoosh_default as default
};

View file

@ -0,0 +1,11 @@
var AVIFTune = /* @__PURE__ */ ((AVIFTune2) => {
AVIFTune2[AVIFTune2["auto"] = 0] = "auto";
AVIFTune2[AVIFTune2["psnr"] = 1] = "psnr";
AVIFTune2[AVIFTune2["ssim"] = 2] = "ssim";
return AVIFTune2;
})(AVIFTune || {});
var avif_enc_d_default = moduleFactory;
export {
AVIFTune,
avif_enc_d_default as default
};

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -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 {};

View file

@ -0,0 +1,283 @@
import { instantiateEmscriptenWasm } from "./emscripten-utils.js";
import mozDec from "./mozjpeg/mozjpeg_node_dec.js";
import mozDecWasm from "./mozjpeg/mozjpeg_node_dec.wasm.js";
import mozEnc from "./mozjpeg/mozjpeg_node_enc.js";
import mozEncWasm from "./mozjpeg/mozjpeg_node_enc.wasm.js";
import webpDec from "./webp/webp_node_dec.js";
import webpDecWasm from "./webp/webp_node_dec.wasm.js";
import webpEnc from "./webp/webp_node_enc.js";
import webpEncWasm from "./webp/webp_node_enc.wasm.js";
import avifDec from "./avif/avif_node_dec.js";
import avifDecWasm from "./avif/avif_node_dec.wasm.js";
import avifEnc from "./avif/avif_node_enc.js";
import avifEncWasm from "./avif/avif_node_enc.wasm.js";
import * as pngEncDec from "./png/squoosh_png.js";
import pngEncDecWasm from "./png/squoosh_png_bg.wasm.js";
const pngEncDecInit = () => pngEncDec.default(pngEncDecWasm);
import * as oxipng from "./png/squoosh_oxipng.js";
import oxipngWasm from "./png/squoosh_oxipng_bg.wasm.js";
const oxipngInit = () => oxipng.default(oxipngWasm);
import * as resize from "./resize/squoosh_resize.js";
import resizeWasm from "./resize/squoosh_resize_bg.wasm.js";
const resizeInit = () => resize.default(resizeWasm);
import rotateWasm from "./rotate/rotate.wasm.js";
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(rotateWasm)).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),
enc: () => instantiateEmscriptenWasm(
mozEnc,
mozEncWasm
),
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),
enc: () => instantiateEmscriptenWasm(
webpEnc,
webpEncWasm
),
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),
enc: async () => {
return instantiateEmscriptenWasm(
avifEnc,
avifEncWasm
);
},
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
};

View file

@ -0,0 +1,9 @@
export declare function pathify(path: string): string;
export declare function instantiateEmscriptenWasm<T extends EmscriptenWasm.Module>(factory: EmscriptenWasm.ModuleFactory<T>, bytes: Uint8Array): 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 __filename 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;

View file

@ -0,0 +1,31 @@
import { fileURLToPath, pathToFileURL } from "node:url";
function pathify(path) {
if (path.startsWith("file://")) {
path = fileURLToPath(path);
}
return path;
}
function instantiateEmscriptenWasm(factory, bytes) {
return factory({
// @ts-expect-error This is a valid Emscripten option, but the type definitions don't know about it
wasmBinary: bytes,
locateFile(file) {
return file;
}
});
}
function dirname(url) {
return url.substring(0, url.lastIndexOf("/"));
}
function getModuleURL(url) {
if (!url) {
return pathToFileURL(__filename).toString();
}
return url;
}
export {
dirname,
getModuleURL,
instantiateEmscriptenWasm,
pathify
};

View file

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

View file

@ -0,0 +1,96 @@
import { cpus } from "node:os";
import { fileURLToPath } from "node:url";
import { isMainThread } from "node:worker_threads";
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(
// There will be at most 7 workers needed since each worker will take
// at least 1 operation type.
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
};

View file

@ -0,0 +1,14 @@
/// <reference types="node" />
import type { ImageOutputFormat } 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: ImageOutputFormat, quality?: number): Promise<Uint8Array>;
export {};

View file

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

View file

@ -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);
}

View file

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

View file

@ -0,0 +1,22 @@
/// <reference types="node" />
import ImageData from './image_data.js';
export declare function decodeBuffer(_buffer: Buffer | Uint8Array): Promise<ImageData>;
export declare function rotate(image: ImageData, numRotations: number): Promise<ImageData>;
type ResizeOpts = {
image: ImageData;
} & {
width?: number;
height?: number;
};
export declare function resize({ image, width, height }: ResizeOpts): Promise<ImageData>;
export declare function encodeJpeg(image: ImageData, opts: {
quality?: number;
}): Promise<Uint8Array>;
export declare function encodeWebp(image: ImageData, opts: {
quality?: number;
}): Promise<Uint8Array>;
export declare function encodeAvif(image: ImageData, opts: {
quality?: number;
}): Promise<Uint8Array>;
export declare function encodePng(image: ImageData): Promise<Uint8Array>;
export {};

View file

@ -0,0 +1,112 @@
import { codecs as supportedFormats, preprocessors } from "./codecs.js";
import ImageData from "./image_data.js";
const DELAY_MS = 1e3;
let _promise;
function delayOnce(ms) {
if (!_promise) {
_promise = new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
return _promise;
}
function maybeDelay() {
const isAppleM1 = process.arch === "arm64" && process.platform === "darwin";
if (isAppleM1) {
return delayOnce(DELAY_MS);
}
return Promise.resolve();
}
async function decodeBuffer(_buffer) {
var _a;
const buffer = Buffer.from(_buffer);
const firstChunk = buffer.slice(0, 16);
const firstChunkString = Array.from(firstChunk).map((v) => String.fromCodePoint(v)).join("");
if (firstChunkString.includes("GIF")) {
throw Error(`GIF images are not supported, please install the @astrojs/image/sharp plugin`);
}
const key = (_a = Object.entries(supportedFormats).find(
([, { detectors }]) => detectors.some((detector) => detector.exec(firstChunkString))
)) == null ? void 0 : _a[0];
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));
return rgba;
}
async function rotate(image, numRotations) {
image = ImageData.from(image);
const m = await preprocessors["rotate"].instantiate();
return await m(image.data, image.width, image.height, { numRotations });
}
async function resize({ image, width, height }) {
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
});
}
async function encodeJpeg(image, opts) {
image = ImageData.from(image);
const e = supportedFormats["mozjpeg"];
const m = await e.enc();
await maybeDelay();
const quality = opts.quality || e.defaultEncoderOptions.quality;
const r = await m.encode(image.data, image.width, image.height, {
...e.defaultEncoderOptions,
quality
});
return r;
}
async function encodeWebp(image, opts) {
image = ImageData.from(image);
const e = supportedFormats["webp"];
const m = await e.enc();
await maybeDelay();
const quality = opts.quality || e.defaultEncoderOptions.quality;
const r = await m.encode(image.data, image.width, image.height, {
...e.defaultEncoderOptions,
quality
});
return r;
}
async function encodeAvif(image, opts) {
image = ImageData.from(image);
const e = supportedFormats["avif"];
const m = await e.enc();
await maybeDelay();
const val = e.autoOptimize.min;
const quality = opts.quality || 75;
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 r;
}
async function encodePng(image) {
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 r;
}
export {
decodeBuffer,
encodeAvif,
encodeJpeg,
encodePng,
encodeWebp,
resize,
rotate
};

View file

@ -0,0 +1,11 @@
var MozJpegColorSpace = /* @__PURE__ */ ((MozJpegColorSpace2) => {
MozJpegColorSpace2[MozJpegColorSpace2["GRAYSCALE"] = 1] = "GRAYSCALE";
MozJpegColorSpace2[MozJpegColorSpace2["RGB"] = 2] = "RGB";
MozJpegColorSpace2[MozJpegColorSpace2["YCbCr"] = 3] = "YCbCr";
return MozJpegColorSpace2;
})(MozJpegColorSpace || {});
var mozjpeg_enc_d_default = moduleFactory;
export {
MozJpegColorSpace,
mozjpeg_enc_d_default as default
};

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,10 @@
/**
* @param {Uint8Array} data
* @param {number} level
* @param {boolean} interlace
* @returns {Uint8Array}
*/
export declare function optimise(data: any, level: any, interlace: any): any;
declare function init(input: any): Promise<WebAssembly.Exports>;
export default init;
export declare function cleanup(): void;

View file

@ -0,0 +1,89 @@
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);
}
function optimise(data, level, interlace) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.optimise(retptr, ptr0, len0, level, interlace);
const r0 = getInt32Memory0()[retptr / 4 + 0];
const r1 = getInt32Memory0()[retptr / 4 + 1];
const 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;
}
var squoosh_oxipng_default = init;
function cleanup() {
wasm = null;
cachegetUint8Memory0 = null;
cachegetInt32Memory0 = null;
}
export {
cleanup,
squoosh_oxipng_default as default,
optimise
};

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,15 @@
/**
* @param {Uint8Array} data
* @param {number} width
* @param {number} height
* @returns {Uint8Array}
*/
export declare function encode(data: any, width: any, height: any): any;
/**
* @param {Uint8Array} data
* @returns {ImageData}
*/
export declare function decode(data: any): any;
declare function init(input: any): Promise<WebAssembly.Exports>;
export default init;
export declare function cleanup(): void;

View file

@ -0,0 +1,138 @@
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(void 0);
heap.push(void 0, 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);
}
function encode(data, width, height) {
try {
const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.encode(retptr, ptr0, len0, width, height);
const r0 = getInt32Memory0()[retptr / 4 + 0];
const r1 = getInt32Memory0()[retptr / 4 + 1];
const 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;
}
function decode(data) {
const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
const 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) {
const v0 = getClampedArrayU8FromWasm0(arg0, arg1).slice();
wasm.__wbindgen_free(arg0, arg1 * 1);
const 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;
}
var squoosh_png_default = init;
function cleanup() {
wasm = null;
cachegetUint8ClampedMemory0 = null;
cachegetUint8Memory0 = null;
cachegetInt32Memory0 = null;
}
export {
cleanup,
decode,
squoosh_png_default as default,
encode
};

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,15 @@
/**
* @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 declare function resize(input_image: any, input_width: any, input_height: any, output_width: any, output_height: any, typ_idx: any, premultiply: any, color_space_conversion: any): any;
declare function init(input: any): Promise<WebAssembly.Exports>;
export default init;
export declare function cleanup(): void;

View file

@ -0,0 +1,95 @@
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);
}
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);
const ptr0 = passArray8ToWasm0(input_image, wasm.__wbindgen_malloc);
const len0 = WASM_VECTOR_LEN;
wasm.resize(
retptr,
ptr0,
len0,
input_width,
input_height,
output_width,
output_height,
typ_idx,
premultiply,
color_space_conversion
);
const r0 = getInt32Memory0()[retptr / 4 + 0];
const r1 = getInt32Memory0()[retptr / 4 + 1];
const 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;
}
var squoosh_resize_default = init;
function cleanup() {
wasm = null;
cachegetUint8Memory0 = null;
cachegetInt32Memory0 = null;
}
export {
cleanup,
squoosh_resize_default as default,
resize
};

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

View file

@ -0,0 +1,4 @@
var rotate_wasm_default = Buffer.from("AGFzbQEAAAABDAJgAn9/AGADf39/AAMGBQAAAAABBQMBABAGEQJ/AEGAgMAAC38AQYCAwAALBy4EBm1lbW9yeQIABnJvdGF0ZQAECl9fZGF0YV9lbmQDAAtfX2hlYXBfYmFzZQMBCpsJBUkBAX8gACABbCIAQf////8DcSICBEBBCCEBIABBAnRBCGohAANAIAAgASgCADYCACABQQRqIQEgAEEEaiEAIAJBf2oiAg0ACwsLzQMBFH8gAUECdCERIAAgAWwiDEECdEEEaiESA0ACQAJAAkACQCAEQQFxRQRAIAMgAU8NAiADQQFqIQgMAQsgA0EPaiICIANJIggNASACIAFJIgVFDQEgASADQRBqIAgbIAEgBRshCCACIQMLIAEgA0EQaiICIAIgAUsbIQ0gA0F/cyETIBIgA0ECdGshFEEAIQVBACEOA0ACQAJAIA5FBEAgBSAASQ0BQQEhBAwGCyAAIAVBEGogBUEPaiICIAVJIgcbIAAgAiAASRshBUEBIQQgByACIABPcg0FDAELIAUiAkEBaiEFC0EBIQ4gAyANTw0AIAAgAkEQaiIPIAAgD0kbQQJ0IAJBAnRrIRUgEyABIAJsaiEHIBQgASACQQFqbEECdGohCSADIQoDQCAAIApsIgYgAmoiBEEQaiAAIAZqIA8gAEkbIgYgBEkgDCAGSXINAyAEIAZHBEAgBEECdEEIaiELIBUhBiAHIRAgCSEEA0AgDCABIBBqIhBNDQUgBCALKAIANgIAIAQgEWohBCALQQRqIQsgBkF8aiIGDQALCyAHQX9qIQcgCUF8aiEJIA0gCkEBaiIKRw0ACwwACwALDwsACyAIIQMMAAsAC1MBAX8CQCAAIAFsQQJ0IgJBCGoiAEEIRg0AIAAgAmpBfGohAEEAIQEDQCABIAJGDQEgACABQQhqKAIANgIAIABBfGohACACIAFBBGoiAUcNAAsLC9oDARN/IABBf2ohEEEAIAFBAnRrIREgACABbCIMQQJ0QQhqIRIDQAJAAkACQAJAIARBAXFFBEAgAyABTw0CIANBAWohCQwBCyADQQ9qIgIgA0kiCQ0BIAIgAUkiBUUNASABIANBEGogCRsgASAFGyEJIAIhAwsgASADQRBqIgIgAiABSxshDSASIANBAnRqIRNBACEFQQAhBgNAAkACQCAGQQFxRQRAIAUgAEkNAUEBIQQMBgsgACAFQRBqIAVBD2oiAiAFSSIIGyAAIAIgAEkbIQVBASEEIAggAiAAT3INBQwBCyAFIgJBAWohBQtBASEGIAMgDU8NACAAIAJBEGoiDiAAIA5JG0ECdCACQQJ0ayEUIAMgASAAIAJrbGohCCATIAEgECACa2xBAnRqIQogAyELA0AgACALbCIHIAJqIgRBEGogACAHaiAOIABJGyIHIARJIAwgB0lyDQMgBCAHRwRAIARBAnRBCGohBiAUIQcgCCEPIAohBANAIAwgDyABayIPTQ0FIAQgBigCADYCACAEIBFqIQQgBkEEaiEGIAdBfGoiBw0ACwtBASEGIAhBAWohCCAKQQRqIQogDSALQQFqIgtHDQALDAALAAsPCwALIAkhAwwACwALUAACQAJAAkACQCACQbMBTARAIAJFDQIgAkHaAEcNASAAIAEQAQ8LIAJBtAFGDQIgAkGOAkYNAwsACyAAIAEQAA8LIAAgARACDwsgACABEAMLAE0JcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AQVydXN0Yx0xLjQ3LjAgKDE4YmY2YjRmMCAyMDIwLTEwLTA3KQ==", "base64");
export {
rotate_wasm_default as default
};

View file

@ -0,0 +1 @@
export default function execOnce<T extends (...args: any[]) => ReturnType<T>>(fn: T): T;

View file

@ -0,0 +1,14 @@
function execOnce(fn) {
let used = false;
let result;
return (...args) => {
if (!used) {
used = true;
result = fn(...args);
}
return result;
};
}
export {
execOnce as default
};

View file

@ -0,0 +1,22 @@
/// <reference types="node" />
import { Worker } from 'worker_threads';
interface Job<I> {
msg: I;
resolve: (result: any) => void;
reject: (reason: any) => void;
}
export default class WorkerPool<I, O> {
numWorkers: number;
jobQueue: TransformStream<Job<I>, Job<I>>;
workerQueue: TransformStream<Worker, Worker>;
done: Promise<void>;
constructor(numWorkers: number, workerFile: string);
_readLoop(): Promise<void>;
_nextWorker(): Promise<Worker>;
_terminateAll(): Promise<void>;
join(): Promise<void>;
dispatchJob(msg: I): Promise<O>;
private jobPromise;
static useThisThreadAsWorker<I, O>(cb: (msg: I) => O): void;
}
export {};

View file

@ -0,0 +1,95 @@
import { parentPort, Worker } from "worker_threads";
function uuid() {
return Array.from({ length: 16 }, () => Math.floor(Math.random() * 256).toString(16)).join("");
}
class WorkerPool {
constructor(numWorkers, workerFile) {
this.numWorkers = numWorkers;
this.jobQueue = new TransformStream();
this.workerQueue = new TransformStream();
const writer = this.workerQueue.writable.getWriter();
for (let i = 0; i < numWorkers; i++) {
writer.write(new Worker(workerFile));
}
writer.releaseLock();
this.done = this._readLoop();
}
async _readLoop() {
const reader = this.jobQueue.readable.getReader();
while (true) {
const { value, done } = await reader.read();
if (done) {
await this._terminateAll();
return;
}
if (!value) {
throw new Error("Reader did not return any value");
}
const { msg, resolve, reject } = value;
const worker = await this._nextWorker();
this.jobPromise(worker, msg).then((result) => resolve(result)).catch((reason) => reject(reason)).finally(() => {
const writer = this.workerQueue.writable.getWriter();
writer.write(worker);
writer.releaseLock();
});
}
}
async _nextWorker() {
const reader = this.workerQueue.readable.getReader();
const { value } = await reader.read();
reader.releaseLock();
if (!value) {
throw new Error("No worker left");
}
return value;
}
async _terminateAll() {
for (let n = 0; n < this.numWorkers; n++) {
const worker = await this._nextWorker();
worker.terminate();
}
this.workerQueue.writable.close();
}
async join() {
this.jobQueue.writable.getWriter().close();
await this.done;
}
dispatchJob(msg) {
return new Promise((resolve, reject) => {
const writer = this.jobQueue.writable.getWriter();
writer.write({ msg, resolve, reject });
writer.releaseLock();
});
}
jobPromise(worker, msg) {
return new Promise((resolve, reject) => {
const id = uuid();
worker.postMessage({ msg, id });
worker.on("message", function f({ error, result, id: rid }) {
if (rid !== id) {
return;
}
if (error) {
reject(error);
return;
}
worker.off("message", f);
resolve(result);
});
});
}
static useThisThreadAsWorker(cb) {
parentPort.on("message", async (data) => {
const { msg, id } = data;
try {
const result = await cb(msg);
parentPort.postMessage({ result, id });
} catch (e) {
parentPort.postMessage({ error: e.message, id });
}
});
}
}
export {
WorkerPool as default
};

View file

@ -0,0 +1,4 @@
var webp_enc_d_default = moduleFactory;
export {
webp_enc_d_default as default
};

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

View file

@ -0,0 +1,2 @@
declare var Module: (Module: any) => any;
export default Module;

File diff suppressed because it is too large Load diff

Binary file not shown.

View file

@ -0,0 +1,3 @@
/// <reference types="node" />
declare const _default: Buffer;
export default _default;

File diff suppressed because one or more lines are too long

129
node_modules/astro/dist/assets/types.d.ts generated vendored Normal file
View file

@ -0,0 +1,129 @@
import type { VALID_INPUT_FORMATS, VALID_OUTPUT_FORMATS } from './consts.js';
import type { ImageService } from './services/service.js';
export type ImageQualityPreset = 'low' | 'mid' | 'high' | 'max' | (string & {});
export type ImageQuality = ImageQualityPreset | number;
export type ImageInputFormat = (typeof VALID_INPUT_FORMATS)[number];
export type ImageOutputFormat = (typeof VALID_OUTPUT_FORMATS)[number] | (string & {});
declare global {
var astroAsset: {
imageService?: ImageService;
addStaticImage?: ((options: ImageTransform) => string) | undefined;
staticImages?: Map<string, {
path: string;
options: ImageTransform;
}>;
};
}
/**
* Type returned by ESM imports of images and direct calls to imageMetadata
*/
export interface ImageMetadata {
src: string;
width: number;
height: number;
format: ImageInputFormat;
orientation?: number;
}
/**
* Options accepted by the image transformation service.
*/
export type ImageTransform = {
src: ImageMetadata | string;
width?: number | undefined;
height?: number | undefined;
quality?: ImageQuality | undefined;
format?: ImageOutputFormat | undefined;
[key: string]: any;
};
export interface GetImageResult {
rawOptions: ImageTransform;
options: ImageTransform;
src: string;
attributes: Record<string, any>;
}
type WithRequired<T, K extends keyof T> = T & {
[P in K]-?: T[P];
};
type ImageSharedProps<T> = T & {
/**
* Width of the image, the value of this property will be used to assign the `width` property on the final `img` element.
*
* For local images, this value will additionally be used to resize the image to the desired width, taking into account the original aspect ratio of the image.
*
* **Example**:
* ```astro
* <Image src={...} width={300} alt="..." />
* ```
* **Result**:
* ```html
* <img src="..." width="300" height="..." alt="..." />
* ```
*/
width?: number | `${number}`;
/**
* Height of the image, the value of this property will be used to assign the `height` property on the final `img` element.
*
* For local images, if `width` is not present, this value will additionally be used to resize the image to the desired height, taking into account the original aspect ratio of the image.
*
* **Example**:
* ```astro
* <Image src={...} height={300} alt="..." />
* ```
* **Result**:
* ```html
* <img src="..." height="300" width="..." alt="..." />
* ```
*/
height?: number | `${number}`;
};
export type LocalImageProps<T> = ImageSharedProps<T> & {
/**
* A reference to a local image imported through an ESM import.
*
* **Example**:
* ```js
* import myImage from "~/assets/my_image.png";
* ```
* And then refer to the image, like so:
* ```astro
* <Image src={myImage} alt="..."></Image>
* ```
*/
src: ImageMetadata;
/**
* Desired output format for the image. Defaults to `webp`.
*
* **Example**:
* ```astro
* <Image src={...} format="avif" alt="..." />
* ```
*/
format?: ImageOutputFormat;
/**
* Desired quality for the image. Value can either be a preset such as `low` or `high`, or a numeric value from 0 to 100.
*
* The perceptual quality of the output image is service-specific.
* For instance, a certain service might decide that `high` results in a very beautiful image, but another could choose for it to be at best passable.
*
* **Example**:
* ```astro
* <Image src={...} quality='high' alt="..." />
* <Image src={...} quality={300} alt="..." />
* ```
*/
quality?: ImageQuality;
};
export type RemoteImageProps<T> = WithRequired<ImageSharedProps<T>, 'width' | 'height'> & {
/**
* URL of a remote image. Can start with a protocol (ex: `https://`) or alternatively `/`, or `Astro.url`, for images in the `public` folder
*
* Remote images are not optimized, and require both `width` and `height` to be set.
*
* **Example**:
* ```
* <Image src="https://example.com/image.png" width={450} height={300} alt="..." />
* ```
*/
src: string;
};
export {};

0
node_modules/astro/dist/assets/types.js generated vendored Normal file
View file

2
node_modules/astro/dist/assets/utils/emitAsset.d.ts generated vendored Normal file
View file

@ -0,0 +1,2 @@
import type { ImageMetadata } from '../types.js';
export declare function emitESMImage(id: string | undefined, watchMode: boolean, fileEmitter: any): Promise<ImageMetadata | undefined>;

37
node_modules/astro/dist/assets/utils/emitAsset.js generated vendored Normal file
View file

@ -0,0 +1,37 @@
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";
import { prependForwardSlash, slash } from "../../core/path.js";
import { imageMetadata } from "./metadata.js";
async function emitESMImage(id, watchMode, fileEmitter) {
if (!id) {
return void 0;
}
const url = pathToFileURL(id);
const meta = await imageMetadata(url);
if (!meta) {
return void 0;
}
if (!watchMode) {
const pathname = decodeURI(url.pathname);
const filename = path.basename(pathname, path.extname(pathname) + `.${meta.format}`);
const handle = fileEmitter({
name: filename,
source: await fs.promises.readFile(url),
type: "asset"
});
meta.src = `__ASTRO_ASSET_IMAGE__${handle}__`;
} else {
url.searchParams.append("origWidth", meta.width.toString());
url.searchParams.append("origHeight", meta.height.toString());
url.searchParams.append("origFormat", meta.format);
meta.src = `/@fs` + prependForwardSlash(fileURLToNormalizedPath(url));
}
return meta;
}
function fileURLToNormalizedPath(filePath) {
return slash(fileURLToPath(filePath) + filePath.search).replace(/\\/g, "/");
}
export {
emitESMImage
};

12
node_modules/astro/dist/assets/utils/etag.d.ts generated vendored Normal file
View file

@ -0,0 +1,12 @@
/**
* FNV-1a Hash implementation
* @author Travis Webb (tjwebb) <me@traviswebb.com>
*
* Ported from https://github.com/tjwebb/fnv-plus/blob/master/index.js
* License https://github.com/tjwebb/fnv-plus#license
*
* Simplified, optimized and add modified for 52 bit, which provides a larger hash space
* and still making use of Javascript's 53-bit integer space.
*/
export declare const fnv1a52: (str: string) => number;
export declare const etag: (payload: string, weak?: boolean) => string;

28
node_modules/astro/dist/assets/utils/etag.js generated vendored Normal file
View file

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

1
node_modules/astro/dist/assets/utils/index.d.ts generated vendored Normal file
View file

@ -0,0 +1 @@
export { emitESMImage } from './emitAsset.js';

4
node_modules/astro/dist/assets/utils/index.js generated vendored Normal file
View file

@ -0,0 +1,4 @@
import { emitESMImage } from "./emitAsset.js";
export {
emitESMImage
};

3
node_modules/astro/dist/assets/utils/metadata.d.ts generated vendored Normal file
View file

@ -0,0 +1,3 @@
/// <reference types="node" />
import type { ImageMetadata } from '../types.js';
export declare function imageMetadata(src: URL | string, data?: Buffer): Promise<ImageMetadata | undefined>;

28
node_modules/astro/dist/assets/utils/metadata.js generated vendored Normal file
View file

@ -0,0 +1,28 @@
import fs from "node:fs/promises";
import { fileURLToPath } from "node:url";
import imageSize from "../vendor/image-size/index.js";
async function imageMetadata(src, data) {
let file = data;
if (!file) {
try {
file = await fs.readFile(src);
} catch (e) {
return void 0;
}
}
const { width, height, type, orientation } = imageSize(file);
const isPortrait = (orientation || 0) >= 5;
if (!width || !height || !type) {
return void 0;
}
return {
src: fileURLToPath(src),
width: isPortrait ? height : width,
height: isPortrait ? width : height,
format: type,
orientation
};
}
export {
imageMetadata
};

View file

@ -0,0 +1,2 @@
import type { ImageMetadata } from '../types.js';
export declare function getOrigQueryParams(params: URLSearchParams): Omit<ImageMetadata, 'src'> | undefined;

Some files were not shown because too many files have changed in this diff Show more