astro 4.7.0 → 4.8.0

package/dist/transitions/swap-functions.js

@@ -0,0 +1,105 @@
+const PERSIST_ATTR = "data-astro-transition-persist";
+function deselectScripts(doc) {
+  for (const s1 of document.scripts) {
+    for (const s2 of doc.scripts) {
+      if (
+        // Check if the script should be rerun regardless of it being the same
+        !s2.hasAttribute("data-astro-rerun") && // Inline
+        (!s1.src && s1.textContent === s2.textContent || // External
+        s1.src && s1.type === s2.type && s1.src === s2.src)
+      ) {
+        s2.dataset.astroExec = "";
+        break;
+      }
+    }
+  }
+}
+function swapRootAttributes(doc) {
+  const html = document.documentElement;
+  const astroAttributes = [...html.attributes].filter(
+    ({ name }) => (html.removeAttribute(name), name.startsWith("data-astro-"))
+  );
+  [...doc.documentElement.attributes, ...astroAttributes].forEach(
+    ({ name, value }) => html.setAttribute(name, value)
+  );
+}
+function swapHeadElements(doc) {
+  for (const el of Array.from(document.head.children)) {
+    const newEl = persistedHeadElement(el, doc);
+    if (newEl) {
+      newEl.remove();
+    } else {
+      el.remove();
+    }
+  }
+  document.head.append(...doc.head.children);
+}
+function swapBodyElement(newElement, oldElement) {
+  oldElement.replaceWith(newElement);
+  for (const el of oldElement.querySelectorAll(`[${PERSIST_ATTR}]`)) {
+    const id = el.getAttribute(PERSIST_ATTR);
+    const newEl = newElement.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+    if (newEl) {
+      newEl.replaceWith(el);
+      if (newEl.localName === "astro-island" && shouldCopyProps(el)) {
+        el.setAttribute("ssr", "");
+        el.setAttribute("props", newEl.getAttribute("props"));
+      }
+    }
+  }
+}
+const saveFocus = () => {
+  const activeElement = document.activeElement;
+  if (activeElement?.closest(`[${PERSIST_ATTR}]`)) {
+    if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
+      const start = activeElement.selectionStart;
+      const end = activeElement.selectionEnd;
+      return () => restoreFocus({ activeElement, start, end });
+    }
+    return () => restoreFocus({ activeElement });
+  } else {
+    return () => restoreFocus({ activeElement: null });
+  }
+};
+const restoreFocus = ({ activeElement, start, end }) => {
+  if (activeElement) {
+    activeElement.focus();
+    if (activeElement instanceof HTMLInputElement || activeElement instanceof HTMLTextAreaElement) {
+      if (typeof start === "number") activeElement.selectionStart = start;
+      if (typeof end === "number") activeElement.selectionEnd = end;
+    }
+  }
+};
+const persistedHeadElement = (el, newDoc) => {
+  const id = el.getAttribute(PERSIST_ATTR);
+  const newEl = id && newDoc.head.querySelector(`[${PERSIST_ATTR}="${id}"]`);
+  if (newEl) {
+    return newEl;
+  }
+  if (el.matches("link[rel=stylesheet]")) {
+    const href = el.getAttribute("href");
+    return newDoc.head.querySelector(`link[rel=stylesheet][href="${href}"]`);
+  }
+  return null;
+};
+const shouldCopyProps = (el) => {
+  const persistProps = el.dataset.astroTransitionPersistProps;
+  return persistProps == null || persistProps === "false";
+};
+const swap = (doc) => {
+  deselectScripts(doc);
+  swapRootAttributes(doc);
+  swapHeadElements(doc);
+  const restoreFocusFunction = saveFocus();
+  swapBodyElement(doc.body, document.body);
+  restoreFocusFunction();
+};
+export {
+  deselectScripts,
+  restoreFocus,
+  saveFocus,
+  swap,
+  swapBodyElement,
+  swapHeadElements,
+  swapRootAttributes
+};

package/dist/vite-plugin-astro/compile.js

@@ -71,8 +71,7 @@ async function enhanceCompileError({
   const scannedFrontmatter = frontmatterRE.exec(source);
   if (scannedFrontmatter) {
     const frontmatter = scannedFrontmatter[1].replace(/\breturn\b/g, "throw");
-    if (lineText && !frontmatter.includes(lineText))
-      throw err;
+    if (lineText && !frontmatter.includes(lineText)) throw err;
     try {
       await transformWithEsbuild(frontmatter, id, {
         loader: "ts",

package/dist/vite-plugin-astro/hmr.js

@@ -7,8 +7,7 @@ async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
     }
   }
   const oldCode = astroFileToCompileMetadata.get(ctx.file)?.originalCode;
-  if (oldCode == null)
-    return;
+  if (oldCode == null) return;
   const newCode = await ctx.read();
   if (isStyleOnlyChanged(oldCode, newCode)) {
     logger.debug("watch", "style-only change");
@@ -19,26 +18,22 @@ async function handleHotUpdate(ctx, { logger, astroFileToCompileMetadata }) {
 const scriptRE = /<script(?:\s.*?)?>.*?<\/script>/gs;
 const styleRE = /<style(?:\s.*?)?>.*?<\/style>/gs;
 function isStyleOnlyChanged(oldCode, newCode) {
-  if (oldCode === newCode)
-    return false;
+  if (oldCode === newCode) return false;
   let oldFrontmatter = "";
   let newFrontmatter = "";
   oldCode = oldCode.replace(frontmatterRE, (m) => (oldFrontmatter = m, ""));
   newCode = newCode.replace(frontmatterRE, (m) => (newFrontmatter = m, ""));
-  if (oldFrontmatter !== newFrontmatter)
-    return false;
+  if (oldFrontmatter !== newFrontmatter) return false;
   const oldScripts = [];
   const newScripts = [];
   oldCode = oldCode.replace(scriptRE, (m) => (oldScripts.push(m), ""));
   newCode = newCode.replace(scriptRE, (m) => (newScripts.push(m), ""));
-  if (!isArrayEqual(oldScripts, newScripts))
-    return false;
+  if (!isArrayEqual(oldScripts, newScripts)) return false;
   const oldStyles = [];
   const newStyles = [];
   oldCode = oldCode.replace(styleRE, (m) => (oldStyles.push(m), ""));
   newCode = newCode.replace(styleRE, (m) => (newStyles.push(m), ""));
-  if (oldCode !== newCode)
-    return false;
+  if (oldCode !== newCode) return false;
   return oldStyles.length === newStyles.length && !isArrayEqual(oldStyles, newStyles);
 }
 function isArrayEqual(a, b) {

package/dist/vite-plugin-astro/index.js

@@ -57,8 +57,7 @@ function astro({ settings, logger }) {
       if (!compileMetadata) {
         if (server) {
           const code = await loadId(server.pluginContainer, filename);
-          if (code != null)
-            await compile(code, filename);
+          if (code != null) await compile(code, filename);
         } else if (config.experimental.contentCollectionCache) {
           await this.load({
             id: filename,
@@ -191,8 +190,7 @@ File: ${id}`
   return [prePlugin, normalPlugin];
 }
 function appendSourceMap(content, map) {
-  if (!map)
-    return content;
+  if (!map) return content;
   return `${content}
 //# sourceMappingURL=data:application/json;charset=utf-8;base64,${Buffer.from(
     map

package/dist/vite-plugin-astro-server/pipeline.d.ts

@@ -1,4 +1,4 @@
-import type { AstroSettings, ComponentInstance, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
+import type { AstroSettings, ComponentInstance, ManifestData, RewritePayload, RouteData, SSRLoadedRenderer, SSRManifest } from '../@types/astro.js';
 import type { HeadElements } from '../core/base-pipeline.js';
 import type { Logger } from '../core/logger/core.js';
 import type { ModuleLoader } from '../core/module-loader/index.js';
@@ -10,10 +10,15 @@ export declare class DevPipeline extends Pipeline {
     readonly settings: AstroSettings;
     readonly config: import("../@types/astro.js").AstroConfig;
     renderers: SSRLoadedRenderer[];
+    manifestData: ManifestData | undefined;
+    componentInterner: WeakMap<RouteData, ComponentInstance>;
     private constructor();
-    static create({ loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
+    static create(manifestData: ManifestData, { loader, logger, manifest, settings, }: Pick<DevPipeline, 'loader' | 'logger' | 'manifest' | 'settings'>): DevPipeline;
     headElements(routeData: RouteData): Promise<HeadElements>;
     componentMetadata(routeData: RouteData): Promise<Map<string, import("../@types/astro.js").SSRComponentMetadata>>;
-    preload(filePath: URL): Promise<ComponentInstance>;
+    preload(routeData: RouteData, filePath: URL): Promise<ComponentInstance>;
     clearRouteCache(): void;
+    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
+    tryRewrite(payload: RewritePayload): Promise<[RouteData, ComponentInstance]>;
+    setManifestData(manifestData: ManifestData): void;
 }

package/dist/vite-plugin-astro-server/pipeline.js

@@ -1,11 +1,11 @@
-import url from "node:url";
+import { fileURLToPath } from "node:url";
 import { getInfoOutput } from "../cli/info/index.js";
 import { ASTRO_VERSION, DEFAULT_404_COMPONENT } from "../core/constants.js";
 import { enhanceViteSSRError } from "../core/errors/dev/index.js";
-import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { RouteNotFound } from "../core/errors/errors-data.js";
+import { AggregateError, AstroError, CSSError, MarkdownError } from "../core/errors/index.js";
 import { Pipeline, loadRenderer } from "../core/render/index.js";
-import { isPage, resolveIdToUrl, viteID } from "../core/util.js";
-import { isServerLikeOutput } from "../prerender/utils.js";
+import { isPage, isServerLikeOutput, resolveIdToUrl, viteID } from "../core/util.js";
 import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
 import { getStylesForURL } from "./css.js";
 import { getComponentMetadata } from "./metadata.js";
@@ -28,13 +28,17 @@ class DevPipeline extends Pipeline {
   // renderers are loaded on every request,
   // so it needs to be mutable here unlike in other environments
   renderers = new Array();
-  static create({
+  manifestData;
+  componentInterner = /* @__PURE__ */ new WeakMap();
+  static create(manifestData, {
     loader,
     logger,
     manifest,
     settings
   }) {
-    return new DevPipeline(loader, logger, manifest, settings);
+    const pipeline = new DevPipeline(loader, logger, manifest, settings);
+    pipeline.manifestData = manifestData;
+    return pipeline;
   }
   async headElements(routeData) {
     const {
@@ -43,7 +47,7 @@ class DevPipeline extends Pipeline {
       mode,
       settings
     } = this;
-    const filePath = new URL(`./${routeData.component}`, root);
+    const filePath = new URL(`${routeData.component}`, root);
     const { scripts } = settings.config.experimental.directRenderScript ? { scripts: /* @__PURE__ */ new Set() } : await getScriptsForURL(filePath, settings.config.root, loader);
     if (isPage(filePath, settings) && mode === "development") {
       scripts.add({
@@ -54,7 +58,7 @@ class DevPipeline extends Pipeline {
         const src = await resolveIdToUrl(loader, "astro/runtime/client/dev-toolbar/entrypoint.js");
         scripts.add({ props: { type: "module", src }, children: "" });
         const additionalMetadata = {
-          root: url.fileURLToPath(settings.config.root),
+          root: fileURLToPath(settings.config.root),
           version: ASTRO_VERSION,
           latestAstroVersion: settings.latestAstroVersion,
           debugInfo: await getInfoOutput({ userConfig: settings.config, print: false })
@@ -93,10 +97,10 @@ class DevPipeline extends Pipeline {
       config: { root },
       loader
     } = this;
-    const filePath = new URL(`./${routeData.component}`, root);
+    const filePath = new URL(`${routeData.component}`, root);
     return getComponentMetadata(filePath, loader);
   }
-  async preload(filePath) {
+  async preload(routeData, filePath) {
     const { loader } = this;
     if (filePath.href === new URL(DEFAULT_404_COMPONENT, this.config.root).href) {
       return { default: default404Page };
@@ -105,7 +109,9 @@ class DevPipeline extends Pipeline {
     const renderers_ = await Promise.all(renderers__);
     this.renderers = renderers_.filter((r) => Boolean(r));
     try {
-      return await loader.import(viteID(filePath));
+      const componentInstance = await loader.import(viteID(filePath));
+      this.componentInterner.set(routeData, componentInstance);
+      return componentInstance;
     } catch (error) {
       if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
         throw error;
@@ -115,6 +121,48 @@ class DevPipeline extends Pipeline {
   }
   clearRouteCache() {
     this.routeCache.clearAll();
+    this.componentInterner = /* @__PURE__ */ new WeakMap();
+  }
+  async getComponentByRoute(routeData) {
+    const component = this.componentInterner.get(routeData);
+    if (component) {
+      return component;
+    } else {
+      const filePath = new URL(`${routeData.component}`, this.config.root);
+      return await this.preload(routeData, filePath);
+    }
+  }
+  async tryRewrite(payload) {
+    let foundRoute;
+    if (!this.manifestData) {
+      throw new Error("Missing manifest data. This is an internal error, please file an issue.");
+    }
+    for (const route of this.manifestData.routes) {
+      if (payload instanceof URL) {
+        if (route.pattern.test(payload.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (payload instanceof Request) {
+        const url = new URL(payload.url);
+        if (route.pattern.test(url.pathname)) {
+          foundRoute = route;
+          break;
+        }
+      } else if (route.pattern.test(decodeURI(payload))) {
+        foundRoute = route;
+        break;
+      }
+    }
+    if (foundRoute) {
+      const componentInstance = await this.getComponentByRoute(foundRoute);
+      return [foundRoute, componentInstance];
+    } else {
+      throw new AstroError(RouteNotFound);
+    }
+  }
+  setManifestData(manifestData) {
+    this.manifestData = manifestData;
   }
 }
 export {

package/dist/vite-plugin-astro-server/plugin.js

@@ -23,16 +23,17 @@ function createVitePluginAstroServer({
     configureServer(viteServer) {
       const loader = createViteLoader(viteServer);
       const manifest = createDevelopmentManifest(settings);
-      const pipeline = DevPipeline.create({ loader, logger, manifest, settings });
       let manifestData = ensure404Route(
         createRouteManifest({ settings, fsMod }, logger)
       );
+      const pipeline = DevPipeline.create(manifestData, { loader, logger, manifest, settings });
       const controller = createController({ loader });
       const localStorage = new AsyncLocalStorage();
       function rebuildManifest(needsManifestRebuild) {
         pipeline.clearRouteCache();
         if (needsManifestRebuild) {
           manifestData = ensure404Route(createRouteManifest({ settings }, logger));
+          pipeline.setManifestData(manifestData);
         }
       }
       viteServer.watcher.on("add", rebuildManifest.bind(null, true));
@@ -79,10 +80,8 @@ function createVitePluginAstroServer({
       };
     },
     transform(code, id, opts = {}) {
-      if (opts.ssr)
-        return;
-      if (!id.includes("vite/dist/client/client.mjs"))
-        return;
+      if (opts.ssr) return;
+      if (!id.includes("vite/dist/client/client.mjs")) return;
       return patchOverlay(code);
     }
   };
@@ -105,7 +104,7 @@ function createDevelopmentManifest(settings) {
     assets: /* @__PURE__ */ new Set(),
     entryModules: {},
     routes: [],
-    adapterName: "",
+    adapterName: settings?.adapter?.name || "",
     clientDirectives: settings.clientDirectives,
     renderers: [],
     base: settings.config.base,
@@ -115,6 +114,7 @@ function createDevelopmentManifest(settings) {
     inlinedScripts: /* @__PURE__ */ new Map(),
     i18n: i18nManifest,
     checkOrigin: settings.config.experimental.security?.csrfProtection?.origin ?? false,
+    rewritingEnabled: settings.config.experimental.rewriting,
     middleware(_, next) {
       return next();
     }

package/dist/vite-plugin-astro-server/response.js

@@ -78,8 +78,7 @@ async function writeWebResponse(res, webResponse) {
       });
       while (true) {
         const { done, value } = await reader.read();
-        if (done)
-          break;
+        if (done) break;
         if (value) {
           res.write(value);
         }

package/dist/vite-plugin-astro-server/route.js

@@ -78,7 +78,7 @@ ${AstroErrorData.NoMatchingStaticPathFound.hint(possibleRoutes)}`
   }
   if (custom404) {
     const filePath = new URL(`./${custom404.component}`, config.root);
-    const preloadedComponent = await pipeline.preload(filePath);
+    const preloadedComponent = await pipeline.preload(custom404, filePath);
     return {
       route: custom404,
       filePath,
@@ -139,40 +139,38 @@ async function handleRoute({
       if (!pathNameHasLocale && pathname !== "/") {
         return handle404Response(origin, incomingRequest, incomingResponse);
       }
-      request = createRequest({
-        base: config.base,
-        url,
-        headers: incomingRequest.headers,
-        logger,
-        // no route found, so we assume the default for rendering the 404 page
-        staticLike: config.output === "static" || config.output === "hybrid"
-      });
-      route = {
-        component: "",
-        generate(_data) {
-          return "";
-        },
-        params: [],
-        // Disable eslint as we only want to generate an empty RegExp
-        // eslint-disable-next-line prefer-regex-literals
-        pattern: new RegExp(""),
-        prerender: false,
-        segments: [],
-        type: "fallback",
-        route: "",
-        fallbackRoutes: [],
-        isIndex: false
-      };
-      renderContext = RenderContext.create({
-        pipeline,
-        pathname,
-        middleware,
-        request,
-        routeData: route
-      });
-    } else {
-      return handle404Response(origin, incomingRequest, incomingResponse);
     }
+    request = createRequest({
+      base: config.base,
+      url,
+      headers: incomingRequest.headers,
+      logger,
+      // no route found, so we assume the default for rendering the 404 page
+      staticLike: config.output === "static" || config.output === "hybrid"
+    });
+    route = {
+      component: "",
+      generate(_data) {
+        return "";
+      },
+      params: [],
+      // Disable eslint as we only want to generate an empty RegExp
+      // eslint-disable-next-line prefer-regex-literals
+      pattern: new RegExp(""),
+      prerender: false,
+      segments: [],
+      type: "fallback",
+      route: "",
+      fallbackRoutes: [],
+      isIndex: false
+    };
+    renderContext = RenderContext.create({
+      pipeline,
+      pathname,
+      middleware,
+      request,
+      routeData: route
+    });
   } else {
     const filePath = matchedRoute.filePath;
     const { preloadedComponent } = matchedRoute;
@@ -188,8 +186,7 @@ async function handleRoute({
       staticLike: config.output === "static" || route.prerender
     });
     for (const [name, value] of Object.entries(config.server.headers ?? {})) {
-      if (value)
-        incomingResponse.setHeader(name, value);
+      if (value) incomingResponse.setHeader(name, value);
     }
     options = {
       pipeline,
@@ -258,12 +255,9 @@ async function handleRoute({
   await writeSSRResult(request, response, incomingResponse);
 }
 function getStatus(matchedRoute) {
-  if (!matchedRoute)
-    return 404;
-  if (matchedRoute.route.route === "/404")
-    return 404;
-  if (matchedRoute.route.route === "/500")
-    return 500;
+  if (!matchedRoute) return 404;
+  if (matchedRoute.route.route === "/404") return 404;
+  if (matchedRoute.route.route === "/500") return 500;
 }
 export {
   handleRoute,

package/dist/vite-plugin-astro-server/vite.js

@@ -15,7 +15,7 @@ async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ ne
     loader.getModulesByFile(id) ?? /* @__PURE__ */ new Set()
   ) : (
     // For non-root files, we're safe to pull from "getModuleById" based on testing.
-    // TODO: Find better invalidation strat to use "getModuleById" in all cases!
+    // TODO: Find better invalidation strategy to use "getModuleById" in all cases!
     /* @__PURE__ */ new Set([loader.getModuleById(id)])
   );
   for (const entry of moduleEntriesForId) {
@@ -24,14 +24,12 @@ async function* crawlGraph(loader, _id, isRootFile, scanned = /* @__PURE__ */ ne
     }
     if (id === entry.id) {
       scanned.add(id);
-      const entryIsStyle = isCSSRequest(id);
+      if (isCSSRequest(id)) {
+        continue;
+      }
       for (const importedModule of entry.importedModules) {
-        if (!importedModule.id)
-          continue;
+        if (!importedModule.id) continue;
         const importedModulePathname = importedModule.id.replace(STRIP_QUERY_PARAMS_REGEX, "");
-        if (entryIsStyle && !isCSSRequest(importedModulePathname)) {
-          continue;
-        }
         const isFileTypeNeedingSSR = fileExtensionsToSSR.has(npath.extname(importedModulePathname));
         const isPropagationStoppingPoint = ASTRO_PROPAGATED_ASSET_REGEX.test(importedModule.id);
         if (isFileTypeNeedingSSR && // Should not SSR a module with ?astroPropagatedAssets

package/dist/vite-plugin-config-alias/index.js

@@ -2,11 +2,9 @@ import path from "node:path";
 import { normalizePath } from "vite";
 const getConfigAlias = (settings) => {
   const { tsConfig, tsConfigPath } = settings;
-  if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions)
-    return null;
+  if (!tsConfig || !tsConfigPath || !tsConfig.compilerOptions) return null;
   const { baseUrl, paths } = tsConfig.compilerOptions;
-  if (!baseUrl)
-    return null;
+  if (!baseUrl) return null;
   const resolvedBaseUrl = path.resolve(path.dirname(tsConfigPath), baseUrl);
   const aliases = [];
   if (paths) {
@@ -33,8 +31,7 @@ function configAliasVitePlugin({
   settings
 }) {
   const configAlias = getConfigAlias(settings);
-  if (!configAlias)
-    return null;
+  if (!configAlias) return null;
   const plugin = {
     name: "astro:tsconfig-alias",
     // use post to only resolve ids that all other plugins before it can't
@@ -43,8 +40,7 @@ function configAliasVitePlugin({
       patchCreateResolver(config, plugin);
     },
     async resolveId(id, importer, options) {
-      if (isVirtualId(id))
-        return;
+      if (isVirtualId(id)) return;
       for (const alias of configAlias) {
         if (alias.find.test(id)) {
           const updatedId = id.replace(alias.find, alias.replacement);
@@ -52,8 +48,7 @@ function configAliasVitePlugin({
             return updatedId;
           }
           const resolved = await this.resolve(updatedId, importer, { skipSelf: true, ...options });
-          if (resolved)
-            return resolved;
+          if (resolved) return resolved;
         }
       }
     }
@@ -80,15 +75,13 @@ function patchCreateResolver(config, postPlugin) {
         ssr
       };
       const result = await resolver.apply(_createResolver, args2);
-      if (result)
-        return result;
+      if (result) return result;
       const resolved = await postPlugin.resolveId.apply(fakePluginContext, [
         id,
         importer,
         fakeResolveIdOpts
       ]);
-      if (resolved)
-        return resolved;
+      if (resolved) return resolved;
     };
   };
 }

package/dist/vite-plugin-head/index.js

@@ -4,8 +4,7 @@ const injectExp = /(?:^\/\/|\/\/!)\s*astro-head-inject/;
 function configHeadVitePlugin() {
   let server;
   function propagateMetadata(id, prop, value, seen = /* @__PURE__ */ new Set()) {
-    if (seen.has(id))
-      return;
+    if (seen.has(id)) return;
     seen.add(id);
     const mod = server.moduleGraph.getModuleById(id);
     const info = this.getModuleInfo(id);
@@ -80,8 +79,7 @@ function astroHeadBuildPlugin(internals) {
             generateBundle(_opts, bundle) {
               const map = internals.componentMetadata;
               function getOrCreateMetadata(id) {
-                if (map.has(id))
-                  return map.get(id);
+                if (map.has(id)) return map.get(id);
                 const metadata = {
                   propagation: "none",
                   containsHead: false
@@ -90,8 +88,7 @@ function astroHeadBuildPlugin(internals) {
                 return metadata;
               }
               for (const [, output] of Object.entries(bundle)) {
-                if (output.type !== "chunk")
-                  continue;
+                if (output.type !== "chunk") continue;
                 for (const [id, mod] of Object.entries(output.modules)) {
                   const modinfo = this.getModuleInfo(id);
                   if (modinfo) {

package/dist/vite-plugin-html/index.js

@@ -6,8 +6,7 @@ function html() {
       options.plugins = options.plugins?.filter((p) => p.name !== "vite:build-html");
     },
     async transform(source, id) {
-      if (!id.endsWith(".html"))
-        return;
+      if (!id.endsWith(".html")) return;
       return await transform(source, id);
     }
   };

package/dist/vite-plugin-html/transform/escape.js

@@ -12,14 +12,12 @@ const rehypeEscape = ({ s }) => {
           );
         }
       } else if (node.type === "element") {
-        if (!node.properties)
-          return;
+        if (!node.properties) return;
         for (let [key, value] of Object.entries(node.properties)) {
           key = key.replace(/([A-Z])/g, "-$1").toLowerCase();
           const newKey = needsEscape(key) ? escapeTemplateLiteralCharacters(key) : key;
           const newValue = needsEscape(value) ? escapeTemplateLiteralCharacters(value) : value;
-          if (newKey === key && newValue === value)
-            continue;
+          if (newKey === key && newValue === value) continue;
           replaceAttribute(s, node, key, value === "" ? newKey : `${newKey}="${newValue}"`);
         }
       }

package/dist/vite-plugin-html/transform/slots.js

@@ -4,8 +4,7 @@ const rehypeSlots = ({ s }) => {
   return (tree, file) => {
     visit(tree, (node) => {
       if (node.type === "element" && node.tagName === "slot") {
-        if (typeof node.properties?.["is:inline"] !== "undefined")
-          return;
+        if (typeof node.properties?.["is:inline"] !== "undefined") return;
         const name = node.properties?.["name"] ?? "default";
         const start = node.position?.start.offset ?? 0;
         const end = node.position?.end.offset ?? 0;

package/dist/vite-plugin-html/transform/utils.js

@@ -3,8 +3,7 @@ function replaceAttribute(s, node, key, newValue) {
   splitAttrsTokenizer.lastIndex = 0;
   const text = s.original.slice(node.position?.start.offset ?? 0, node.position?.end.offset ?? 0).toString();
   const offset = text.indexOf(key);
-  if (offset === -1)
-    return;
+  if (offset === -1) return;
   const start = node.position.start.offset + offset;
   const tokens = text.slice(offset).split(splitAttrsTokenizer);
   const token = tokens[0].replace(/([^>])>[\s\S]*$/gm, "$1");