vinext 1.3.0 → 1.3.1

package/dist/client/navigation-runtime.js

@@ -200,4 +200,4 @@ function hasAppNavigationRuntimeBootstrap() {
 	return getNavigationRuntime() !== null;
 }
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, createNavigationRuntimeRouteManifestLoader, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };
+export { NAVIGATION_RUNTIME_KEY, createNavigationRuntimeRouteManifestLoader, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, isNavigationRuntimeFunctions, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };

package/dist/client/pages-router-link-navigation.d.ts

@@ -39,4 +39,5 @@ export declare function navigatePagesRouterLinkWithFallback({ router, loadRouter
   navigation: PagesRouterLinkNavigation;
   fallback: () => void;
 }): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/client/vinext-next-data.d.ts

@@ -5,10 +5,33 @@ export type VinextLinkPrefetchRoute = {
   documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
+  /**
+   * The route's segment config rules out static generation, so Next.js
+   * renders it on every request, and its automatic prefetch never renders the
+   * page. Read at build time. Never set with Cache Components: segment config
+   * doesn't decide what renders dynamically there, so an automatic prefetch of
+   * a dynamic route without a loading boundary still renders its page
+   * (Next.js prefetches its static shell instead).
+   */
+  rendersDynamically?: true;
+  /**
+   * Intercepting pages that can render a URL of this route under a matching
+   * interception context. Next.js builds each as its own route, so its
+   * `rendersDynamically` replaces the route's own then. Set only alongside
+   * `rendersDynamically` classification.
+   */
+  intercepts?: VinextLinkPrefetchIntercept[];
   requiresDynamicNavigationRequest?: boolean;
   /** The route has dynamic params above its root layout. */
   hasRootParams?: true;
 };
+export type VinextLinkPrefetchIntercept = {
+  /** The URL pattern of the route the interception context must be on, or below. */
+  sourcePatternParts: string[];
+  /** The URL pattern the intercepting page intercepts. */
+  targetPatternParts: string[];
+  rendersDynamically?: true;
+};
 /**
  * Pages Router route pattern exposed to the client so the App Router's
  * navigation runtime can decide whether a soft-navigated URL should be
@@ -49,4 +72,5 @@ type VinextLocaleGlobalTarget = {
 export declare function extractVinextNextDataJson(html: string): string | null;
 export declare function parseVinextNextDataJson(json: string): BrowserVinextNextData;
 export declare function applyVinextLocaleGlobals(target: VinextLocaleGlobalTarget, nextData: VinextNextData): void;
-//#endregion
+//#endregion
+export {};

package/dist/client/window-next.d.ts

@@ -168,4 +168,5 @@ type WindowNext = {
  */
 export declare function installWindowNext(fields: Partial<WindowNext>): void;
 export declare function setWindowNextInternalSourcePage(sourcePage: string | null): void;
-//#endregion
+//#endregion
+export {};

package/dist/config/config-matchers.d.ts

@@ -55,7 +55,7 @@ export declare function checkHasConditions(has: HasCondition[] | undefined, miss
  */
 export type RedirectMatch = {
   destination: string;
-  permanent: boolean;
+  statusCode: number;
   destinationQuery: RedirectDestinationQueryPart[];
 };
 /**
@@ -157,6 +157,17 @@ export declare function sanitizeDestination(dest: string): string;
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/server-route-utils.ts
  */
 export declare function preserveRedirectDestinationQuery(destination: string, requestSearch: string, destinationQuery?: RedirectDestinationQueryPart[]): string;
+/**
+ * Percent-encode what a config-redirect `Location` header cannot carry.
+ *
+ * The destination template was already parsed like a URL by matchRedirect, so
+ * its literal path, hash and host are encoded as Next.js sends them. Captures
+ * and the destination query are inserted verbatim, like Next.js, so they can
+ * still hold control or non-ASCII characters. Next.js writes those raw and its
+ * Node server answers 500 for a character above U+00FF (the Headers
+ * constructor throws the same way); vinext percent-encodes them instead.
+ */
+export declare function encodeRedirectLocation(location: string): string;
 /**
  * Proxy an incoming request to an external URL and return the upstream response.
  *

package/dist/config/config-matchers.js

@@ -388,10 +388,13 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
-			localeMatch = resolveRedirectMatch(redirect, {
-				[entry.paramName]: "",
-				...conditionParams
-			});
+			localeMatch = {
+				redirect,
+				params: {
+					[entry.paramName]: "",
+					...conditionParams
+				}
+			};
 			localeMatchIndex = entry.originalIndex;
 			break;
 		}
@@ -408,10 +411,13 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 				onRuleSourceMatch?.(redirect);
 				const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 				if (!conditionParams) continue;
-				localeMatch = resolveRedirectMatch(redirect, {
-					[entry.paramName]: localePart,
-					...conditionParams
-				});
+				localeMatch = {
+					redirect,
+					params: {
+						[entry.paramName]: localePart,
+						...conditionParams
+					}
+				};
 				localeMatchIndex = entry.originalIndex;
 				break;
 			}
@@ -428,10 +434,10 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			return resolveRedirectMatch(redirect, {
 				...params,
 				...conditionParams
-			});
+			}, basePathState);
 		}
 	}
-	return localeMatch;
+	return localeMatch && resolveRedirectMatch(localeMatch.redirect, localeMatch.params, basePathState);
 }
 /**
 * Apply rewrite rules from next.config.js.
@@ -492,11 +498,83 @@ function matchesRewriteSource(pathname, rewrite, basePathState = _BASEPATH_DEFAU
 function substituteAndSanitizeDestination(destination, params, kind) {
 	return sanitizeDestination(substituteDestinationParams(destination, params, kind));
 }
-function resolveRedirectMatch(redirect, params) {
+/**
+* Prepare a redirect destination template as Next.js does before substituting
+* params. processRoutes (load-custom-routes.ts) prefixes a local destination
+* with the basePath (a bare `/` becomes the basePath, except on the
+* default-locale variant), then parseDestination (prepare-destination.ts) parses it
+* with the URL parser, its param tokens escaped so they survive. This trims
+* whitespace, resolves dot segments and backslashes, percent-encodes the path
+* and hash, punycodes the host, drops an empty query or hash, and throws (a
+* 500) on an invalid absolute URL. Captures are substituted afterwards, so the
+* parser never sees them. The query text is kept verbatim, as
+* preserveRedirectDestinationQuery emits it.
+*/
+function parseRedirectDestinationTemplate(redirect, params, { basePath, hadBasePath }) {
+	let template = redirect.destination;
+	const isLocal = template.startsWith("/");
+	if (isLocal && basePath && hadBasePath) template = template === "/" && !redirect.defaultLocaleVariant ? basePath : basePath + template;
+	template = template.replace(LOCATION_STRIPPED_RE, "");
+	let marker = "__ESC_COLON_";
+	while (template.toLowerCase().includes(marker.toLowerCase())) marker = `_${marker}`;
+	const paramValues = Object.values(params);
+	let literalColon = "__ESC_LITERAL_COLON_";
+	while (template.includes(literalColon) || paramValues.some((value) => value.includes(literalColon))) literalColon = `_${literalColon}`;
+	const keys = Object.keys(params).sort((a, b) => b.length - a.length);
+	const keyPattern = keys.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+	const escaped = keys.length === 0 ? template : template.replace(new RegExp(`\\\\.|:(${keyPattern})(?![A-Za-z0-9_])`, "gs"), (match, key) => key ? `${marker}${key}` : match);
+	const consumeEscapes = (value) => value.replace(/\\(.)/gs, (_, char) => char === ":" ? literalColon : char);
+	let url;
+	try {
+		url = isLocal ? new URL(`http://n${escaped}`) : new URL(escaped);
+	} catch {
+		return {
+			template,
+			literalColon,
+			parsed: false
+		};
+	}
+	const hash = url.hash;
+	url.search = "";
+	url.hash = "";
+	const hashIndex = template.indexOf("#");
+	const beforeHash = hashIndex === -1 ? template : template.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex);
+	let base = isLocal ? url.pathname : url.href;
+	if (!isLocal && (url.username || url.password)) {
+		const auth = url.username ? `${encodeURIComponent(url.password ? `${url.username}:${url.password}` : url.username).replace(/%3A/i, ":")}@` : "";
+		url.username = "";
+		url.password = "";
+		base = url.href.replace("//", `//${auth}`);
+	}
+	if (!isLocal && !SPECIAL_SCHEME_RE.test(url.protocol)) base = base.slice(0, base.length - url.pathname.length) + consumeEscapes(url.pathname);
+	const markerRe = new RegExp(`${marker}(${keyPattern})`, "gi");
+	const unescape = (value) => keys.length === 0 ? value : value.replace(markerRe, (_, key) => `:${keys.includes(key) ? key : keys.find((k) => k.toLowerCase() === key.toLowerCase())}`);
+	return {
+		template: `${unescape(base)}${/^\?&*$/.test(query) ? "" : query}${unescape(consumeEscapes(hash))}`,
+		literalColon,
+		parsed: true
+	};
+}
+const SPECIAL_SCHEME_RE = /^(?:https?|wss?|ftp|file):$/;
+const REDIRECT_ORIGIN_RE = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/?#]*/;
+/**
+* Next.js resolve-routes.ts runs normalizeRepeatedSlashes on the prepared
+* destination's pathname, after params are substituted: backslashes become
+* `/` and runs of slashes collapse, so a basePath-prefixed `//target`
+* becomes `/docs/target`. `destination` starts at the pathname.
+*/
+function normalizeRedirectPathnameSlashes(destination) {
+	return destination.replace(/^[^?#]*/, (pathname) => pathname.replace(/\\/g, "/").replace(/\/\/+/g, "/"));
+}
+function resolveRedirectMatch(redirect, params, basePathState) {
+	const { template: destination, literalColon, parsed } = parseRedirectDestinationTemplate(redirect, params, basePathState);
+	const origin = REDIRECT_ORIGIN_RE.exec(destination)?.[0] ?? "";
 	return {
-		destination: substituteAndSanitizeDestination(redirect.destination, params, "redirect"),
-		permanent: redirect.permanent,
-		destinationQuery: substituteRedirectDestinationQuery(redirect.destination, params)
+		destination: (!parsed ? substituteAndSanitizeDestination(destination, params, "redirect") : origin ? substituteDestinationParams(origin, params, "redirect") + normalizeRedirectPathnameSlashes(substituteDestinationParams(destination.slice(origin.length), params, "redirect")) : normalizeRedirectPathnameSlashes(substituteAndSanitizeDestination(destination, params, "redirect"))).replaceAll(literalColon, ":"),
+		statusCode: redirect.statusCode || (redirect.permanent ? 308 : 307),
+		destinationQuery: substituteRedirectDestinationQuery(destination, params)
 	};
 }
 /**
@@ -639,6 +717,22 @@ function preserveRedirectDestinationQuery(destination, requestSearch, destinatio
 	}).flat().join("&");
 	return mergedQuery === "" ? `${pathPart}${hash}` : `${pathPart}?${mergedQuery}${hash}`;
 }
+const LOCATION_STRIPPED_RE = /^[\u0000- ]+|[\u0000- ]+$|[\t\n\r]/g;
+const LOCATION_UNSAFE_RE = /[\u0000-\u0008\u000A-\u001F\u007F]|[^\u0000-\u007F]/gu;
+const LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+/**
+* Percent-encode what a config-redirect `Location` header cannot carry.
+*
+* The destination template was already parsed like a URL by matchRedirect, so
+* its literal path, hash and host are encoded as Next.js sends them. Captures
+* and the destination query are inserted verbatim, like Next.js, so they can
+* still hold control or non-ASCII characters. Next.js writes those raw and its
+* Node server answers 500 for a character above U+00FF (the Headers
+* constructor throws the same way); vinext percent-encodes them instead.
+*/
+function encodeRedirectLocation(location) {
+	return location.replace(LONE_SURROGATE_RE, "�").replace(LOCATION_UNSAFE_RE, encodeURIComponent);
+}
 function parseExternalRewriteUrl(externalUrl) {
 	try {
 		return new URL(externalUrl);
@@ -901,7 +995,8 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 			const localizedSource = `/${locale}${suffixFor(r.source)}`;
 			out.push({
 				...r,
-				source: localizedSource
+				source: localizedSource,
+				...type === "redirect" ? { defaultLocaleVariant: true } : {}
 			});
 		}
 		const internalSource = `${internalLocale}${suffixFor(r.source)}`;
@@ -918,4 +1013,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, configSourceError, isExternalUrl, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, configSourceError, encodeRedirectLocation, isExternalUrl, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination };

package/dist/config/dotenv.d.ts

@@ -47,4 +47,5 @@ export declare function getDotenvFiles(mode: string): string[];
  * commands (which don't go through Vite at all), this is the only loading.
  */
 export declare function loadDotenv({ root, mode, processEnv }: LoadDotenvOptions): LoadDotenvResult;
-//#endregion
+//#endregion
+export {};

package/dist/config/next-config.d.ts

@@ -18,7 +18,13 @@ export type HasCondition = {
 export type NextRedirect = {
   source: string;
   destination: string;
-  permanent: boolean;
+  /** `true` answers 308, `false` 307. Ignored when `statusCode` is set. */
+  permanent?: boolean;
+  /**
+   * Explicit redirect status, taking precedence over `permanent` as in Next.js
+   * `getRedirectStatus` (lib/redirect-status.ts).
+   */
+  statusCode?: 301 | 302 | 303 | 307 | 308;
   has?: HasCondition[];
   missing?: HasCondition[];
   /**
@@ -36,6 +42,12 @@ export type NextRedirect = {
    * `.nextjs-ref/packages/next/src/lib/load-custom-routes.ts:26`.
    */
   basePath?: false;
+  /**
+   * Internal: set by `applyLocaleToRoutes` on the `/${defaultLocale}` variant.
+   * Next.js `processRoutes` prefixes that variant's destination with the
+   * basePath without turning a bare `/` into the bare basePath.
+   */
+  defaultLocaleVariant?: true;
 };
 export type NextRewrite = {
   source: string;

package/dist/config/next-config.js

@@ -374,7 +374,8 @@ function warnDeprecatedConfigOptions(config, root) {
 		["experimental.instrumentationHook", `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`]
 	];
 	for (const [propertyPath, warning] of warnings) if (hasConfigProperty(config, propertyPath)) warnConfigOnce(warning);
-	if (readOptionalRecord(config.experimental)?.skipTrailingSlashRedirect != null) warnConfigOnce(`\`experimental.skipTrailingSlashRedirect\` has been moved to \`skipTrailingSlashRedirect\`. Please update your ${configFileName} file accordingly.`);
+	const experimental = readOptionalRecord(config.experimental);
+	for (const key of ["skipTrailingSlashRedirect", "cacheComponents"]) if (experimental?.[key] != null) warnConfigOnce(`\`experimental.${key}\` has been moved to \`${key}\`. Please update your ${configFileName} file accordingly.`);
 }
 async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER) {
 	return await resolveConfigValue(config, phase);
@@ -808,6 +809,28 @@ function validateConfigConditions(type, routes) {
 	}
 	if (invalid.length > 0) throw new Error(`Invalid next.config.js ${type} has/missing condition${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nEach item must be { type: header, cookie, query or host, key: string, value?: string }, with a value and no key required for host.`);
 }
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+/**
+* Fail config loading on a redirect without a valid status, with the rules of
+* Next.js's checkRedirect (load-custom-routes.ts): `statusCode` must be one of
+* the redirect statuses, and `permanent` a boolean when it is absent.
+*/
+function validateRedirectStatuses(redirects) {
+	const invalid = [];
+	for (const redirect of redirects) {
+		const parts = [];
+		if (redirect.statusCode && !REDIRECT_STATUS_CODES.has(redirect.statusCode)) parts.push("`statusCode` is not undefined or valid statusCode");
+		if (typeof redirect.permanent !== "boolean" && !redirect.statusCode) parts.push("`permanent` is not set to `true` or `false`");
+		if (parts.length > 0) invalid.push(`  ${describeSource(redirect.source)}: ${parts.join(", ")}`);
+	}
+	if (invalid.length > 0) throw new Error(`Invalid next.config.js redirect${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nValid redirect statusCode values are ${[...REDIRECT_STATUS_CODES].join(", ")}`);
+}
 /** JSON for a config value, or its type when JSON cannot serialize it. */
 function describeConfigValue(value) {
 	try {
@@ -950,6 +973,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		validateConfigSources("redirect", redirects);
 		validateConfigSources("rewrite", allRewrites);
 		validateConfigConditions("redirect", redirects);
+		validateRedirectStatuses(redirects);
 		validateConfigConditions("rewrite", allRewrites);
 		const invalidBasePathRewrites = allRewrites.filter((rewrite) => rewrite.basePath === false && !(rewrite.destination.startsWith("http://") || rewrite.destination.startsWith("https://")));
 		if (invalidBasePathRewrites.length > 0) throw new Error(invalidBasePathRewrites.map((rewrite) => `The route ${rewrite.source} rewrites urls outside of the basePath. Please use a destination that starts with \`http://\` or \`https://\` https://nextjs.org/docs/messages/invalid-external-rewrite`).concat(`Invalid rewrite${invalidBasePathRewrites.length === 1 ? "" : "s"} found`).join("\n"));
@@ -986,6 +1010,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	};
 	const allowedDevOrigins = Array.isArray(config.allowedDevOrigins) ? config.allowedDevOrigins : [];
 	const experimental = readOptionalRecord(config.experimental);
+	const cacheComponents = (experimental?.cacheComponents ?? config.cacheComponents) === true;
 	const serverActionsConfig = readOptionalRecord(experimental?.serverActions);
 	const serverActionsAllowedOrigins = readStringArray(serverActionsConfig?.allowedOrigins);
 	const serverActionsBodySizeLimitConfig = readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit);
@@ -1001,7 +1026,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	const appShells = experimental?.appShells === true;
 	if (appShells) {
 		const missingCoFlags = [];
-		if (!config.cacheComponents) missingCoFlags.push("cacheComponents");
+		if (!cacheComponents) missingCoFlags.push("cacheComponents");
 		if (!prefetchInlining) missingCoFlags.push("experimental.prefetchInlining");
 		if (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
 		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
@@ -1022,7 +1047,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		exclude: lightningCssFeatureNamesToMask(readStringArray(rawLightningCssFeatures?.exclude))
 	};
 	if (rawLightningCssFeatures && !useLightningcss) console.warn("[vinext] experimental.lightningCssFeatures is set but experimental.useLightningcss is not enabled. The lightningCssFeatures option has no effect without useLightningcss.");
-	if (experimental?.cachedNavigations === true && !config.cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
+	if (experimental?.cachedNavigations === true && !cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
 	if (config.webpack !== void 0) {
 		if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized || webpackProbe.instrumentationClientRouteManifest !== void 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, MDX loader settings, and instrumentation-client route manifests, but other webpack customization is ignored");
 		else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
@@ -1073,7 +1098,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		instrumentationClientRouteManifest: webpackProbe.instrumentationClientRouteManifest,
 		instrumentationServerValueInjections: webpackProbe.instrumentationServerValueInjections,
-		cacheComponents: config.cacheComponents ?? false,
+		cacheComponents,
 		appNavFailHandling: experimental?.appNavFailHandling === true,
 		gestureTransition: experimental?.gestureTransition === true,
 		prefetchInlining,

package/dist/config/tsconfig-paths.d.ts

@@ -17,4 +17,5 @@ export declare function loadTsconfigResolutionForRoot(projectRoot: string): Tsco
  * Back-compat helper for call sites that only need `compilerOptions.paths`.
  */
 export declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
-//#endregion
+//#endregion
+export {};

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/detector.js

@@ -0,0 +1,23 @@
+import { typeHandlers, types } from "./types/index.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/detector.js
+const firstBytes = /* @__PURE__ */ new Map([
+	[0, "heif"],
+	[56, "psd"],
+	[66, "bmp"],
+	[68, "dds"],
+	[71, "gif"],
+	[73, "tiff"],
+	[77, "tiff"],
+	[82, "webp"],
+	[105, "icns"],
+	[137, "png"],
+	[255, "jpg"]
+]);
+function detector(input) {
+	const byte = input[0];
+	const type = firstBytes.get(byte);
+	if (type && typeHandlers.get(type)?.validate(input)) return type;
+	return types.find((type) => typeHandlers.get(type)?.validate(input));
+}
+//#endregion
+export { detector };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/index.js

@@ -0,0 +1,2 @@
+import "./types/index.js";
+export { imageSize } from "./lookup.js";

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/lookup.js

@@ -0,0 +1,25 @@
+import { typeHandlers } from "./types/index.js";
+import { detector } from "./detector.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/lookup.js
+const globalOptions = { disabledTypes: [] };
+function imageSize(input) {
+	const type = detector(input);
+	if (typeof type !== "undefined") {
+		if (globalOptions.disabledTypes.indexOf(type) > -1) throw new TypeError(`disabled file type: ${type}`);
+		const size = typeHandlers.get(type)?.calculate(input);
+		if (size !== void 0) {
+			size.type = size.type ?? type;
+			if (size.images && size.images.length > 1) {
+				const largestImage = size.images.reduce((largest, current) => {
+					return current.width * current.height > largest.width * largest.height ? current : largest;
+				}, size.images[0]);
+				size.width = largestImage.width;
+				size.height = largestImage.height;
+			}
+			return size;
+		}
+	}
+	throw new TypeError(`unsupported file type: ${type}`);
+}
+//#endregion
+export { imageSize };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/bmp.js

@@ -0,0 +1,11 @@
+import { readInt32LE, readUInt32LE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/bmp.js
+const BMP = {
+	validate: (input) => toUTF8String(input, 0, 2) === "BM",
+	calculate: (input) => ({
+		height: Math.abs(readInt32LE(input, 22)),
+		width: readUInt32LE(input, 18)
+	})
+};
+//#endregion
+export { BMP };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/cur.js

@@ -0,0 +1,15 @@
+import { readUInt16LE } from "./utils.js";
+import { ICO } from "./ico.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/cur.js
+const TYPE_CURSOR = 2;
+const CUR = {
+	validate(input) {
+		const reserved = readUInt16LE(input, 0);
+		const imageCount = readUInt16LE(input, 4);
+		if (reserved !== 0 || imageCount === 0) return false;
+		return readUInt16LE(input, 2) === TYPE_CURSOR;
+	},
+	calculate: (input) => ICO.calculate(input)
+};
+//#endregion
+export { CUR };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/dds.js

@@ -0,0 +1,11 @@
+import { readUInt32LE } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/dds.js
+const DDS = {
+	validate: (input) => readUInt32LE(input, 0) === 542327876,
+	calculate: (input) => ({
+		height: readUInt32LE(input, 12),
+		width: readUInt32LE(input, 16)
+	})
+};
+//#endregion
+export { DDS };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/gif.js

@@ -0,0 +1,12 @@
+import { readUInt16LE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/gif.js
+const gifRegexp = /^GIF8[79]a/;
+const GIF = {
+	validate: (input) => gifRegexp.test(toUTF8String(input, 0, 6)),
+	calculate: (input) => ({
+		height: readUInt16LE(input, 8),
+		width: readUInt16LE(input, 6)
+	})
+};
+//#endregion
+export { GIF };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/heif.js

@@ -0,0 +1,55 @@
+import { findBox, readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/heif.js
+const brandMap = {
+	avif: "avif",
+	mif1: "heif",
+	msf1: "heif",
+	heic: "heic",
+	heix: "heic",
+	hevc: "heic",
+	hevx: "heic"
+};
+const HEIF = {
+	validate(input) {
+		if (toUTF8String(input, 4, 8) !== "ftyp") return false;
+		const ftypBox = findBox(input, "ftyp", 0);
+		if (!ftypBox) return false;
+		return toUTF8String(input, ftypBox.offset + 8, ftypBox.offset + 12) in brandMap;
+	},
+	calculate(input) {
+		const metaBox = findBox(input, "meta", 0);
+		const iprpBox = metaBox && findBox(input, "iprp", metaBox.offset + 12);
+		const ipcoBox = iprpBox && findBox(input, "ipco", iprpBox.offset + 8);
+		if (!ipcoBox) throw new TypeError("Invalid HEIF, no ipco box found");
+		const type = toUTF8String(input, 8, 12);
+		const images = [];
+		let currentOffset = ipcoBox.offset + 8;
+		while (currentOffset < ipcoBox.offset + ipcoBox.size) {
+			const ispeBox = findBox(input, "ispe", currentOffset);
+			if (!ispeBox) break;
+			if (ispeBox.size < 20) throw new TypeError("Invalid HEIF");
+			const rawWidth = readUInt32BE(input, ispeBox.offset + 12);
+			const rawHeight = readUInt32BE(input, ispeBox.offset + 16);
+			const clapBox = findBox(input, "clap", currentOffset);
+			let width = rawWidth;
+			const height = rawHeight;
+			if (clapBox && clapBox.size >= 16 && clapBox.offset < ipcoBox.offset + ipcoBox.size) width = rawWidth - readUInt32BE(input, clapBox.offset + 12);
+			images.push({
+				height,
+				width
+			});
+			const nextOffset = ispeBox.offset + ispeBox.size;
+			if (nextOffset <= currentOffset) throw new TypeError("Invalid HEIF");
+			currentOffset = nextOffset;
+		}
+		if (images.length === 0) throw new TypeError("Invalid HEIF, no sizes found");
+		return {
+			width: images[0].width,
+			height: images[0].height,
+			type,
+			...images.length > 1 ? { images } : {}
+		};
+	}
+};
+//#endregion
+export { HEIF };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/icns.js

@@ -0,0 +1,76 @@
+import { readUInt32BE, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/icns.js
+const SIZE_HEADER = 8;
+const FILE_LENGTH_OFFSET = 4;
+const ENTRY_LENGTH_OFFSET = 4;
+const ICON_TYPE_SIZE = {
+	ICON: 32,
+	"ICN#": 32,
+	"icm#": 16,
+	icm4: 16,
+	icm8: 16,
+	"ics#": 16,
+	ics4: 16,
+	ics8: 16,
+	is32: 16,
+	s8mk: 16,
+	icp4: 16,
+	icl4: 32,
+	icl8: 32,
+	il32: 32,
+	l8mk: 32,
+	icp5: 32,
+	ic11: 32,
+	ich4: 48,
+	ich8: 48,
+	ih32: 48,
+	h8mk: 48,
+	icp6: 64,
+	ic12: 32,
+	it32: 128,
+	t8mk: 128,
+	ic07: 128,
+	ic08: 256,
+	ic13: 256,
+	ic09: 512,
+	ic14: 512,
+	ic10: 1024
+};
+function readImageHeader(input, imageOffset) {
+	const imageLengthOffset = imageOffset + ENTRY_LENGTH_OFFSET;
+	if (imageLengthOffset + 4 > input.length) throw new TypeError("Invalid ICNS");
+	return [toUTF8String(input, imageOffset, imageLengthOffset), readUInt32BE(input, imageLengthOffset)];
+}
+function getImageSize(type) {
+	const size = ICON_TYPE_SIZE[type];
+	return {
+		width: size,
+		height: size,
+		type
+	};
+}
+const ICNS = {
+	validate: (input) => toUTF8String(input, 0, 4) === "icns",
+	calculate(input) {
+		const inputLength = input.length;
+		const fileLength = readUInt32BE(input, FILE_LENGTH_OFFSET);
+		let imageOffset = SIZE_HEADER;
+		const images = [];
+		while (imageOffset < fileLength && imageOffset < inputLength) {
+			const imageHeader = readImageHeader(input, imageOffset);
+			const entryLength = imageHeader[1];
+			if (entryLength < 8) throw new TypeError("Invalid ICNS");
+			const imageSize = getImageSize(imageHeader[0]);
+			images.push(imageSize);
+			imageOffset += entryLength;
+		}
+		if (images.length === 0) throw new TypeError("Invalid ICNS, no sizes found");
+		return {
+			width: images[0].width,
+			height: images[0].height,
+			...images.length > 1 ? { images } : {}
+		};
+	}
+};
+//#endregion
+export { ICNS };