astro 1.1.5 → 1.1.8

package/dist/@types/astro.d.ts

@@ -843,7 +843,7 @@ export interface MarkdownInstance<T extends Record<string, any>> {
     getHeaders(): void;
     default: AstroComponentFactory;
 }
-export interface MDXInstance<T> extends Omit<MarkdownInstance<T>, 'rawContent' | 'compiledContent'> {
+export interface MDXInstance<T extends Record<string, any>> extends Omit<MarkdownInstance<T>, 'rawContent' | 'compiledContent'> {
     /** MDX does not support rawContent! If you need to read the Markdown contents to calculate values (ex. reading time), we suggest injecting frontmatter via remark plugins. Learn more on our docs: https://docs.astro.build/en/guides/integrations-guide/mdx/#inject-frontmatter-via-remark-or-rehype-plugins */
     rawContent: never;
     /** MDX does not support compiledContent! If you need to read the HTML contents to calculate values (ex. reading time), we suggest injecting frontmatter via rehype plugins. Learn more on our docs: https://docs.astro.build/en/guides/integrations-guide/mdx/#inject-frontmatter-via-remark-or-rehype-plugins */
@@ -860,7 +860,7 @@ export interface MarkdownLayoutProps<T extends Record<string, any>> {
     rawContent: MarkdownInstance<T>['rawContent'];
     compiledContent: MarkdownInstance<T>['compiledContent'];
 }
-export declare type MDXLayoutProps<T> = Omit<MarkdownLayoutProps<T>, 'rawContent' | 'compiledContent'>;
+export declare type MDXLayoutProps<T extends Record<string, any>> = Omit<MarkdownLayoutProps<T>, 'rawContent' | 'compiledContent'>;
 export declare type GetHydrateCallback = () => Promise<() => void | Promise<void>>;
 /**
  * getStaticPaths() options

package/dist/core/add/index.js

@@ -459,11 +459,11 @@ async function getInstallIntegrationsCommand({
   ).sort();
   switch (pm.name) {
     case "npm":
-      return { pm: "npm", command: "install", flags: ["--save-dev"], dependencies };
+      return { pm: "npm", command: "install", flags: [], dependencies };
     case "yarn":
-      return { pm: "yarn", command: "add", flags: ["--dev"], dependencies };
+      return { pm: "yarn", command: "add", flags: [], dependencies };
     case "pnpm":
-      return { pm: "pnpm", command: "install", flags: ["--save-dev"], dependencies };
+      return { pm: "pnpm", command: "install", flags: [], dependencies };
     default:
       return null;
   }
@@ -478,7 +478,10 @@ async function tryToInstallIntegrations({
   if (installCommand === null) {
     return 0 /* none */;
   } else {
-    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command} ${installCommand.flags.join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
+    const coloredOutput = `${bold(installCommand.pm)} ${installCommand.command}${[
+      "",
+      ...installCommand.flags
+    ].join(" ")} ${cyan(installCommand.dependencies.join(" "))}`;
     const message = `
 ${boxen(coloredOutput, {
       margin: 0.5,

package/dist/core/build/vite-plugin-analyzer.js

@@ -1,5 +1,4 @@
 import { prependForwardSlash } from "../../core/path.js";
-import { resolveClientDevPath } from "../../core/render/dev/resolve.js";
 import { getTopLevelPages } from "./graph.js";
 import { getPageDataByViteID, trackClientOnlyPageDatas } from "./internal.js";
 function vitePluginAnalyzer(internals) {
@@ -66,14 +65,14 @@ function vitePluginAnalyzer(internals) {
           continue;
         const astro = info.meta.astro;
         for (const c of astro.hydratedComponents) {
-          const rid = c.resolvedPath ? resolveClientDevPath(c.resolvedPath) : c.specifier;
+          const rid = c.resolvedPath ? decodeURI(c.resolvedPath) : c.specifier;
           internals.discoveredHydratedComponents.add(rid);
         }
         hoistScanner.scan.call(this, astro.scripts, id);
         if (astro.clientOnlyComponents.length) {
           const clientOnlys = [];
           for (const c of astro.clientOnlyComponents) {
-            const cid = c.resolvedPath ? resolveClientDevPath(c.resolvedPath) : c.specifier;
+            const cid = c.resolvedPath ? decodeURI(c.resolvedPath) : c.specifier;
             internals.discoveredClientOnlyComponents.add(cid);
             clientOnlys.push(cid);
           }

package/dist/core/build/vite-plugin-css.js

@@ -92,6 +92,7 @@ function rollupPluginAstroBuildCSS(options) {
                   if (Object.keys(c.modules).every((id) => internals.cssChunkModuleIds.has(id))) {
                     for (const importedCssImport of meta.importedCss) {
                       delete bundle[importedCssImport];
+                      meta.importedCss.delete(importedCssImport);
                     }
                     return;
                   }

package/dist/{vite-plugin-astro → core/compile}/compile.d.ts

@@ -1,8 +1,6 @@
 import type { TransformResult } from '@astrojs/compiler';
-import type { PluginContext } from 'rollup';
-import type { ViteDevServer } from 'vite';
-import type { AstroConfig } from '../@types/astro';
-import type { TransformStyleWithVite } from './styles';
+import type { AstroConfig } from '../../@types/astro';
+import type { TransformStyle } from './types';
 declare type CompileResult = TransformResult & {
     cssDeps: Set<string>;
     source: string;
@@ -12,10 +10,7 @@ export interface CompileProps {
     filename: string;
     moduleId: string;
     source: string;
-    ssr: boolean;
-    transformStyleWithVite: TransformStyleWithVite;
-    viteDevServer?: ViteDevServer;
-    pluginContext: PluginContext;
+    transformStyle: TransformStyle;
 }
 export declare function isCached(config: AstroConfig, filename: string): boolean;
 export declare function getCachedSource(config: AstroConfig, filename: string): string | null;

package/dist/{vite-plugin-astro → core/compile}/compile.js

@@ -1,35 +1,19 @@
 import { transform } from "@astrojs/compiler";
-import { fileURLToPath } from "url";
-import { AstroErrorCodes } from "../core/errors.js";
-import { prependForwardSlash } from "../core/path.js";
-import { viteID } from "../core/util.js";
+import { AstroErrorCodes } from "../errors.js";
+import { prependForwardSlash } from "../path.js";
+import { AggregateError, viteID } from "../util.js";
+import { createStylePreprocessor } from "./style.js";
 const configCache = /* @__PURE__ */ new WeakMap();
-function getNormalizedID(filename) {
-  try {
-    const filenameURL = new URL(`file://${filename}`);
-    return fileURLToPath(filenameURL);
-  } catch (err) {
-    return filename;
-  }
-}
 async function compile({
   config,
   filename,
   moduleId,
   source,
-  ssr,
-  transformStyleWithVite,
-  viteDevServer,
-  pluginContext
+  transformStyle
 }) {
   var _a;
-  const normalizedID = getNormalizedID(filename);
   let cssDeps = /* @__PURE__ */ new Set();
-  let cssTransformError;
-  if (!pluginContext.addWatchFile) {
-    pluginContext.addWatchFile = () => {
-    };
-  }
+  let cssTransformErrors = [];
   const transformResult = await transform(source, {
     pathname: `/@fs${prependForwardSlash(moduleId)}`,
     projectRoot: config.root.toString(),
@@ -37,47 +21,30 @@ async function compile({
     sourcefile: filename,
     sourcemap: "both",
     internalURL: `/@fs${prependForwardSlash(
-      viteID(new URL("../runtime/server/index.js", import.meta.url))
+      viteID(new URL("../../runtime/server/index.js", import.meta.url))
     )}`,
     experimentalStaticExtraction: true,
-    preprocessStyle: async (value, attrs) => {
-      const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
-      try {
-        const result = await transformStyleWithVite.call(pluginContext, {
-          id: normalizedID,
-          source: value,
-          lang,
-          ssr,
-          viteDevServer
-        });
-        if (!result)
-          return null;
-        for (const dep of result.deps) {
-          cssDeps.add(dep);
-        }
-        let map;
-        if (result.map) {
-          if (typeof result.map === "string") {
-            map = result.map;
-          } else if (result.map.mappings) {
-            map = result.map.toString();
-          }
-        }
-        return { code: result.code, map };
-      } catch (err) {
-        cssTransformError = err;
-        return null;
-      }
-    }
+    preprocessStyle: createStylePreprocessor(transformStyle, cssDeps, cssTransformErrors)
   }).catch((err) => {
     err.code = err.code || AstroErrorCodes.UnknownCompilerError;
     throw err;
   }).then((result) => {
-    if (cssTransformError) {
-      cssTransformError.code = cssTransformError.code || AstroErrorCodes.UnknownCompilerCSSError;
-      throw cssTransformError;
+    switch (cssTransformErrors.length) {
+      case 0:
+        return result;
+      case 1: {
+        let error = cssTransformErrors[0];
+        if (!error.code) {
+          error.code = AstroErrorCodes.UnknownCompilerCSSError;
+        }
+        throw cssTransformErrors[0];
+      }
+      default: {
+        const aggregateError = new AggregateError(cssTransformErrors);
+        aggregateError.code = AstroErrorCodes.UnknownCompilerCSSError;
+        throw aggregateError;
+      }
     }
-    return result;
   });
   const compileResult = Object.create(transformResult, {
     cssDeps: {

package/dist/core/compile/index.d.ts

@@ -0,0 +1,3 @@
+export type { CompileProps } from './compile';
+export { cachedCompilation, getCachedSource, invalidateCompilation, isCached } from './compile.js';
+export type { TransformStyle } from './types';

package/dist/core/compile/index.js

@@ -0,0 +1,7 @@
+import { cachedCompilation, getCachedSource, invalidateCompilation, isCached } from "./compile.js";
+export {
+  cachedCompilation,
+  getCachedSource,
+  invalidateCompilation,
+  isCached
+};

package/dist/core/compile/style.d.ts

@@ -0,0 +1,5 @@
+import type { TransformOptions } from '@astrojs/compiler';
+import type { TransformStyle } from './types';
+declare type PreprocessStyle = TransformOptions['preprocessStyle'];
+export declare function createStylePreprocessor(transformStyle: TransformStyle, cssDeps: Set<string>, errors: Error[]): PreprocessStyle;
+export {};

package/dist/core/compile/style.js

@@ -0,0 +1,31 @@
+function createStylePreprocessor(transformStyle, cssDeps, errors) {
+  const preprocessStyle = async (value, attrs) => {
+    const lang = `.${(attrs == null ? void 0 : attrs.lang) || "css"}`.toLowerCase();
+    try {
+      const result = await transformStyle(value, lang);
+      if (!result)
+        return null;
+      for (const dep of result.deps) {
+        cssDeps.add(dep);
+      }
+      let map;
+      if (result.map) {
+        if (typeof result.map === "string") {
+          map = result.map;
+        } else if (result.map.mappings) {
+          map = result.map.toString();
+        }
+      }
+      return { code: result.code, map };
+    } catch (err) {
+      errors.push(err);
+      return {
+        error: err + ""
+      };
+    }
+  };
+  return preprocessStyle;
+}
+export {
+  createStylePreprocessor
+};

package/dist/core/compile/types.d.ts

@@ -0,0 +1,7 @@
+import type { SourceMap } from 'rollup';
+export declare type TransformStyleResult = null | {
+    code: string;
+    map: SourceMap | null;
+    deps: Set<string>;
+};
+export declare type TransformStyle = (source: string, lang: string) => TransformStyleResult | Promise<TransformStyleResult>;

package/dist/core/create-vite.js

@@ -1,4 +1,6 @@
 import fs from "fs";
+import { createRequire } from "module";
+import path from "path";
 import { fileURLToPath } from "url";
 import * as vite from "vite";
 import astroPostprocessVitePlugin from "../vite-plugin-astro-postprocess/index.js";
@@ -116,32 +118,82 @@ function sortPlugins(pluginOptions) {
   pluginOptions.splice(jsxPluginIndex, 0, mdxPlugin);
 }
 async function getAstroPackages({ root }) {
-  const pkgUrl = new URL("./package.json", root);
-  const pkgPath = fileURLToPath(pkgUrl);
-  if (!fs.existsSync(pkgPath))
-    return [];
-  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  const deps = [...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})];
-  return deps.filter((dep) => {
-    if (isCommonNotAstro(dep))
-      return false;
-    if (/^astro\-/.test(dep))
-      return true;
-    const depPkgUrl = new URL(`./node_modules/${dep}/package.json`, root);
-    const depPkgPath = fileURLToPath(depPkgUrl);
-    if (!fs.existsSync(depPkgPath))
-      return false;
-    const {
-      dependencies = {},
-      peerDependencies = {},
-      keywords = []
-    } = JSON.parse(fs.readFileSync(depPkgPath, "utf-8"));
-    if (peerDependencies.astro || dependencies.astro)
-      return true;
-    if (keywords.includes("astro") || keywords.includes("astro-component"))
-      return true;
-    return false;
-  });
+  const { astroPackages } = new DependencyWalker(root);
+  return astroPackages;
+}
+class DependencyWalker {
+  constructor(root) {
+    this.astroDeps = /* @__PURE__ */ new Set();
+    this.nonAstroDeps = /* @__PURE__ */ new Set();
+    const pkgUrl = new URL("./package.json", root);
+    this.require = createRequire(pkgUrl);
+    const pkgPath = fileURLToPath(pkgUrl);
+    if (!fs.existsSync(pkgPath))
+      return;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const deps = [
+      ...Object.keys(pkg.dependencies || {}),
+      ...Object.keys(pkg.devDependencies || {})
+    ];
+    this.scanDependencies(deps);
+  }
+  get astroPackages() {
+    return Array.from(this.astroDeps);
+  }
+  seen(dep) {
+    return this.astroDeps.has(dep) || this.nonAstroDeps.has(dep);
+  }
+  readPkgJSON(dir) {
+    try {
+      const filePath = path.join(dir, "package.json");
+      return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    } catch (e) {
+    }
+  }
+  resolvePkgJSON(dep) {
+    try {
+      const pkgJson = this.require(dep + "/package.json");
+      return pkgJson;
+    } catch (e) {
+      try {
+        let dir = path.dirname(this.require.resolve(dep));
+        while (dir) {
+          const pkgJSON = this.readPkgJSON(dir);
+          if (pkgJSON && pkgJSON.name === dep)
+            return pkgJSON;
+          const parentDir = path.dirname(dir);
+          if (parentDir === dir)
+            break;
+          dir = parentDir;
+        }
+      } catch {
+      }
+    }
+  }
+  scanDependencies(deps) {
+    const newDeps = [];
+    for (const dep of deps) {
+      if (isCommonNotAstro(dep)) {
+        this.nonAstroDeps.add(dep);
+        continue;
+      }
+      const pkgJson = this.resolvePkgJSON(dep);
+      if (!pkgJson) {
+        this.nonAstroDeps.add(dep);
+        continue;
+      }
+      const { dependencies = {}, peerDependencies = {}, keywords = [] } = pkgJson;
+      if (peerDependencies.astro || dependencies.astro || keywords.includes("astro") || keywords.includes("astro-component") || /^(@[^\/]+\/)?astro\-/.test(dep)) {
+        this.astroDeps.add(dep);
+        const unknownDependencies = Object.keys(dependencies).filter((d) => !this.seen(d));
+        newDeps.push(...unknownDependencies);
+      } else {
+        this.nonAstroDeps.add(dep);
+      }
+    }
+    if (newDeps.length)
+      this.scanDependencies(newDeps);
+  }
 }
 const COMMON_DEPENDENCIES_NOT_ASTRO = [
   "autoprefixer",

package/dist/core/dev/index.js

@@ -46,7 +46,7 @@ async function dev(config, options) {
       https: !!((_a = viteConfig.server) == null ? void 0 : _a.https)
     })
   );
-  const currentVersion = "1.1.5";
+  const currentVersion = "1.1.8";
   if (currentVersion.includes("-")) {
     warn(options.logging, null, msg.prerelease({ currentVersion }));
   }

package/dist/core/messages.js

@@ -46,7 +46,7 @@ function devStart({
   https,
   site
 }) {
-  const version = "1.1.5";
+  const version = "1.1.8";
   const rootPath = site ? site.pathname : "/";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
@@ -225,7 +225,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"1.1.5"}`
+        `v${"1.1.8"}`
       )} ${headline}`
     );
   }

package/dist/core/render/dev/css.js

@@ -3,14 +3,14 @@ import { viteID } from "../../util.js";
 import { STYLE_EXTENSIONS } from "../util.js";
 import { crawlGraph } from "./vite.js";
 async function getStylesForURL(filePath, viteServer, mode) {
-  var _a;
   const importedCssUrls = /* @__PURE__ */ new Set();
   const importedStylesMap = /* @__PURE__ */ new Map();
   for await (const importedModule of crawlGraph(viteServer, viteID(filePath), true)) {
     const ext = path.extname(importedModule.url).toLowerCase();
     if (STYLE_EXTENSIONS.has(ext)) {
-      if (mode === "development" && typeof ((_a = importedModule.ssrModule) == null ? void 0 : _a.default) === "string") {
-        importedStylesMap.set(importedModule.url, importedModule.ssrModule.default);
+      const ssrModule = importedModule.ssrModule ?? await viteServer.ssrLoadModule(importedModule.url);
+      if (mode === "development" && typeof (ssrModule == null ? void 0 : ssrModule.default) === "string") {
+        importedStylesMap.set(importedModule.url, ssrModule.default);
       } else {
         importedCssUrls.add(importedModule.url);
       }

package/dist/core/util.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import type { ErrorPayload, ViteDevServer } from 'vite';
 import type { AstroConfig, RouteType } from '../@types/astro';
 export declare const ASTRO_VERSION: string;
@@ -46,3 +47,15 @@ export declare function getLocalAddress(serverAddress: string, host: string | bo
  * through a script tag or a dynamic import as-is.
  */
 export declare function resolveIdToUrl(viteServer: ViteDevServer, id: string): Promise<string>;
+export declare const AggregateError: AggregateErrorConstructor | {
+    new (errors: Iterable<any>, message?: string | undefined): {
+        errors: Array<any>;
+        name: string;
+        message: string;
+        stack?: string | undefined;
+        cause?: Error | undefined;
+    };
+    captureStackTrace(targetObject: object, constructorOpt?: Function | undefined): void;
+    prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    stackTraceLimit: number;
+};

package/dist/core/util.js

@@ -5,7 +5,7 @@ import resolve from "resolve";
 import slash from "slash";
 import { fileURLToPath, pathToFileURL } from "url";
 import { prependForwardSlash, removeTrailingForwardSlash } from "./path.js";
-const ASTRO_VERSION = "1.1.5";
+const ASTRO_VERSION = "1.1.8";
 function isObject(value) {
   return typeof value === "object" && value != null;
 }
@@ -87,7 +87,7 @@ function resolveDependency(dep, projectRoot) {
   return pathToFileURL(resolved).toString();
 }
 function viteID(filePath) {
-  return slash(fileURLToPath(filePath));
+  return slash(fileURLToPath(filePath) + filePath.search);
 }
 const VALID_ID_PREFIX = `/@id/`;
 function unwrapId(id) {
@@ -170,8 +170,16 @@ async function resolveIdToUrl(viteServer, id) {
   }
   return VALID_ID_PREFIX + result.id;
 }
+const AggregateError = typeof globalThis.AggregateError !== "undefined" ? globalThis.AggregateError : class extends Error {
+  constructor(errors, message) {
+    super(message);
+    this.errors = [];
+    this.errors = Array.from(errors);
+  }
+};
 export {
   ASTRO_VERSION,
+  AggregateError,
   VALID_ID_PREFIX,
   arraify,
   codeFrame,

package/dist/jsx/babel.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
 import { pathToFileURL } from "node:url";
+import { resolveClientDevPath } from "../core/render/dev/resolve.js";
 import { HydrationDirectiveProps } from "../runtime/server/hydration.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 function isComponent(tagName) {
@@ -184,7 +185,8 @@ function astroJSX() {
               break;
             }
             if (namespace.at(0) === local) {
-              path.setData("import", { name: imported, path: source });
+              const name = imported === "*" ? imported : tagName;
+              path.setData("import", { name, path: source });
               break;
             }
           }
@@ -194,10 +196,7 @@ function astroJSX() {
           let resolvedPath;
           if (meta.path.startsWith(".")) {
             const fileURL = pathToFileURL(state.filename);
-            resolvedPath = `/@fs${new URL(meta.path, fileURL).pathname}`;
-            if (resolvedPath.endsWith(".jsx")) {
-              resolvedPath = resolvedPath.slice(0, -4);
-            }
+            resolvedPath = resolveClientDevPath(`/@fs${new URL(meta.path, fileURL).pathname}`);
           } else {
             resolvedPath = meta.path;
           }
@@ -273,10 +272,7 @@ function astroJSX() {
           let resolvedPath;
           if (meta.path.startsWith(".")) {
             const fileURL = pathToFileURL(state.filename);
-            resolvedPath = `/@fs${new URL(meta.path, fileURL).pathname}`;
-            if (resolvedPath.endsWith(".jsx")) {
-              resolvedPath = resolvedPath.slice(0, -4);
-            }
+            resolvedPath = resolveClientDevPath(`/@fs${new URL(meta.path, fileURL).pathname}`);
           } else {
             resolvedPath = meta.path;
           }

package/dist/runtime/server/astro-global.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "1.1.5";
+const ASTRO_VERSION = "1.1.8";
 function createDeprecatedFetchContentFn() {
   return () => {
     throw new Error("Deprecated: Astro.fetchContent() has been replaced with Astro.glob().");

package/dist/runtime/server/hydration.js

@@ -85,11 +85,11 @@ async function generateHydrateScript(scriptOptions, metadata) {
       island.props[key] = value;
     }
   }
-  island.props["component-url"] = await result.resolve(componentUrl);
+  island.props["component-url"] = await result.resolve(decodeURI(componentUrl));
   if (renderer.clientEntrypoint) {
     island.props["component-export"] = componentExport.value;
-    island.props["renderer-url"] = await result.resolve(renderer.clientEntrypoint);
-    island.props["props"] = escapeHTML(serializeProps(props));
+    island.props["renderer-url"] = await result.resolve(decodeURI(renderer.clientEntrypoint));
+    island.props["props"] = escapeHTML(serializeProps(props, metadata));
   }
   island.props["ssr"] = "";
   island.props["client"] = hydrate;

package/dist/runtime/server/render/component.js

@@ -231,7 +231,8 @@ If you're still stuck, please open an issue on GitHub or join us at https://astr
     `<!--${metadata.componentExport.value}:${metadata.componentUrl}-->
 ${html}
 ${serializeProps(
-      props
+      props,
+      metadata
     )}`
   );
   const island = await generateHydrateScript(

package/dist/runtime/server/render/page.js

@@ -56,7 +56,7 @@ async function renderPage(result, componentFactory, props, children, streaming)
                     controller.enqueue(encoder.encode("<!DOCTYPE html>\n"));
                   }
                 }
-                controller.enqueue(encoder.encode(html));
+                controller.enqueue(encoder.encode(String(html)));
                 i++;
               }
               controller.close();

package/dist/runtime/server/serialize.d.ts

@@ -1 +1,2 @@
-export declare function serializeProps(props: any): string;
+import type { AstroComponentMetadata } from '../../@types/astro';
+export declare function serializeProps(props: any, metadata: AstroComponentMetadata): string;

package/dist/runtime/server/serialize.js

@@ -8,17 +8,35 @@ const PROP_TYPE = {
   BigInt: 6,
   URL: 7
 };
-function serializeArray(value) {
-  return value.map((v) => convertToSerializedForm(v));
+function serializeArray(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
+    throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
+
+Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
+  }
+  parents.add(value);
+  const serialized = value.map((v) => {
+    return convertToSerializedForm(v, metadata, parents);
+  });
+  parents.delete(value);
+  return serialized;
 }
-function serializeObject(value) {
-  return Object.fromEntries(
+function serializeObject(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
+  if (parents.has(value)) {
+    throw new Error(`Cyclic reference detected while serializing props for <${metadata.displayName} client:${metadata.hydrate}>!
+
+Cyclic references cannot be safely serialized for client-side usage. Please remove the cyclic reference.`);
+  }
+  parents.add(value);
+  const serialized = Object.fromEntries(
     Object.entries(value).map(([k, v]) => {
-      return [k, convertToSerializedForm(v)];
+      return [k, convertToSerializedForm(v, metadata, parents)];
     })
   );
+  parents.delete(value);
+  return serialized;
 }
-function convertToSerializedForm(value) {
+function convertToSerializedForm(value, metadata = {}, parents = /* @__PURE__ */ new WeakSet()) {
   const tag = Object.prototype.toString.call(value);
   switch (tag) {
     case "[object Date]": {
@@ -28,10 +46,16 @@ function convertToSerializedForm(value) {
       return [PROP_TYPE.RegExp, value.source];
     }
     case "[object Map]": {
-      return [PROP_TYPE.Map, JSON.stringify(serializeArray(Array.from(value)))];
+      return [
+        PROP_TYPE.Map,
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
+      ];
     }
     case "[object Set]": {
-      return [PROP_TYPE.Set, JSON.stringify(serializeArray(Array.from(value)))];
+      return [
+        PROP_TYPE.Set,
+        JSON.stringify(serializeArray(Array.from(value), metadata, parents))
+      ];
     }
     case "[object BigInt]": {
       return [PROP_TYPE.BigInt, value.toString()];
@@ -40,19 +64,20 @@ function convertToSerializedForm(value) {
       return [PROP_TYPE.URL, value.toString()];
     }
     case "[object Array]": {
-      return [PROP_TYPE.JSON, JSON.stringify(serializeArray(value))];
+      return [PROP_TYPE.JSON, JSON.stringify(serializeArray(value, metadata, parents))];
     }
     default: {
       if (value !== null && typeof value === "object") {
-        return [PROP_TYPE.Value, serializeObject(value)];
+        return [PROP_TYPE.Value, serializeObject(value, metadata, parents)];
       } else {
         return [PROP_TYPE.Value, value];
       }
     }
   }
 }
-function serializeProps(props) {
-  return JSON.stringify(serializeObject(props));
+function serializeProps(props, metadata) {
+  const serialized = JSON.stringify(serializeObject(props, metadata));
+  return serialized;
 }
 export {
   serializeProps

package/dist/vite-plugin-astro/hmr.d.ts

@@ -1,7 +1,7 @@
 import type { HmrContext, ModuleNode } from 'vite';
 import type { AstroConfig } from '../@types/astro';
+import { cachedCompilation } from '../core/compile/index.js';
 import type { LogOptions } from '../core/logger/core.js';
-import { cachedCompilation } from './compile.js';
 export interface HandleHotUpdateOptions {
     config: AstroConfig;
     logging: LogOptions;

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

@@ -1,7 +1,7 @@
 import { fileURLToPath } from "node:url";
+import { invalidateCompilation, isCached } from "../core/compile/index.js";
 import { info } from "../core/logger/core.js";
 import * as msg from "../core/messages.js";
-import { invalidateCompilation, isCached } from "./compile.js";
 import { isAstroScript } from "./query.js";
 const PKG_PREFIX = new URL("../../", import.meta.url);
 const isPkgFile = (id) => {

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

@@ -2,12 +2,16 @@ import ancestor from "common-ancestor-path";
 import esbuild from "esbuild";
 import slash from "slash";
 import { fileURLToPath } from "url";
-import { isRelativePath, startsWithForwardSlash } from "../core/path.js";
+import { cachedCompilation, getCachedSource } from "../core/compile/index.js";
+import { isRelativePath, prependForwardSlash, startsWithForwardSlash } from "../core/path.js";
+import { viteID } from "../core/util.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
-import { cachedCompilation, getCachedSource } from "./compile.js";
+import {
+  createTransformStyles,
+  createViteStyleTransformer
+} from "../vite-style-transform/index.js";
 import { handleHotUpdate } from "./hmr.js";
 import { parseAstroRequest } from "./query.js";
-import { createTransformStyleWithViteFn } from "./styles.js";
 const FRONTMATTER_PARSE_REGEXP = /^\-\-\-(.*)^\-\-\-/ms;
 function astro({ config, logging }) {
   function normalizeFilename(filename) {
@@ -24,10 +28,11 @@ function astro({ config, logging }) {
     return slash(fileURLToPath(url)) + url.search;
   }
   let resolvedConfig;
-  let transformStyleWithVite;
+  let styleTransformer;
   let viteDevServer;
   const srcRootWeb = config.srcDir.pathname.slice(config.root.pathname.length - 1);
   const isBrowserPath = (path) => path.startsWith(srcRootWeb);
+  const isFullFilePath = (path) => path.startsWith(prependForwardSlash(slash(fileURLToPath(config.root))));
   function resolveRelativeFromAstroParent(id, parsedFrom) {
     const filename = normalizeFilename(parsedFrom.filename);
     const resolvedURL = new URL(id, `file://${filename}`);
@@ -42,10 +47,11 @@ function astro({ config, logging }) {
     enforce: "pre",
     configResolved(_resolvedConfig) {
       resolvedConfig = _resolvedConfig;
-      transformStyleWithVite = createTransformStyleWithViteFn(_resolvedConfig);
+      styleTransformer = createViteStyleTransformer(_resolvedConfig);
     },
     configureServer(server) {
       viteDevServer = server;
+      styleTransformer.viteDevServer = server;
     },
     async resolveId(id, from, opts) {
       if (from) {
@@ -63,6 +69,9 @@ function astro({ config, logging }) {
         if (query.type === "style" && isBrowserPath(id)) {
           return relativeToRoot(id);
         }
+        if (isFullFilePath(id)) {
+          return viteID(new URL("file://" + id));
+        }
         return id;
       }
     },
@@ -86,10 +95,7 @@ function astro({ config, logging }) {
         filename,
         moduleId: id,
         source,
-        ssr: Boolean(opts == null ? void 0 : opts.ssr),
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
       };
       switch (query.type) {
         case "style": {
@@ -163,7 +169,7 @@ File: ${filename}`
       }
     },
     async transform(source, id, opts) {
-      var _a, _b;
+      var _a;
       const parsedId = parseAstroRequest(id);
       const query = parsedId.query;
       if (!id.endsWith(".astro") || query.astro) {
@@ -178,10 +184,7 @@ File: ${filename}`
         filename,
         moduleId: id,
         source,
-        ssr: Boolean(opts == null ? void 0 : opts.ssr),
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, filename, Boolean(opts == null ? void 0 : opts.ssr), this)
       };
       try {
         const transformResult = await cachedCompilation(compileProps);
@@ -203,16 +206,8 @@ const $$url = ${JSON.stringify(
         )};export { $$file as file, $$url as url };
 `;
         if (!resolvedConfig.isProduction) {
-          const metadata = transformResult.code.split("$$createMetadata(")[1].split("});\n")[0];
-          const pattern = /specifier:\s*'([^']*)'/g;
-          const deps = /* @__PURE__ */ new Set();
-          let match;
-          while (match = (_b = pattern.exec(metadata)) == null ? void 0 : _b[1]) {
-            deps.add(match);
-          }
           let i = 0;
           while (i < transformResult.scripts.length) {
-            deps.add(`${id}?astro&type=script&index=${i}&lang.ts`);
             SUFFIX += `import "${id}?astro&type=script&index=${i}&lang.ts";`;
             i++;
           }
@@ -288,10 +283,7 @@ ${source}
         filename: context.file,
         moduleId: context.file,
         source: await context.read(),
-        ssr: true,
-        transformStyleWithVite,
-        viteDevServer,
-        pluginContext: this
+        transformStyle: createTransformStyles(styleTransformer, context.file, true, this)
       };
       const compile = () => cachedCompilation(compileProps);
       return handleHotUpdate.call(this, context, {

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

@@ -83,6 +83,7 @@ async function handle404Response(origin, config, req, res) {
 async function handle500Response(viteServer, origin, req, res, err) {
   res.on("close", () => setTimeout(() => viteServer.ws.send(getViteErrorPayload(err)), 200));
   if (res.headersSent) {
+    res.write(`<script type="module" src="/@vite/client"><\/script>`);
     res.end();
   } else {
     writeHtmlResponse(

package/dist/vite-plugin-markdown-legacy/index.js

@@ -5,12 +5,13 @@ import fs from "fs";
 import matter from "gray-matter";
 import { fileURLToPath } from "url";
 import { pagesVirtualModuleId } from "../core/app/index.js";
+import { cachedCompilation } from "../core/compile/index.js";
 import { collectErrorMetadata } from "../core/errors.js";
-import { cachedCompilation } from "../vite-plugin-astro/compile.js";
-import {
-  createTransformStyleWithViteFn
-} from "../vite-plugin-astro/styles.js";
 import { getFileInfo } from "../vite-plugin-utils/index.js";
+import {
+  createTransformStyles,
+  createViteStyleTransformer
+} from "../vite-style-transform/index.js";
 const MARKDOWN_IMPORT_FLAG = "?mdImport";
 const MARKDOWN_CONTENT_FLAG = "?content";
 function safeMatter(source, id) {
@@ -43,13 +44,16 @@ function markdown({ config, logging }) {
     }
     return false;
   }
-  let transformStyleWithVite;
+  let styleTransformer;
   let viteDevServer;
   return {
     name: "astro:markdown",
     enforce: "pre",
     configResolved(_resolvedConfig) {
-      transformStyleWithVite = createTransformStyleWithViteFn(_resolvedConfig);
+      styleTransformer = createViteStyleTransformer(_resolvedConfig);
+    },
+    configureServer(server) {
+      styleTransformer.viteDevServer = server;
     },
     async resolveId(id, importer, options) {
       if (id.endsWith(`.md${MARKDOWN_CONTENT_FLAG}`)) {
@@ -161,10 +165,12 @@ ${astroResult}
           filename,
           moduleId: id,
           source: astroResult,
-          ssr: Boolean(opts == null ? void 0 : opts.ssr),
-          transformStyleWithVite,
-          viteDevServer,
-          pluginContext: this
+          transformStyle: createTransformStyles(
+            styleTransformer,
+            filename,
+            Boolean(opts == null ? void 0 : opts.ssr),
+            this
+          )
         };
         let transformResult = await cachedCompilation(compileProps);
         let { code: tsResult } = transformResult;

package/dist/vite-style-transform/index.d.ts

@@ -0,0 +1,2 @@
+export type { ViteStyleTransformer } from './style-transform';
+export { createTransformStyles, createViteStyleTransformer } from './style-transform.js';

package/dist/vite-style-transform/index.js

@@ -0,0 +1,5 @@
+import { createTransformStyles, createViteStyleTransformer } from "./style-transform.js";
+export {
+  createTransformStyles,
+  createViteStyleTransformer
+};

package/dist/vite-style-transform/style-transform.d.ts

@@ -0,0 +1,10 @@
+import type { PluginContext } from 'rollup';
+import type { TransformStyle } from '../core/compile/index';
+import { TransformStyleWithVite } from './transform-with-vite.js';
+import type * as vite from 'vite';
+export declare type ViteStyleTransformer = {
+    viteDevServer?: vite.ViteDevServer;
+    transformStyleWithVite: TransformStyleWithVite;
+};
+export declare function createViteStyleTransformer(viteConfig: vite.ResolvedConfig): ViteStyleTransformer;
+export declare function createTransformStyles(viteStyleTransformer: ViteStyleTransformer, filename: string, ssr: boolean, pluginContext: PluginContext): TransformStyle;

package/dist/vite-style-transform/style-transform.js

@@ -0,0 +1,36 @@
+import { fileURLToPath } from "url";
+import { createTransformStyleWithViteFn } from "./transform-with-vite.js";
+function createViteStyleTransformer(viteConfig) {
+  return {
+    transformStyleWithVite: createTransformStyleWithViteFn(viteConfig)
+  };
+}
+function getNormalizedIDForPostCSS(filename) {
+  try {
+    const filenameURL = new URL(`file://${filename}`);
+    return fileURLToPath(filenameURL);
+  } catch (err) {
+    return filename;
+  }
+}
+function createTransformStyles(viteStyleTransformer, filename, ssr, pluginContext) {
+  if (!pluginContext.addWatchFile) {
+    pluginContext.addWatchFile = () => {
+    };
+  }
+  const normalizedID = getNormalizedIDForPostCSS(filename);
+  return async function(styleSource, lang) {
+    const result = await viteStyleTransformer.transformStyleWithVite.call(pluginContext, {
+      id: normalizedID,
+      source: styleSource,
+      lang,
+      ssr,
+      viteDevServer: viteStyleTransformer.viteDevServer
+    });
+    return result;
+  };
+}
+export {
+  createTransformStyles,
+  createViteStyleTransformer
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "1.1.5",
+  "version": "1.1.8",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -82,7 +82,7 @@
     "vendor"
   ],
   "dependencies": {
-    "@astrojs/compiler": "^0.23.4",
+    "@astrojs/compiler": "^0.24.0",
     "@astrojs/language-server": "^0.23.0",
     "@astrojs/markdown-remark": "^1.1.1",
     "@astrojs/telemetry": "^1.0.0",
@@ -95,6 +95,9 @@
     "@babel/types": "^7.18.4",
     "@proload/core": "^0.3.2",
     "@proload/plugin-tsm": "^0.2.1",
+    "@types/babel__core": "^7.1.19",
+    "@types/html-escaper": "^3.0.0",
+    "@types/yargs-parser": "^21.0.0",
     "boxen": "^6.2.1",
     "ci-info": "^3.3.1",
     "common-ancestor-path": "^1.0.1",
@@ -139,7 +142,6 @@
   },
   "devDependencies": {
     "@playwright/test": "^1.22.2",
-    "@types/babel__core": "^7.1.19",
     "@types/babel__generator": "^7.6.4",
     "@types/babel__traverse": "^7.17.1",
     "@types/chai": "^4.3.1",
@@ -148,7 +150,6 @@
     "@types/debug": "^4.1.7",
     "@types/diff": "^5.0.2",
     "@types/estree": "^0.0.51",
-    "@types/html-escaper": "^3.0.0",
     "@types/mime": "^2.0.3",
     "@types/mocha": "^9.1.1",
     "@types/parse5": "^6.0.3",
@@ -158,7 +159,6 @@
     "@types/rimraf": "^3.0.2",
     "@types/send": "^0.17.1",
     "@types/unist": "^2.0.6",
-    "@types/yargs-parser": "^21.0.0",
     "ast-types": "^0.14.2",
     "astro-scripts": "0.0.7",
     "chai": "^4.3.6",
@@ -178,7 +178,8 @@
     "dev": "astro-scripts dev --prebuild \"src/runtime/server/astro-island.ts\" --prebuild \"src/runtime/client/{idle,load,media,only,visible}.ts\" \"src/**/*.ts\"",
     "postbuild": "astro-scripts copy \"src/**/*.astro\"",
     "benchmark": "node test/benchmark/dev.bench.js && node test/benchmark/build.bench.js",
-    "test": "mocha --exit --timeout 20000 --ignore **/lit-element.test.js && mocha --timeout 20000 **/lit-element.test.js",
+    "test:unit": "mocha --exit --timeout 2000 ./test/units/**/*.test.js",
+    "test": "pnpm run test:unit && mocha --exit --timeout 20000 --ignore **/lit-element.test.js && mocha --timeout 20000 **/lit-element.test.js",
     "test:match": "mocha --timeout 20000 -g",
     "test:e2e": "playwright test",
     "test:e2e:match": "playwright test -g"