vinext 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/plugins/ignore-dynamic-requests.js

@@ -43,6 +43,21 @@ function stringValue(node) {
 	if ((node.type === "Literal" || node.type === "StringLiteral") && typeof node.value === "string") return node.value;
 	return null;
 }
+function stringFromCharCodeValue(value, scope) {
+	const node = unwrapExpression(value);
+	if (node?.type !== "CallExpression") return null;
+	const callee = unwrapExpression(node.callee);
+	const object = callee?.type === "MemberExpression" ? unwrapExpression(callee.object) : null;
+	const property = callee?.type === "MemberExpression" ? unwrapExpression(callee.property) : null;
+	if (callee?.type !== "MemberExpression" || callee.computed === true || !isIdentifierNamed(object, "String") || hasAstBinding(scope, "String") || !isIdentifierNamed(property, "fromCharCode")) return null;
+	let resolved = "";
+	for (const argument of nodeArray(node.arguments)) {
+		const argumentNode = unwrapExpression(argument);
+		if (argumentNode?.type !== "Literal" || typeof argumentNode.value !== "number" || !Number.isInteger(argumentNode.value) || argumentNode.value < 0 || argumentNode.value > 65535) return null;
+		resolved += String.fromCharCode(argumentNode.value);
+	}
+	return resolved;
+}
 function isUnboundNumericGlobal(node, scope) {
 	return node.type === "Identifier" && typeof node.name === "string" && !hasAstBinding(scope, node.name) && (isIdentifierNamed(node, "NaN") || isIdentifierNamed(node, "Infinity"));
 }
@@ -482,10 +497,19 @@ function transformVeryDynamicRequests(code, id) {
 		if (node.type === "CallExpression" && hasRange(node)) {
 			const callee = unwrapExpression(node.callee);
 			const argumentsList = nodeArray(node.arguments);
-			if (isIdentifierNamed(callee, "require") && !hasAstBinding(scope, "require") && argumentsList.length === 1 && astNode(argumentsList[0])?.type !== "SpreadElement" && !hasDynamicRequestIgnoreDirective(code, node, argumentsList[0]) && !requestHasStaticPart(argumentsList[0], scope)) {
-				output.overwrite(node.start, node.end, dynamicRequireReplacement());
-				changed = true;
-				return;
+			if (isIdentifierNamed(callee, "require") && !hasAstBinding(scope, "require") && argumentsList.length === 1 && astNode(argumentsList[0])?.type !== "SpreadElement" && !hasDynamicRequestIgnoreDirective(code, node, argumentsList[0])) {
+				const resolvedRequest = stringFromCharCodeValue(argumentsList[0], scope);
+				const argument = astNode(argumentsList[0]);
+				if (resolvedRequest !== null && resolvedRequest.replaceAll("\\", "/") !== "/" && argument && hasRange(argument)) {
+					output.overwrite(argument.start, argument.end, JSON.stringify(resolvedRequest));
+					changed = true;
+					return;
+				}
+				if (!requestHasStaticPart(argumentsList[0], scope)) {
+					output.overwrite(node.start, node.end, dynamicRequireReplacement());
+					changed = true;
+					return;
+				}
 			}
 		}
 		if (node.type === "ImportExpression" && hasRange(node) && !hasDynamicRequestIgnoreDirective(code, node, node.source) && !requestHasStaticPart(node.source, scope)) {

package/dist/plugins/import-meta-url.d.ts

@@ -1,6 +1,5 @@
 import { Plugin } from "vite";
 import MagicString from "magic-string";
-
 //#region src/plugins/import-meta-url.d.ts
 type ImportMetaUrlEnvironment = "client" | "server";
 type RewriteResult = {

package/dist/plugins/instrumentation-client.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/instrumentation-client.d.ts
 declare function createInstrumentationClientTransformPlugin(getInstrumentationClientPath: () => string | null): Plugin;
 //#endregion

package/dist/plugins/middleware-server-only.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/middleware-server-only.d.ts
 /**
  * Allow `import 'server-only'` from neutral server targets (and any module

package/dist/plugins/og-asset-ownership.d.ts

@@ -1,5 +1,4 @@
 import { Alias } from "vite";
-
 //#region src/plugins/og-asset-ownership.d.ts
 type OgAssetModuleBoundary = {
   assetRoot: string;

package/dist/plugins/og-assets.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/og-assets.d.ts
 /**
  * Create the `vinext:og-inline-fetch-assets` Vite plugin.

package/dist/plugins/optimize-imports.d.ts

@@ -1,6 +1,5 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
 import { Plugin } from "vite";
-
 //#region src/plugins/optimize-imports.d.ts
 type BarrelExportEntry = {
   source: string;

package/dist/plugins/remove-console.d.ts

@@ -1,5 +1,4 @@
 import MagicString from "magic-string";
-
 //#region src/plugins/remove-console.d.ts
 type RemoveConsoleConfig = boolean | {
   exclude: string[];

package/dist/plugins/require-context.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/require-context.d.ts
 declare function createRequireContextPlugin(): Plugin;
 //#endregion

package/dist/plugins/require-context.js

@@ -1,6 +1,7 @@
+import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { forEachAstChild, hasRange, isAstRecord, nodeArray } from "./ast-utils.js";
-import { createTransformCache } from "./transform-cache.js";
 import { parseAst } from "vite";
+import { readdir, realpath, stat } from "node:fs/promises";
 import MagicString from "magic-string";
 //#region src/plugins/require-context.ts
 const TRANSFORMABLE_EXTENSIONS = /* @__PURE__ */ new Set([
@@ -14,7 +15,7 @@ const TRANSFORMABLE_EXTENSIONS = /* @__PURE__ */ new Set([
 	".cts"
 ]);
 function createRequireContextPlugin() {
-	const cached = createTransformCache();
+	const watchedContexts = /* @__PURE__ */ new WeakMap();
 	return {
 		name: "vinext:require-context",
 		enforce: "pre",
@@ -23,13 +24,42 @@ function createRequireContextPlugin() {
 				id: /\.(?:[cm]?[jt]s|[jt]sx)(?:\?.*)?$/i,
 				code: /\brequire\b[\s\S]*\.context/
 			},
-			handler(code, id) {
-				return cached(id, code, void 0, () => transformRequireContext(code, id));
+			async handler(code, id) {
+				const transformed = await transformRequireContext(code, id);
+				const contextsForEnvironment = watchedContexts.get(this.environment) ?? /* @__PURE__ */ new Map();
+				watchedContexts.set(this.environment, contextsForEnvironment);
+				if (!transformed) {
+					contextsForEnvironment.delete(id);
+					return null;
+				}
+				contextsForEnvironment.set(id, transformed.contexts);
+				for (const context of transformed.contexts) this.addWatchFile(context.directory);
+				return {
+					code: transformed.code,
+					map: transformed.map
+				};
 			}
+		},
+		hotUpdate({ type, file, modules }) {
+			const contextsForEnvironment = watchedContexts.get(this.environment);
+			if (!contextsForEnvironment) return;
+			for (const module of modules) if (module.id != null) contextsForEnvironment.delete(module.id);
+			if (type === "update") return;
+			const normalizedFile = toSlash(file);
+			const affectedModules = new Set(modules);
+			let addedImporter = false;
+			for (const [id, contexts] of contextsForEnvironment) {
+				if (!contexts.some((context) => matchesWatchedContext(normalizedFile, context))) continue;
+				const module = this.environment.moduleGraph.getModuleById(id);
+				if (!module || affectedModules.has(module)) continue;
+				affectedModules.add(module);
+				addedImporter = true;
+			}
+			return addedImporter ? [...affectedModules] : void 0;
 		}
 	};
 }
-function transformRequireContext(code, id) {
+async function transformRequireContext(code, id) {
 	const lang = langForId(id);
 	let ast;
 	try {
@@ -40,10 +70,25 @@ function transformRequireContext(code, id) {
 	const calls = collectRequireContextCalls(ast);
 	if (calls.length === 0) return null;
 	const output = new MagicString(code);
-	for (const call of calls) output.overwrite(call.range.start, call.range.end, buildReplacement(call));
+	const importOffset = findImportInsertionOffset(ast);
+	const imports = [];
+	const contexts = [];
+	let bindingPrefix = "__vinext_require_context";
+	while (code.includes(bindingPrefix)) bindingPrefix += "_";
+	for (const [callIndex, call] of calls.entries()) {
+		const resolved = await resolveContextModules(id, call, bindingPrefix, callIndex);
+		contexts.push(resolved.context);
+		for (const module of resolved.modules) imports.push(`import * as ${module.binding} from ${JSON.stringify(module.specifier)};`);
+		output.overwrite(call.range.start, call.range.end, buildReplacement(call, resolved.modules));
+	}
+	if (imports.length > 0) {
+		const importBlock = `${importOffset > 0 ? "\n" : ""}${imports.join("\n")}\n`;
+		output.appendLeft(importOffset, importBlock);
+	}
 	return {
 		code: output.toString(),
-		map: output.generateMap({ hires: "boundary" })
+		map: output.generateMap({ hires: "boundary" }),
+		contexts
 	};
 }
 function langForId(id) {
@@ -75,6 +120,16 @@ function collectRequireContextCalls(ast) {
 	visit(ast);
 	return calls;
 }
+function findImportInsertionOffset(ast) {
+	if (!isAstRecord(ast) || ast.type !== "Program") return 0;
+	let offset = 0;
+	if (isAstRecord(ast.hashbang) && hasRange(ast.hashbang)) offset = ast.hashbang.end;
+	for (const statement of nodeArray(ast.body)) {
+		if (!isAstRecord(statement) || statement.type !== "ExpressionStatement" || typeof statement.directive !== "string" || !hasRange(statement)) break;
+		offset = statement.end;
+	}
+	return offset;
+}
 function parseRequireContextCall(node) {
 	if (node.type !== "CallExpression" || !hasRange(node)) return null;
 	const callee = node.callee;
@@ -146,26 +201,14 @@ function regexLiteralValue(value) {
 	};
 	return null;
 }
-function buildReplacement(call) {
-	const globPattern = globPatternFor(call.dir, call.recursive);
-	const glob = `import.meta.glob(${JSON.stringify(globPattern)}, { eager: true })`;
+function buildReplacement(call, modules) {
 	const base = JSON.stringify(stripTrailingSlash(call.dir));
-	const filterFlags = call.flags.replace(/[gy]/g, "");
-	const regexArgs = `${JSON.stringify(call.pattern)}, ${JSON.stringify(filterFlags)}`;
+	const entries = modules.map((module) => `${JSON.stringify(module.key)}: ${module.binding}`);
 	return [
 		"(() => {",
-		`  const __modules = ${glob};`,
 		`  const __base = ${base};`,
-		`  const __re = ${call.pattern ? `new RegExp(${regexArgs})` : "null"};`,
-		"  const __prefix = __base.endsWith('/') ? __base : __base + '/';",
-		"  const __map = Object.create(null);",
-		"  for (const __abs in __modules) {",
-		"    if (!__abs.startsWith(__prefix)) continue;",
-		"    const __key = './' + __abs.slice(__prefix.length);",
-		"    if (__re && !__re.test(__key)) continue;",
-		"    __map[__key] = __modules[__abs];",
-		"  }",
-		"  const __keys = Object.keys(__map).sort();",
+		`  const __map = Object.assign(Object.create(null), {${entries.join(",")}});`,
+		`  const __keys = ${JSON.stringify(modules.map((module) => module.key))};`,
 		"  const __ctx = (__key) => {",
 		"    if (__key in __map) return __map[__key];",
 		"    const __err = new Error('Cannot find module \\'' + __key + '\\'');",
@@ -179,9 +222,83 @@ function buildReplacement(call) {
 		"})()"
 	].join("\n");
 }
-function globPatternFor(dir, recursive) {
-	const base = stripTrailingSlash(dir);
-	return recursive ? `${base}/**/*` : `${base}/*`;
+async function resolveContextModules(id, call, bindingPrefix, callIndex) {
+	const importer = toSlash(id.split("?", 1)[0]);
+	const directory = path.resolve(path.dirname(importer), call.dir);
+	const context = {
+		directory,
+		recursive: call.recursive,
+		pattern: call.pattern,
+		flags: filterFlags(call.flags)
+	};
+	const regexp = call.pattern ? new RegExp(call.pattern, context.flags) : null;
+	const accepted = [];
+	for (const candidate of await listContextFiles(directory, call.recursive)) {
+		const key = `./${candidate}`;
+		if (regexp && !regexp.test(key)) continue;
+		accepted.push({
+			key,
+			specifier: `${stripTrailingSlash(call.dir)}/${candidate}`
+		});
+	}
+	accepted.sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+	return {
+		context,
+		modules: accepted.map((entry, index) => ({
+			...entry,
+			binding: `${bindingPrefix}_${callIndex}_${index}`
+		}))
+	};
+}
+async function listContextFiles(directory, recursive) {
+	const files = [];
+	const ancestorRealPaths = /* @__PURE__ */ new Set();
+	async function walk(currentDirectory, prefix) {
+		let realDirectory;
+		let entries;
+		try {
+			realDirectory = await realpath(currentDirectory);
+			entries = await readdir(currentDirectory, { withFileTypes: true });
+		} catch (error) {
+			const code = error.code;
+			if (code === "ENOENT" || code === "ENOTDIR") return;
+			throw error;
+		}
+		if (ancestorRealPaths.has(realDirectory)) return;
+		ancestorRealPaths.add(realDirectory);
+		try {
+			for (const entry of entries) {
+				if (entry.name.startsWith(".")) continue;
+				const entryPath = path.join(currentDirectory, entry.name);
+				let isFile = entry.isFile();
+				let isDirectory = entry.isDirectory();
+				if (!isFile && !isDirectory) try {
+					const stats = await stat(entryPath);
+					isFile = stats.isFile();
+					isDirectory = stats.isDirectory();
+				} catch (error) {
+					const code = error.code;
+					if (code === "ENOENT" || code === "ELOOP") continue;
+					throw error;
+				}
+				if (isFile) files.push(`${prefix}${entry.name}`);
+				else if (isDirectory && recursive) await walk(entryPath, `${prefix}${entry.name}/`);
+			}
+		} finally {
+			ancestorRealPaths.delete(realDirectory);
+		}
+	}
+	await walk(directory, "");
+	return files;
+}
+function matchesWatchedContext(file, context) {
+	const candidate = path.relative(context.directory, file);
+	if (candidate.length === 0 || candidate === ".." || candidate.startsWith("../") || candidate.split("/").some((segment) => segment.startsWith(".")) || !context.recursive && candidate.includes("/")) return false;
+	if (context.recursive) return true;
+	return context.pattern === "" || new RegExp(context.pattern, context.flags).test(`./${candidate}`);
+}
+function filterFlags(flags) {
+	return flags.replace(/[gy]/g, "");
 }
 function stripTrailingSlash(value) {
 	return value.endsWith("/") ? value.slice(0, -1) : value;

package/dist/plugins/rsc-client-reference-loaders.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/rsc-client-reference-loaders.d.ts
 declare function createRscClientReferenceLoadersPlugin(): Plugin;
 //#endregion

package/dist/plugins/rsc-reference-validation-normalizer.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/rsc-reference-validation-normalizer.d.ts
 /**
  * @vitejs/plugin-rsc stores dev virtual client-reference keys in Vite's encoded

package/dist/plugins/sass.d.ts

@@ -1,5 +1,4 @@
 import { ResolvedConfig } from "vite";
-
 //#region src/plugins/sass.d.ts
 type AdditionalData = string | ((source: string, filename: string) => string | Promise<string>);
 type VitePreprocessorOptions = {
@@ -7,6 +6,35 @@ type VitePreprocessorOptions = {
   loadPaths?: string[];
   [key: string]: any;
 };
+type SassTsconfigPathAlias = {
+  find: string;
+  replacements: readonly string[];
+};
+type SassFileImporterContext = {
+  containingUrl?: URL | null;
+};
+type SassFileImporter = {
+  findFileUrl(url: string, context?: SassFileImporterContext): URL | null;
+};
+/**
+ * Create Sass `FileImporter`s for paths materialized from tsconfig.
+ *
+ * Vite does not apply tsconfig path aliases while resolving Sass loads. Vinext
+ * deliberately extends that behavior for migration compatibility: application
+ * stylesheets may use the same exact and single-wildcard mappings as source
+ * modules. This is a vinext capability, not Next.js parity; current Next.js
+ * webpack builds do not resolve tsconfig `paths` from Sass.
+ *
+ * One importer is emitted per ordered replacement slot. When Sass cannot find
+ * a file for the first target it advances to the next importer, preserving the
+ * fallback order from `paths`. All importers select the same best pattern, so a
+ * failed specific mapping never falls through to a less-specific mapping.
+ *
+ * Aliases stay scoped to application stylesheets. Loads originating in
+ * `node_modules`, plus absolute, relative, protocol-relative, and scheme URLs,
+ * are left to user and Vite importers.
+ */
+declare function createSassTsconfigPathImporters(aliases: readonly SassTsconfigPathAlias[]): SassFileImporter[];
 /**
  * Create a Sass `FileImporter` that resolves webpack-style tilde (`~`) imports.
  *
@@ -75,4 +103,4 @@ declare function createSassAwareFileSystemLoader(): {
   setResolvedConfig: (config: ResolvedConfig) => void;
 };
 //#endregion
-export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassCssUrlAssetImporter, createSassTildeImporter };
+export { SassTsconfigPathAlias, buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassCssUrlAssetImporter, createSassTildeImporter, createSassTsconfigPathImporters };

package/dist/plugins/sass.js

@@ -3,7 +3,7 @@ import { markCssUrlAssetReferences, rebaseCssUrlAssetReferences } from "../build
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import { preprocessCSS } from "vite";
-import { pathToFileURL } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 //#region src/plugins/sass.ts
 /**
 * Map a Next.js `sassOptions` object onto Vite's
@@ -28,6 +28,69 @@ import { pathToFileURL } from "node:url";
 *
 * @see https://vite.dev/config/shared-options.html#css-preprocessoroptions
 */
+const URL_SCHEME_RE = /^[A-Za-z][A-Za-z\d+.-]*:/;
+const NODE_MODULES_PATH_RE = /(?:^|\/)node_modules(?:\/|$)/;
+function matchSassTsconfigPathAlias(aliases, url) {
+	for (const alias of aliases) if (!alias.find.includes("*") && alias.find === url) return {
+		alias,
+		matchedStar: null
+	};
+	let bestMatch = null;
+	let bestPrefixLength = -1;
+	for (const alias of aliases) {
+		const starIndex = alias.find.indexOf("*");
+		if (starIndex < 0) continue;
+		const prefix = alias.find.slice(0, starIndex);
+		const suffix = alias.find.slice(starIndex + 1);
+		if (url.length < prefix.length + suffix.length || !url.startsWith(prefix) || !url.endsWith(suffix) || prefix.length <= bestPrefixLength) continue;
+		bestPrefixLength = prefix.length;
+		bestMatch = {
+			alias,
+			matchedStar: url.slice(prefix.length, url.length - suffix.length)
+		};
+	}
+	return bestMatch;
+}
+function isSassAliasEligibleUrl(url, context) {
+	if (URL_SCHEME_RE.test(url) || url.startsWith("//") || url.startsWith("/") || url.startsWith("./") || url.startsWith("../") || url.startsWith("~")) return false;
+	const containingUrl = context?.containingUrl;
+	if (containingUrl?.protocol === "file:") {
+		const containingPath = toSlash(fileURLToPath(containingUrl));
+		if (NODE_MODULES_PATH_RE.test(containingPath)) return false;
+	}
+	return true;
+}
+/**
+* Create Sass `FileImporter`s for paths materialized from tsconfig.
+*
+* Vite does not apply tsconfig path aliases while resolving Sass loads. Vinext
+* deliberately extends that behavior for migration compatibility: application
+* stylesheets may use the same exact and single-wildcard mappings as source
+* modules. This is a vinext capability, not Next.js parity; current Next.js
+* webpack builds do not resolve tsconfig `paths` from Sass.
+*
+* One importer is emitted per ordered replacement slot. When Sass cannot find
+* a file for the first target it advances to the next importer, preserving the
+* fallback order from `paths`. All importers select the same best pattern, so a
+* failed specific mapping never falls through to a less-specific mapping.
+*
+* Aliases stay scoped to application stylesheets. Loads originating in
+* `node_modules`, plus absolute, relative, protocol-relative, and scheme URLs,
+* are left to user and Vite importers.
+*/
+function createSassTsconfigPathImporters(aliases) {
+	const entries = aliases.filter(({ find, replacements }) => find.length > 0 && replacements.length > 0);
+	const replacementSlots = Math.max(0, ...entries.map((alias) => alias.replacements.length));
+	return Array.from({ length: replacementSlots }, (_, replacementIndex) => ({ findFileUrl(url, context) {
+		if (!isSassAliasEligibleUrl(url, context)) return null;
+		const match = matchSassTsconfigPathAlias(entries, url);
+		if (!match) return null;
+		const replacement = match.alias.replacements[replacementIndex];
+		if (!replacement) return null;
+		const matchedStar = match.matchedStar;
+		return pathToFileURL(matchedStar === null ? replacement : replacement.replaceAll("*", () => matchedStar));
+	} }));
+}
 /**
 * Create a Sass `FileImporter` that resolves webpack-style tilde (`~`) imports.
 *
@@ -130,8 +193,7 @@ function createSassCssUrlAssetImporter() {
 			if (!fs.statSync(candidate, { throwIfNoEntry: false })?.isFile()) continue;
 			const prepared = prepareStylesheet(candidate, entryDirectory);
 			if (prepared === null) return match;
-			const canonicalUrl = pathToFileURL(candidate);
-			markedStylesheets.set(canonicalUrl.href, prepared);
+			markedStylesheets.set(candidate, prepared);
 			const namespace = rule === "use" && !/\bas\s+(?:\*|[-\w]+)/.test(suffix) ? ` as ${deriveSassNamespace(importUrl)}` : "";
 			return `${prefix}${quote}${importUrlPrefix}${encodeURIComponent(candidate)}${quote}${namespace}${suffix}`;
 		}
@@ -143,7 +205,7 @@ function createSassCssUrlAssetImporter() {
 			return pathToFileURL(decodeURIComponent(url.slice(21)));
 		},
 		load(canonicalUrl) {
-			return markedStylesheets.get(canonicalUrl.href) ?? null;
+			return markedStylesheets.get(toSlash(fileURLToPath(canonicalUrl))) ?? null;
 		},
 		rewriteImports
 	};
@@ -338,4 +400,4 @@ function createSassAwareFileSystemLoader() {
 	};
 }
 //#endregion
-export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassCssUrlAssetImporter, createSassTildeImporter };
+export { buildSassPreprocessorOptions, createSassAwareFileSystemLoader, createSassCssUrlAssetImporter, createSassTildeImporter, createSassTsconfigPathImporters };

package/dist/plugins/server-externals-manifest.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/server-externals-manifest.d.ts
 /**
  * vinext:server-externals-manifest

package/dist/plugins/strip-server-exports.d.ts

@@ -1,5 +1,4 @@
 import MagicString from "magic-string";
-
 //#region src/plugins/strip-server-exports.d.ts
 declare function hasServerExportCandidate(code: string): boolean;
 declare function hasExportAllCandidate(code: string): boolean;

package/dist/plugins/styled-jsx.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/styled-jsx.d.ts
 type NextSwcModule = {
   loadBindings(): Promise<unknown>;

package/dist/plugins/wasm-module-import.d.ts

@@ -1,5 +1,4 @@
 import { Plugin } from "vite";
-
 //#region src/plugins/wasm-module-import.d.ts
 /**
  * vinext:wasm-module-import — handle `import x from '*.wasm?module'`.