vinext 1.2.0 → 1.2.1

package/dist/plugins/ast-utils.d.ts

@@ -1,4 +1,4 @@
-import { ESTree } from "vite";
+import { ESTree, ParseResult, ParserOptions } from "vite";
 //#region src/plugins/ast-utils.d.ts
 export type ScriptParserLanguage = "js" | "jsx" | "ts" | "tsx";
 export declare const SCRIPT_MODULE_ID_RE: RegExp;
@@ -8,7 +8,7 @@ export declare const SCRIPT_MODULE_ID_RE: RegExp;
  * Static imports — `import x from "..."`, `import { ... } from "..."`,
  * `import "..."` — never place a `(` (nor a comment leading to one) immediately
  * after the `import` keyword. Plugins that act only on dynamic `import(...)` use
- * this to skip `parseAst` for the overwhelming majority of modules in a large
+ * this to skip parsing for the overwhelming majority of modules in a large
  * app: at ~5k routes, where almost every module is a static-import-only page,
  * it removes most of the build's AST-parse/GC cost. This is a deliberate,
  * measured performance filter — keep it a regex, never a parse.
@@ -36,6 +36,57 @@ export declare function mayContainDynamicImport(code: string): boolean;
  * necessarily been lowered.
  */
 export declare function scriptParserLanguage(id: string): ScriptParserLanguage | null;
+/** The import/export record oxc builds alongside the AST. */
+export type ModuleRecord = ParseResult["module"];
+/**
+ * Parse `code` into an ESTree program, throwing on syntax errors.
+ *
+ * Replaces Vite's deprecated `parseAst` with the same defaults and contract.
+ * Callers that only need import/export declarations should use
+ * {@link parseModuleRecord}, which skips building the JS AST.
+ */
+export declare function parseProgram(code: string, options?: ParserOptions): ESTree.Program;
+/** Async {@link parseProgram}; replaces Vite's deprecated `parseAstAsync`. */
+export declare function parseProgramAsync(code: string, options?: ParserOptions): Promise<ESTree.Program>;
+/**
+ * Parse `code` and return only its static import/export and dynamic import
+ * record, or `null` when it has syntax errors.
+ *
+ * Reading the record never deserializes the JS AST, which is most of the cost
+ * of a parse (about 4x cheaper than {@link parseProgram} on large modules).
+ * The record omits import attributes; see {@link hasImportAttributes}.
+ */
+export declare function parseModuleRecord(code: string, lang: ParserOptions["lang"]): ModuleRecord | null;
+/**
+ * One whitespace character or comment. Each alternative can only match one
+ * way (a block comment stops at the first `*\/`, a line comment runs to the
+ * line end), so repeating it cannot backtrack exponentially.
+ */
+export declare const TRIVIA_PATTERN: string;
+/** Leading whitespace and comments. */
+export declare const LEADING_TRIVIA_RE: RegExp;
+/**
+ * Whether the static import/export statement ending at `statementEnd` has
+ * `with { ... }` (or legacy `assert { ... }`) attributes after its source
+ * string, which ends at `sourceEnd`. The module record does not report
+ * attributes.
+ */
+export declare function hasImportAttributes(code: string, sourceEnd: number, statementEnd: number): boolean;
+/**
+ * Whether a static import is erased by TypeScript: every binding is
+ * type-only, or it is `import type {} from "x"`, which the module record
+ * reports with no entries (like a runtime `import {} from "x"`).
+ */
+export declare function isTypeOnlyImport(code: string, statement: ModuleRecord["staticImports"][number]): boolean;
+/**
+ * The value of the string literal or expression-free template literal spanning
+ * `span`, or `null` for any other expression. The module record gives only the
+ * span of a dynamic import's source.
+ */
+export declare function quotedStringAt(code: string, span: {
+  start: number;
+  end: number;
+}): string | null;
 export declare function isIdentifierNamed(value: ESTree.Node | null | undefined, name: string): boolean;
 export declare function getAstName(node: ESTree.Node | null | undefined): string | null;
 /** Remove syntax-only wrappers while preserving the underlying expression. */

package/dist/plugins/ast-utils.js

@@ -1,3 +1,4 @@
+import { parse, parseSync } from "vite";
 //#region src/plugins/ast-utils.ts
 const SCRIPT_MODULE_EXTENSION_RE = /^\.(?:[cm]?[jt]s|[jt]sx)$/i;
 const SCRIPT_MODULE_ID_RE = /\.(?:[cm]?[jt]s|[jt]sx)(?:[?#].*)?$/i;
@@ -7,7 +8,7 @@ const SCRIPT_MODULE_ID_RE = /\.(?:[cm]?[jt]s|[jt]sx)(?:[?#].*)?$/i;
 * Static imports — `import x from "..."`, `import { ... } from "..."`,
 * `import "..."` — never place a `(` (nor a comment leading to one) immediately
 * after the `import` keyword. Plugins that act only on dynamic `import(...)` use
-* this to skip `parseAst` for the overwhelming majority of modules in a large
+* this to skip parsing for the overwhelming majority of modules in a large
 * app: at ~5k routes, where almost every module is a static-import-only page,
 * it removes most of the build's AST-parse/GC cost. This is a deliberate,
 * measured performance filter — keep it a regex, never a parse.
@@ -46,6 +47,93 @@ function scriptParserLanguage(id) {
 	if (extension === ".tsx") return "tsx";
 	return "jsx";
 }
+const PROGRAM_PARSER_DEFAULTS = {
+	lang: "js",
+	preserveParens: false
+};
+const PARSE_FILENAME = "file.js";
+function programOrThrow(result) {
+	if (result.errors.length > 0) {
+		const frames = result.errors.slice(0, 5).map((error) => error.codeframe ?? error.message);
+		throw new SyntaxError(`Parse failed with ${result.errors.length} error${result.errors.length === 1 ? "" : "s"}:\n${frames.join("\n")}`);
+	}
+	return result.program;
+}
+/**
+* Parse `code` into an ESTree program, throwing on syntax errors.
+*
+* Replaces Vite's deprecated `parseAst` with the same defaults and contract.
+* Callers that only need import/export declarations should use
+* {@link parseModuleRecord}, which skips building the JS AST.
+*/
+function parseProgram(code, options) {
+	return programOrThrow(parseSync(PARSE_FILENAME, code, {
+		...PROGRAM_PARSER_DEFAULTS,
+		...options
+	}));
+}
+/** Async {@link parseProgram}; replaces Vite's deprecated `parseAstAsync`. */
+async function parseProgramAsync(code, options) {
+	return programOrThrow(await parse(PARSE_FILENAME, code, {
+		...PROGRAM_PARSER_DEFAULTS,
+		...options
+	}));
+}
+/**
+* Parse `code` and return only its static import/export and dynamic import
+* record, or `null` when it has syntax errors.
+*
+* Reading the record never deserializes the JS AST, which is most of the cost
+* of a parse (about 4x cheaper than {@link parseProgram} on large modules).
+* The record omits import attributes; see {@link hasImportAttributes}.
+*/
+function parseModuleRecord(code, lang) {
+	const result = parseSync(PARSE_FILENAME, code, { lang });
+	return result.errors.length > 0 ? null : result.module;
+}
+/**
+* One whitespace character or comment. Each alternative can only match one
+* way (a block comment stops at the first `*\/`, a line comment runs to the
+* line end), so repeating it cannot backtrack exponentially.
+*/
+const TRIVIA_PATTERN = String.raw`(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/|\/\/[^\n\r\u2028\u2029]*(?![^\n\r\u2028\u2029]))`;
+/** Leading whitespace and comments. */
+const LEADING_TRIVIA_RE = new RegExp(`^${TRIVIA_PATTERN}*`);
+/**
+* Whether the static import/export statement ending at `statementEnd` has
+* `with { ... }` (or legacy `assert { ... }`) attributes after its source
+* string, which ends at `sourceEnd`. The module record does not report
+* attributes.
+*/
+function hasImportAttributes(code, sourceEnd, statementEnd) {
+	const afterSource = code.slice(sourceEnd, statementEnd);
+	const triviaLength = LEADING_TRIVIA_RE.exec(afterSource)?.[0].length ?? 0;
+	return /^(?:with|assert)\b/.test(afterSource.slice(triviaLength));
+}
+const EMPTY_TYPE_IMPORT_RE = new RegExp(String.raw`^import${TRIVIA_PATTERN}*type${TRIVIA_PATTERN}*\{`);
+/**
+* Whether a static import is erased by TypeScript: every binding is
+* type-only, or it is `import type {} from "x"`, which the module record
+* reports with no entries (like a runtime `import {} from "x"`).
+*/
+function isTypeOnlyImport(code, statement) {
+	if (statement.entries.length > 0) return statement.entries.every((entry) => entry.isType);
+	return EMPTY_TYPE_IMPORT_RE.test(code.slice(statement.start, statement.moduleRequest.start));
+}
+/**
+* The value of the string literal or expression-free template literal spanning
+* `span`, or `null` for any other expression. The module record gives only the
+* span of a dynamic import's source.
+*/
+function quotedStringAt(code, span) {
+	const text = code.slice(span.start, span.end);
+	const match = /^(?:"([^"\\\r\n]*)"|'([^'\\\r\n]*)'|`([^`\\$]*)`)$/.exec(text);
+	if (match) return match[1] ?? match[2] ?? match[3];
+	if (!/^["'`]/.test(text)) return null;
+	const result = parseSync(PARSE_FILENAME, `(${text})`, PROGRAM_PARSER_DEFAULTS);
+	const statement = result.errors.length > 0 ? void 0 : result.program.body[0];
+	return statement?.type === "ExpressionStatement" ? staticStringValue(statement.expression) : null;
+}
 const SKIP_CHILD_KEYS = /* @__PURE__ */ new Set([
 	"type",
 	"parent",
@@ -137,4 +225,4 @@ function collectBindingNames(node, target) {
 	}
 }
 //#endregion
-export { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, booleanLiteralValue, collectBindingNames, forEachAstChild, getAstName, isIdentifierNamed, mayContainDynamicImport, scriptParserLanguage, staticStringValue, stringLiteralValue, unwrapExpression, walkAst };
+export { DYNAMIC_IMPORT_PRESCAN, LEADING_TRIVIA_RE, SCRIPT_MODULE_ID_RE, TRIVIA_PATTERN, booleanLiteralValue, collectBindingNames, forEachAstChild, getAstName, hasImportAttributes, isIdentifierNamed, isTypeOnlyImport, mayContainDynamicImport, parseModuleRecord, parseProgram, parseProgramAsync, quotedStringAt, scriptParserLanguage, staticStringValue, stringLiteralValue, unwrapExpression, walkAst };

package/dist/plugins/cloudflare-dev-module-urls.d.ts

@@ -0,0 +1,41 @@
+import { Plugin } from "vite";
+//#region src/plugins/cloudflare-dev-module-urls.d.ts
+/**
+ * Vite's internal middlewares that serve module requests (`/@vite/client`,
+ * `/@id/*`, JS and CSS source files) and `/@fs/*` paths, preceded by the one
+ * that strips a non-root `base` from the URL and the one that answers the HMR
+ * client's reconnect ping (`Accept: text/x-vite-ping`) with a 204 instead of
+ * the Worker rendering a page for it. If Vite renames them, none are found and
+ * every request falls through, which is the behavior without this plugin.
+ *
+ * `viteServePublicMiddleware` is deliberately excluded so that `public/` files
+ * reach the Worker and middleware, as they do in production. Without it, the
+ * transform middleware reports a public `.js` or `.css` file as an
+ * `ERR_LOAD_PUBLIC_URL` error, which is treated as a fall-through.
+ */
+export declare const VITE_MODULE_MIDDLEWARE_NAMES: Set<string>;
+/**
+ * Vite's internal middleware that serves files under the project root. Vite
+ * gives imported assets root-relative URLs (`import logo from "./logo.svg"`
+ * and CSS `url(./bg.png)` both resolve to paths like `/app/logo.svg`), and only
+ * this middleware serves them. It also serves every other project file, and a
+ * Worker route can share its path with one (e.g. an `api/` directory and an
+ * `/api/*` route handler), so it only runs for referenced assets. See
+ * `isReferencedAsset`. Navigations to a referenced asset
+ * are served too: in production its URL is under `/_next/static/`, which never
+ * reaches the Worker.
+ */
+export declare const VITE_STATIC_MIDDLEWARE_NAME = "viteServeStaticMiddleware";
+type CloudflareDevModuleUrlsOptions = {
+  /** Whether the Cloudflare Vite plugin is present. Read when the dev server starts. */
+  isEnabled: () => boolean;
+};
+/**
+ * Creates the plugin that lets Vite serve its module URLs before the Cloudflare
+ * plugin's `runWorkerFirst` routing in dev.
+ *
+ * @param options - Plugin options
+ * @returns The Vite plugin
+ */
+export declare function createCloudflareDevModuleUrlsPlugin(options: CloudflareDevModuleUrlsOptions): Plugin;
+//#endregion

package/dist/plugins/cloudflare-dev-module-urls.js

@@ -0,0 +1,271 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { isCSSRequest } from "vite";
+//#region src/plugins/cloudflare-dev-module-urls.ts
+/**
+* Serve Vite's module URLs before the Cloudflare plugin applies
+* `assets.runWorkerFirst` during development.
+*
+* `vinext init` generates `runWorkerFirst: ["/*", "!/_next/static/*", ...]` so
+* middleware runs for `public/` files. In dev, the Cloudflare plugin sends every
+* request matching those patterns to the Worker before Vite's own middlewares
+* run. That includes Vite's module URLs (`/@vite/client`, `/@id/*`, `/@fs/*`,
+* source files such as `/app/globals.css`), which have no production
+* equivalent, so the Worker answers them with the app's 404 page and nothing
+* hydrates.
+*
+* This plugin registers a pre-middleware ahead of the Cloudflare plugin's and
+* gives Vite's module-serving middlewares the first chance to handle each
+* request. Vite decides what it serves: page navigations, non-GET requests, and
+* unknown paths fall through to the Cloudflare plugin unchanged.
+*
+* The same change was made in the Cloudflare plugin itself in
+* https://github.com/cloudflare/workers-sdk/pull/16281.
+*
+* See https://github.com/cloudflare/vinext/issues/4005.
+*/
+/**
+* Vite's internal middlewares that serve module requests (`/@vite/client`,
+* `/@id/*`, JS and CSS source files) and `/@fs/*` paths, preceded by the one
+* that strips a non-root `base` from the URL and the one that answers the HMR
+* client's reconnect ping (`Accept: text/x-vite-ping`) with a 204 instead of
+* the Worker rendering a page for it. If Vite renames them, none are found and
+* every request falls through, which is the behavior without this plugin.
+*
+* `viteServePublicMiddleware` is deliberately excluded so that `public/` files
+* reach the Worker and middleware, as they do in production. Without it, the
+* transform middleware reports a public `.js` or `.css` file as an
+* `ERR_LOAD_PUBLIC_URL` error, which is treated as a fall-through.
+*/
+const VITE_MODULE_MIDDLEWARE_NAMES = /* @__PURE__ */ new Set([
+	"viteBaseMiddleware",
+	"viteHMRPingMiddleware",
+	"viteTransformMiddleware",
+	"viteServeRawFsMiddleware"
+]);
+/**
+* Vite's internal middleware that serves files under the project root. Vite
+* gives imported assets root-relative URLs (`import logo from "./logo.svg"`
+* and CSS `url(./bg.png)` both resolve to paths like `/app/logo.svg`), and only
+* this middleware serves them. It also serves every other project file, and a
+* Worker route can share its path with one (e.g. an `api/` directory and an
+* `/api/*` route handler), so it only runs for referenced assets. See
+* `isReferencedAsset`. Navigations to a referenced asset
+* are served too: in production its URL is under `/_next/static/`, which never
+* reaches the Worker.
+*/
+const VITE_STATIC_MIDDLEWARE_NAME = "viteServeStaticMiddleware";
+/**
+* The Cloudflare plugin's middleware that sends requests matching
+* `runWorkerFirst` to the Worker. It's only registered when `runWorkerFirst` is
+* set, and without it Vite's middlewares already run in their usual order.
+*/
+const CLOUDFLARE_PRE_MIDDLEWARE_NAME = "cloudflarePreMiddleware";
+/**
+* Creates the plugin that lets Vite serve its module URLs before the Cloudflare
+* plugin's `runWorkerFirst` routing in dev.
+*
+* @param options - Plugin options
+* @returns The Vite plugin
+*/
+function createCloudflareDevModuleUrlsPlugin(options) {
+	return {
+		name: "vinext:cloudflare-dev-module-urls",
+		apply: "serve",
+		enforce: "pre",
+		configureServer(server) {
+			if (!options.isEnabled()) return;
+			server.middlewares.use(function vinextCloudflareDevModuleUrls(req, res, next) {
+				runViteModuleMiddlewares(server, req, res, next);
+			});
+		}
+	};
+}
+/**
+* Runs Vite's module-serving middlewares in order, calling `next` once none of
+* them handle the request.
+*
+* @param server - The Vite dev server whose middleware stack is searched
+* @param req - The incoming request
+* @param res - The outgoing response
+* @param next - Called when no middleware handles the request, or with an error
+*/
+function runViteModuleMiddlewares(server, req, res, next) {
+	const url = req.url;
+	if (req.method !== "GET" && req.method !== "HEAD" || !url?.startsWith(server.config.base)) {
+		next();
+		return;
+	}
+	const stack = server.middlewares.stack;
+	if (!stack.some((layer) => getHandleName(layer.handle) === CLOUDFLARE_PRE_MIDDLEWARE_NAME)) {
+		next();
+		return;
+	}
+	const handles = stack.flatMap((layer) => {
+		const handle = layer.handle;
+		if (typeof handle !== "function") return [];
+		if (VITE_MODULE_MIDDLEWARE_NAMES.has(handle.name)) return [handle];
+		if (handle.name === "viteServeStaticMiddleware") {
+			const serveStatic = handle;
+			return [(req, res, next) => isReferencedAsset(server, req.url) ? serveStatic(req, res, next) : next()];
+		}
+		return [];
+	});
+	let index = 0;
+	const tryNext = (error) => {
+		if (isPublicFileLoadError(error)) {
+			req.url = url;
+			next();
+			return;
+		}
+		if (error) {
+			next(error);
+			return;
+		}
+		const handle = handles[index++];
+		if (!handle) {
+			req.url = url;
+			next();
+			return;
+		}
+		try {
+			const result = handle(req, res, tryNext);
+			if (result instanceof Promise) result.catch(next);
+		} catch (e) {
+			next(e);
+		}
+	};
+	tryNext();
+}
+function getHandleName(handle) {
+	return typeof handle === "function" ? handle.name : void 0;
+}
+/**
+* Whether the transform middleware rejected a request because it is for a
+* `public/` file, which `viteServePublicMiddleware` would normally serve.
+*/
+function isPublicFileLoadError(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ERR_LOAD_PUBLIC_URL";
+}
+/**
+* Whether a request URL, with any `base` already stripped, is the URL of an
+* asset that Vite gave to a module.
+*
+* The browser only learns an asset URL from a module Vite has transformed:
+* - The asset's own JS module (`import logo from "./logo.svg"` or `?url`),
+*   whose code is `export default "<url>"`, possibly followed by a query or
+*   fragment (`?t=` after HMR). Only files Vite treats as assets and `?url`
+*   imports count: other modules, such as JSON or `?raw` and `?inline`
+*   imports, export the file's contents, which could look like a URL.
+* - A JS module that uses `new URL("./logo.svg", import.meta.url)`, which Vite
+*   rewrites to `new URL("<url>", '' + import.meta.url)`.
+* - A stylesheet whose `url()` or `image-set()` Vite resolved.
+*
+* The importers of the asset's file in the module graph cover the last two.
+* Other project files can also be in the graph (Tailwind reports every file it
+* scans as a dependency of the stylesheet), and other imports name the file
+* with a query (`?raw` inlines its contents), but no module's code contains
+* their bare URL in one of these forms, so they keep reaching the Worker.
+*
+* @param server - The Vite dev server whose module graphs are searched
+* @param url - The request URL, with any `base` stripped
+* @returns `true` if a module emitted the URL for the file
+*/
+function isReferencedAsset(server, url) {
+	if (!url) return false;
+	const { pathname } = new URL(url, "http://localhost");
+	let decodedPathname;
+	try {
+		decodedPathname = decodeURI(pathname);
+	} catch {
+		return false;
+	}
+	const base = server.config.base;
+	let decodedBase = base;
+	try {
+		decodedBase = decodeURI(base);
+	} catch {}
+	const origin = server.config.server.origin?.replace(/\/+$/, "");
+	const urls = [...new Set([pathname, decodedPathname].flatMap((p) => {
+		const underBase = [base, decodedBase].map((b) => b + p.slice(1));
+		return [
+			p,
+			...underBase,
+			...origin ? underBase.map((u) => origin + u) : []
+		];
+	}))];
+	const file = resolveStaticFile(server, decodedPathname);
+	const isAsset = server.config.assetsInclude(file);
+	for (const environment of Object.values(server.environments)) for (const module of environment.moduleGraph.getModulesByFile(file) ?? []) {
+		const code = module.transformResult?.code;
+		if (code && isAssetUrlModule(module.url, isAsset) && urls.some((u) => containsAssetUrl(code, u))) return true;
+		for (const importer of module.importers) {
+			const code = importer.transformResult?.code;
+			if (!code) continue;
+			const css = isCSSRequest(importer.url);
+			if (urls.some((u) => css ? containsCssUrl(code, u) : code.includes(`new URL("${u}", '' + import.meta.url)`))) return true;
+		}
+	}
+	return false;
+}
+/**
+* Whether a module for the file exports the file's URL: a `?url` import, or an
+* import of an asset without Vite's `raw` or `inline` queries, which export its
+* contents.
+*/
+function isAssetUrlModule(moduleUrl, isAsset) {
+	if (/[?&]url(?:&|$)/.test(moduleUrl)) return true;
+	return isAsset && !/[?&](?:raw|inline)(?:&|$)/.test(moduleUrl);
+}
+/**
+* Whether an asset module's code exports `url` as a JS string, possibly with a
+* query or fragment, as Vite's asset plugin emits it.
+*/
+function containsAssetUrl(code, url) {
+	return [
+		`"${url}"`,
+		`"${url}?`,
+		`"${url}#`
+	].some((literal) => code.includes(literal));
+}
+/**
+* The file `viteServeStaticMiddleware` serves for a decoded pathname, applying
+* `resolve.alias` the same way it does, so the file checked is the file served.
+*
+* @param server - The Vite dev server
+* @param pathname - The decoded request pathname, with any `base` stripped
+* @returns The absolute file path
+*/
+function resolveStaticFile(server, pathname) {
+	const root = server.config.root;
+	for (const { find, replacement } of server.config.resolve.alias) if (typeof find === "string" ? pathname.startsWith(find) : find.test(pathname)) {
+		const redirected = pathname.replace(find, replacement);
+		return path.join(root, redirected.startsWith(root + "/") ? redirected.slice(root.length) : redirected);
+	}
+	return path.join(root, pathname);
+}
+/**
+* Whether stylesheet code contains `url` as a resolved `url()` or `image-set()`
+* reference, the only places Vite rewrites asset URLs in CSS. The code may be
+* the CSS itself or a JS string of it, and the URL may be quoted and may keep a
+* query or fragment from the source.
+*
+* @param code - Transformed stylesheet code
+* @param url - The URL path to look for
+* @returns `true` if the URL appears as a CSS URL
+*/
+function containsCssUrl(code, url) {
+	for (let index = code.indexOf(url); index !== -1; index = code.indexOf(url, index + 1)) {
+		const after = code[index + url.length];
+		if (after === void 0 || !/[)"',?#\\\s]/.test(after)) continue;
+		const start = Math.max(0, index - 32);
+		const before = code.slice(start, index);
+		const urlFunction = /(^|[^\w\-\u0080-\uffff])url\(\s*\\?["']?$/.exec(before);
+		if (urlFunction && (urlFunction[1] !== "" || start === 0)) return true;
+		if (!/["']$/.test(before)) continue;
+		const imageSet = code.lastIndexOf("image-set(", index);
+		if (imageSet !== -1 && !/[;{}]/.test(code.slice(imageSet, index))) return true;
+	}
+	return false;
+}
+//#endregion
+export { VITE_MODULE_MIDDLEWARE_NAMES, VITE_STATIC_MIDDLEWARE_NAME, createCloudflareDevModuleUrlsPlugin };

package/dist/plugins/commonjs-esm-facade.js

@@ -1,4 +1,4 @@
-import { parseAst } from "vite";
+import { parseProgram } from "./ast-utils.js";
 import MagicString from "magic-string";
 //#region src/plugins/commonjs-esm-facade.ts
 const EXPORT_FACADE_START = "/* [vite-plugin-commonjs] export-statement-S */";
@@ -9,7 +9,7 @@ function hasEsmExports(code) {
 	if (!EXPORT_KEYWORD_RE.test(code)) return false;
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = parseProgram(code);
 	} catch {
 		return false;
 	}

package/dist/plugins/css-module-imports.js

@@ -1,32 +1,25 @@
-import { SCRIPT_MODULE_ID_RE, scriptParserLanguage } from "./ast-utils.js";
+import { LEADING_TRIVIA_RE, SCRIPT_MODULE_ID_RE, hasImportAttributes, parseModuleRecord, scriptParserLanguage } from "./ast-utils.js";
 import { magicStringTransformResult } from "./transform-result.js";
-import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/css-module-imports.ts
 const CSS_MODULE_RE = /\.module\.(?:css|scss|sass)$/i;
 const CSS_MODULE_HINT_RE = /\.module\.(?:css|scss|sass)/i;
 const MDX_RE = /\.mdx$/i;
 function rewriteCssModuleNamespaceImports(code, lang = "js") {
-	let ast;
-	try {
-		ast = parseAst(code, { lang });
-	} catch {
-		return null;
-	}
+	const record = parseModuleRecord(code, lang);
+	if (!record) return null;
 	let output = null;
-	for (const statement of ast.body) {
-		if (statement.type !== "ImportDeclaration") continue;
-		if (statement.importKind === "type") continue;
-		if (typeof statement.source?.value !== "string") continue;
-		if (!CSS_MODULE_RE.test(statement.source.value)) continue;
-		if (statement.attributes && statement.attributes.length > 0) continue;
-		if (statement.specifiers?.length !== 1) continue;
-		const specifier = statement.specifiers[0];
-		if (specifier.type !== "ImportNamespaceSpecifier") continue;
-		if (typeof specifier.start !== "number" || typeof specifier.end !== "number") continue;
-		if (typeof specifier.local?.name !== "string") continue;
+	for (const statement of record.staticImports) {
+		if (!CSS_MODULE_RE.test(statement.moduleRequest.value)) continue;
+		if (hasImportAttributes(code, statement.moduleRequest.end, statement.end)) continue;
+		if (statement.entries.length !== 1) continue;
+		const [entry] = statement.entries;
+		if (entry.isType || entry.importName.kind !== "NamespaceObject") continue;
+		const afterImport = statement.start + 6;
+		const starIndex = afterImport + (LEADING_TRIVIA_RE.exec(code.slice(afterImport, entry.localName.start))?.[0].length ?? 0);
+		if (code[starIndex] !== "*") continue;
 		output ??= new MagicString(code);
-		output.overwrite(specifier.start, specifier.end, specifier.local.name);
+		output.overwrite(starIndex, entry.localName.end, entry.localName.value);
 	}
 	if (!output) return null;
 	return magicStringTransformResult(output, { hires: true });

package/dist/plugins/dynamic-preload-metadata.js

@@ -1,11 +1,10 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { collectBindingNames, forEachAstChild, stringLiteralValue, walkAst } from "./ast-utils.js";
+import { collectBindingNames, forEachAstChild, parseProgram, stringLiteralValue, walkAst } from "./ast-utils.js";
 import { hasTrailingComma } from "../utils/has-trailing-comma.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { stripViteModuleQuery } from "../utils/path.js";
 import { isForeignNodeModule } from "../utils/package-name.js";
 import { relativeToRoot, relativeWithinRoot, tryRealpathSync } from "../build/ssr-manifest.js";
-import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/dynamic-preload-metadata.ts
 function isNextDynamicSource(source) {
@@ -239,7 +238,7 @@ async function transformNextDynamicPreloadMetadata(code, id, root, resolveDynami
 	if (!code.includes("next/dynamic")) return null;
 	let ast;
 	try {
-		ast = parseAst(code);
+		ast = parseProgram(code);
 	} catch (error) {
 		if (typeof process !== "undefined" && process.env?.DEBUG?.includes("vinext")) console.debug(`[vinext] dynamic-preload-metadata: failed to parse ${id}:`, error);
 		return null;

package/dist/plugins/extensionless-dynamic-import.js

@@ -1,13 +1,12 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
-import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, scriptParserLanguage, walkAst } from "./ast-utils.js";
+import { DYNAMIC_IMPORT_PRESCAN, SCRIPT_MODULE_ID_RE, parseProgram, scriptParserLanguage, walkAst } from "./ast-utils.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { NODE_MODULES_PATH_RE } from "../utils/path.js";
 import { createTransformCache } from "./transform-cache.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
-import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/extensionless-dynamic-import.ts
 const MODULE_EXTENSIONS = [
@@ -63,7 +62,7 @@ function transformExtensionlessImports(code, id, config) {
 	const lang = scriptParserLanguage(id);
 	let ast;
 	try {
-		ast = parseAst(code, { lang });
+		ast = parseProgram(code, { lang });
 	} catch {
 		return null;
 	}

package/dist/plugins/fonts.d.ts

@@ -31,7 +31,7 @@ export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
 export declare function _rewriteCachedFontCssToServedUrls(css: string, assetsDir?: string): string;
 /**
  * Safely parse a static JS object literal string into a plain object.
- * Uses Vite's parseAst (Rollup/acorn) so no code is ever evaluated.
+ * Uses Vite's bundled oxc parser so no code is ever evaluated.
  * Returns null if the expression contains anything dynamic (function calls,
  * template literals, identifiers, computed properties, etc.).
  *

package/dist/plugins/fonts.js

@@ -1,5 +1,6 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { escapeRegExp } from "../utils/regex.js";
+import { parseProgram } from "./ast-utils.js";
 import { lastSignificantChar } from "../utils/has-trailing-comma.js";
 import { magicStringTransformResult } from "./transform-result.js";
 import { buildFallbackFontFace, getFallbackFontOverrideMetrics } from "../build/google-fonts/fallback-metrics.js";
@@ -10,7 +11,6 @@ import { findFontFilesInCss } from "../build/google-fonts/find-font-files-in-css
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
 import { CONTENT_TYPES } from "../server/static-file-cache.js";
 import fs from "node:fs";
-import { parseAst } from "vite";
 import MagicString from "magic-string";
 //#region src/plugins/fonts.ts
 /**
@@ -127,7 +127,7 @@ function _rewriteCachedFontCssToServedUrls(css, assetsDir = DEFAULT_ASSETS_DIR)
 const DEFAULT_ASSETS_DIR = ASSET_PREFIX_URL_DIR;
 /**
 * Safely parse a static JS object literal string into a plain object.
-* Uses Vite's parseAst (Rollup/acorn) so no code is ever evaluated.
+* Uses Vite's bundled oxc parser so no code is ever evaluated.
 * Returns null if the expression contains anything dynamic (function calls,
 * template literals, identifiers, computed properties, etc.).
 *
@@ -137,7 +137,7 @@ const DEFAULT_ASSETS_DIR = ASSET_PREFIX_URL_DIR;
 function parseStaticObjectLiteral(objectStr) {
 	let ast;
 	try {
-		ast = parseAst(`(${objectStr})`);
+		ast = parseProgram(`(${objectStr})`);
 	} catch {
 		return null;
 	}