feat: scaffold Astro + Tailwind project

node_modules/astro/dist/core/logger/config.d.ts

@@ -0,0 +1,6 @@
+export interface LoggerHandlerConfig {
+    /** Serializable options used by the driver implementation */
+    config?: Record<string, any> | undefined;
+    /** URL or package import */
+    entrypoint: string;
+}

node_modules/astro/dist/core/logger/core.d.ts

@@ -0,0 +1,112 @@
+export interface AstroLoggerDestination<T = unknown> {
+    /**
+     * It receives a message and writes it into a destination
+     */
+    write: (chunk: T) => void;
+    /**
+     * It dumps logs without closing the connection to the destination.
+     * Method that can be used by specialized loggers.
+     */
+    flush?: () => Promise<void> | void;
+    /**
+     * It dumps logs and closes the connection to the destination.
+     * Method that can be used by specialized loggers.
+     */
+    close?: () => Promise<void> | void;
+}
+/**
+ * The level of logging. Priority is the following:
+ * 1. debug
+ * 2. error
+ * 3. warn
+ * 4. info
+ * 5. silent
+ */
+export type AstroLoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+/**
+ * Defined logger labels. Add more as needed, but keep them high-level & reusable,
+ * rather than specific to a single command, function, use, etc. The label will be
+ * shown in the log message to the user, so it should be relevant.
+ */
+declare const AstroLoggerLabels: readonly ["add", "build", "check", "config", "content", "crypto", "deprecated", "markdown", "router", "types", "vite", "watch", "middleware", "preferences", "redirects", "sync", "session", "toolbar", "assets", "env", "update", "adapter", "islands", "cache", "csp", "SKIP_FORMAT"];
+type AstroLoggerLabel = (typeof AstroLoggerLabels)[number];
+export interface AstroLogOptions {
+    destination: AstroLoggerDestination<AstroLoggerMessage>;
+    level: AstroLoggerLevel;
+    /**
+     * Optional configuration for the logger destination
+     */
+    config?: Record<string, any> | undefined;
+}
+/** @lintignore */
+export declare const dateTimeFormat: Intl.DateTimeFormat;
+export interface AstroLoggerMessage {
+    /**
+     * Label associated to the message. Used by Astro for pretty logging
+     */
+    label: string | null;
+    /**
+     * The level of the log
+     */
+    level: AstroLoggerLevel;
+    /**
+     * The message of the log
+     */
+    message: string;
+    /**
+     * Whether a newline should be appended to the end of the message i.e. message + '\n'
+     */
+    newLine: boolean;
+}
+export declare const levels: Record<AstroLoggerLevel, number>;
+export declare function isLogLevelEnabled(configuredLogLevel: AstroLoggerLevel, level: AstroLoggerLevel): boolean;
+export declare function debug(...args: any[]): void;
+/**
+ * Get the prefix for a log message.
+ * This includes the timestamp, log level, and label all properly formatted
+ * with colors. This is shared across different loggers, so it's defined here.
+ */
+export declare function getEventPrefix({ level, label }: AstroLoggerMessage): string;
+/** Print out a timer message for debug() */
+export declare function timerMessage(message: string, startTime?: number): string;
+export declare class AstroLogger {
+    options: AstroLogOptions;
+    constructor(options: AstroLogOptions);
+    info(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    warn(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    error(label: AstroLoggerLabel | null, message: string, newLine?: boolean): void;
+    debug(label: AstroLoggerLabel, ...messages: any[]): void;
+    level(): AstroLoggerLevel;
+    forkIntegrationLogger(label: string): AstroIntegrationLogger;
+    setDestination(destination: AstroLoggerDestination<AstroLoggerMessage>): void;
+    /**
+     * It calls the `close` function of the provided destination, if it exists.
+     */
+    close(): void;
+    /**
+     * It calls the `flush` function of the provided destinatin, if it exists.
+     */
+    flush(): void;
+}
+export declare class AstroIntegrationLogger {
+    options: AstroLogOptions;
+    label: string;
+    constructor(logging: AstroLogOptions, label: string);
+    /**
+     * Creates a new logger instance with a new label, but the same log options.
+     */
+    fork(label: string): AstroIntegrationLogger;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    /**
+     * It calls the `flush` function of the provided destination, if it exists.
+     */
+    flush(): void;
+    /**
+     * It calls the `close` function of the provided destination, if it exists.
+     */
+    close(): void;
+}
+export {};

node_modules/astro/dist/core/logger/core.js

@@ -0,0 +1,198 @@
+import colors from "piccolore";
+const AstroLoggerLabels = [
+  "add",
+  "build",
+  "check",
+  "config",
+  "content",
+  "crypto",
+  "deprecated",
+  "markdown",
+  "router",
+  "types",
+  "vite",
+  "watch",
+  "middleware",
+  "preferences",
+  "redirects",
+  "sync",
+  "session",
+  "toolbar",
+  "assets",
+  "env",
+  "update",
+  "adapter",
+  "islands",
+  "cache",
+  "csp",
+  // SKIP_FORMAT: A special label that tells the logger not to apply any formatting.
+  // Useful for messages that are already formatted, like the server start message.
+  "SKIP_FORMAT"
+];
+const dateTimeFormat = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false
+});
+const levels = {
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  silent: 90
+};
+function log(opts, level, label, message, newLine = true) {
+  const logLevel = opts.level;
+  const dest = opts.destination;
+  const event = {
+    label,
+    level,
+    message,
+    newLine
+  };
+  if (!isLogLevelEnabled(logLevel, level)) {
+    return;
+  }
+  dest.write(event);
+}
+function isLogLevelEnabled(configuredLogLevel, level) {
+  return levels[configuredLogLevel] <= levels[level];
+}
+function info(opts, label, message, newLine = true) {
+  return log(opts, "info", label, message, newLine);
+}
+function warn(opts, label, message, newLine = true) {
+  return log(opts, "warn", label, message, newLine);
+}
+function error(opts, label, message, newLine = true) {
+  return log(opts, "error", label, message, newLine);
+}
+function debug(...args) {
+  if ("_astroGlobalDebug" in globalThis) {
+    globalThis._astroGlobalDebug(...args);
+  }
+}
+function getEventPrefix({ level, label }) {
+  const timestamp = `${dateTimeFormat.format(/* @__PURE__ */ new Date())}`;
+  const prefix = [];
+  if (level === "error" || level === "warn") {
+    prefix.push(colors.bold(timestamp));
+    prefix.push(`[${level.toUpperCase()}]`);
+  } else {
+    prefix.push(timestamp);
+  }
+  if (label) {
+    prefix.push(`[${label}]`);
+  }
+  if (level === "error") {
+    return colors.red(prefix.join(" "));
+  }
+  if (level === "warn") {
+    return colors.yellow(prefix.join(" "));
+  }
+  if (prefix.length === 1) {
+    return colors.dim(prefix[0]);
+  }
+  return colors.dim(prefix[0]) + " " + colors.blue(prefix.splice(1).join(" "));
+}
+function timerMessage(message, startTime = Date.now()) {
+  let timeDiff = Date.now() - startTime;
+  let timeDisplay = timeDiff < 750 ? `${Math.round(timeDiff)}ms` : `${(timeDiff / 1e3).toFixed(1)}s`;
+  return `${message}   ${colors.dim(timeDisplay)}`;
+}
+class AstroLogger {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  info(label, message, newLine = true) {
+    info(this.options, label, message, newLine);
+  }
+  warn(label, message, newLine = true) {
+    warn(this.options, label, message, newLine);
+  }
+  error(label, message, newLine = true) {
+    error(this.options, label, message, newLine);
+  }
+  debug(label, ...messages) {
+    debug(label, ...messages);
+  }
+  level() {
+    return this.options.level;
+  }
+  forkIntegrationLogger(label) {
+    return new AstroIntegrationLogger(this.options, label);
+  }
+  setDestination(destination) {
+    this.options.destination = destination;
+  }
+  /**
+   * It calls the `close` function of the provided destination, if it exists.
+   */
+  close() {
+    if (this.options.destination.close) {
+      this.options.destination.close();
+    }
+  }
+  /**
+   * It calls the `flush` function of the provided destinatin, if it exists.
+   */
+  flush() {
+    if (this.options.destination.flush) {
+      this.options.destination.flush();
+    }
+  }
+}
+class AstroIntegrationLogger {
+  options;
+  label;
+  constructor(logging, label) {
+    this.options = logging;
+    this.label = label;
+  }
+  /**
+   * Creates a new logger instance with a new label, but the same log options.
+   */
+  fork(label) {
+    return new AstroIntegrationLogger(this.options, label);
+  }
+  info(message) {
+    info(this.options, this.label, message);
+  }
+  warn(message) {
+    warn(this.options, this.label, message);
+  }
+  error(message) {
+    error(this.options, this.label, message);
+  }
+  debug(message) {
+    debug(this.label, message);
+  }
+  /**
+   * It calls the `flush` function of the provided destination, if it exists.
+   */
+  flush() {
+    if (this.options.destination.flush) {
+      this.options.destination.flush();
+    }
+  }
+  /**
+   * It calls the `close` function of the provided destination, if it exists.
+   */
+  close() {
+    if (this.options.destination.close) {
+      this.options.destination.close();
+    }
+  }
+}
+export {
+  AstroIntegrationLogger,
+  AstroLogger,
+  dateTimeFormat,
+  debug,
+  getEventPrefix,
+  isLogLevelEnabled,
+  levels,
+  timerMessage
+};

node_modules/astro/dist/core/logger/handlers.d.ts

@@ -0,0 +1,60 @@
+import type { LoggerHandlerConfig } from './config.js';
+import type { JsonHandlerConfig } from './impls/json.js';
+import type { NodeHandlerConfig } from './impls/node.js';
+import type { ConsoleHandlerConfig } from './impls/console.js';
+export declare const logHandlers: {
+    /**
+     * It uses the built-in Astro JSON logger.
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.json({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    json(config?: JsonHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It uses the built-in Astro Node.js logger.
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.node({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    node(config?: NodeHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It uses the built-in Astro console logger.
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.console({ pretty: true })
+     *   }
+     * })
+     * ```
+     */
+    console(config?: ConsoleHandlerConfig): LoggerHandlerConfig;
+    /**
+     * It allows composing different loggers
+     *
+     * @example
+     * ```js
+     * export default defineConfig({
+     *   experimental: {
+     *     logger: logHandlers.compose(
+     *       logHandlers.console(),
+     *       logHandlers.json(),
+     *     )
+     *   }
+     * })
+     * ```
+     */
+    compose(...loggers: LoggerHandlerConfig[]): LoggerHandlerConfig;
+};

node_modules/astro/dist/core/logger/handlers.js

@@ -0,0 +1,81 @@
+const logHandlers = {
+  /**
+   * It uses the built-in Astro JSON logger.
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.json({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  json(config) {
+    return {
+      entrypoint: "astro/logger/json",
+      config
+    };
+  },
+  /**
+   * It uses the built-in Astro Node.js logger.
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.node({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  node(config) {
+    return {
+      entrypoint: "astro/logger/node",
+      config
+    };
+  },
+  /**
+   * It uses the built-in Astro console logger.
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.console({ pretty: true })
+   *   }
+   * })
+   * ```
+   */
+  console(config) {
+    return {
+      entrypoint: "astro/logger/console",
+      config
+    };
+  },
+  /**
+   * It allows composing different loggers
+   *
+   * @example
+   * ```js
+   * export default defineConfig({
+   *   experimental: {
+   *     logger: logHandlers.compose(
+   *       logHandlers.console(),
+   *       logHandlers.json(),
+   *     )
+   *   }
+   * })
+   * ```
+   */
+  compose(...loggers) {
+    return {
+      entrypoint: "astro/logger/compose",
+      config: {
+        loggers
+      }
+    };
+  }
+};
+export {
+  logHandlers
+};

node_modules/astro/dist/core/logger/impls/compose.d.ts

@@ -0,0 +1,2 @@
+import type { AstroLoggerDestination } from '../core.js';
+export default function compose(destinations: AstroLoggerDestination[]): AstroLoggerDestination;

node_modules/astro/dist/core/logger/impls/compose.js

@@ -0,0 +1,26 @@
+function compose(destinations) {
+  return {
+    write(chunk) {
+      for (const logger of destinations) {
+        logger.write(chunk);
+      }
+    },
+    flush() {
+      for (const logger of destinations) {
+        if (logger.flush) {
+          logger.flush();
+        }
+      }
+    },
+    close() {
+      for (const logger of destinations) {
+        if (logger.close) {
+          logger.close();
+        }
+      }
+    }
+  };
+}
+export {
+  compose as default
+};

node_modules/astro/dist/core/logger/impls/console.d.ts

@@ -0,0 +1,9 @@
+import { type AstroLoggerMessage, type AstroLoggerDestination, type AstroLoggerLevel, AstroLogger } from '../core.js';
+import type { NodeHandlerConfig } from './node.js';
+export type ConsoleHandlerConfig = {
+    level?: AstroLoggerLevel;
+};
+export declare function createConsoleLogger({ level }: {
+    level: AstroLoggerLevel;
+}): AstroLogger;
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;

node_modules/astro/dist/core/logger/impls/console.js

@@ -0,0 +1,38 @@
+import {
+  getEventPrefix,
+  levels,
+  AstroLogger
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+function consoleLogDestination(config = {}) {
+  const { level = "info" } = config;
+  return {
+    write(event) {
+      let dest = console.error;
+      if (levels[event.level] < levels["error"]) {
+        dest = console.info;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      if (event.label === "SKIP_FORMAT") {
+        dest(event.message);
+      } else {
+        dest(getEventPrefix(event) + " " + event.message);
+      }
+    }
+  };
+}
+function createConsoleLogger({ level }) {
+  return new AstroLogger({
+    level,
+    destination: consoleLogDestination()
+  });
+}
+function console_default(options) {
+  return consoleLogDestination(options);
+}
+export {
+  createConsoleLogger,
+  console_default as default
+};

node_modules/astro/dist/core/logger/impls/json.d.ts

@@ -0,0 +1,15 @@
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import type { AstroInlineConfig } from '../../../types/public/index.js';
+export type JsonHandlerConfig = {
+    /**
+     * Whether the JSON line should format on multiple lines
+     */
+    pretty?: boolean;
+    /**
+     * The level of logs that should be printed by the logger.
+     */
+    level?: AstroLoggerLevel;
+};
+export declare const SGR_REGEX: RegExp;
+export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export declare function createJsonLoggerFromFlags(config: AstroInlineConfig): AstroLogger;

node_modules/astro/dist/core/logger/impls/json.js

@@ -0,0 +1,42 @@
+import {
+  AstroLogger,
+  levels
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+const SGR_REGEX = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+function jsonLoggerDestination(config = {}) {
+  const { pretty = false, level = "info" } = config;
+  return {
+    write(event) {
+      let dest = process.stderr;
+      if (levels[event.level] < levels["error"]) {
+        dest = process.stdout;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      let trailingLine = event.newLine ? "\n" : "";
+      const message = event.message.replace(SGR_REGEX, "");
+      if (pretty) {
+        dest.write(
+          JSON.stringify({ message, label: event.label, level: event.level }, null, 2) + trailingLine
+        );
+      } else {
+        dest.write(
+          JSON.stringify({ message, label: event.label, level: event.level }) + trailingLine
+        );
+      }
+    }
+  };
+}
+function createJsonLoggerFromFlags(config) {
+  return new AstroLogger({
+    destination: jsonLoggerDestination({ pretty: false }),
+    level: config.logLevel ?? "info"
+  });
+}
+export {
+  SGR_REGEX,
+  createJsonLoggerFromFlags,
+  jsonLoggerDestination as default
+};

node_modules/astro/dist/core/logger/impls/node.d.ts

@@ -0,0 +1,7 @@
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import type { AstroInlineConfig } from '../../../types/public/index.js';
+export type NodeHandlerConfig = {
+    level?: AstroLoggerLevel;
+};
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export declare function createNodeLoggerFromFlags(inlineConfig: AstroInlineConfig): AstroLogger;

node_modules/astro/dist/core/logger/impls/node.js

@@ -0,0 +1,40 @@
+import {
+  AstroLogger,
+  getEventPrefix,
+  levels
+} from "../core.js";
+import { matchesLevel } from "../public.js";
+function nodeLogDestination(config = {}) {
+  const { level = "info" } = config;
+  return {
+    write(event) {
+      let dest = process.stderr;
+      if (levels[event.level] < levels["error"]) {
+        dest = process.stdout;
+      }
+      if (!matchesLevel(event.level, level)) {
+        return;
+      }
+      let trailingLine = event.newLine ? "\n" : "";
+      if (event.label === "SKIP_FORMAT") {
+        dest.write(event.message + trailingLine);
+      } else {
+        dest.write(getEventPrefix(event) + " " + event.message + trailingLine);
+      }
+    }
+  };
+}
+function node_default(options) {
+  return nodeLogDestination(options);
+}
+function createNodeLoggerFromFlags(inlineConfig) {
+  if (inlineConfig.logger) return inlineConfig.logger;
+  return new AstroLogger({
+    destination: nodeLogDestination(),
+    level: inlineConfig.logLevel ?? "info"
+  });
+}
+export {
+  createNodeLoggerFromFlags,
+  node_default as default
+};

node_modules/astro/dist/core/logger/load.d.ts

@@ -0,0 +1,11 @@
+import { AstroLogger, type AstroLoggerLevel } from './core.js';
+import type { LoggerHandlerConfig } from './config.js';
+import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
+export declare function loadLogger(config: LoggerHandlerConfig, level?: AstroLoggerLevel): Promise<AstroLogger>;
+/**
+ * It attempts to load a logger from the entrypoint.
+ * If not provided, it creates a new logger instance on the fly.
+ * @param astroConfig
+ * @param inlineAstroConfig
+ */
+export declare function loadOrCreateNodeLogger(astroConfig: AstroConfig, inlineAstroConfig: AstroInlineConfig): Promise<AstroLogger>;

node_modules/astro/dist/core/logger/load.js

@@ -0,0 +1,88 @@
+import { AstroLogger } from "./core.js";
+import { AstroError } from "../errors/index.js";
+import { UnableToLoadLogger } from "../errors/errors-data.js";
+import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls/node.js";
+import { default as consoleLoggerCreator } from "./impls/console.js";
+import { default as jsonLoggerCreator } from "./impls/json.js";
+import { default as composeLoggerCreator } from "./impls/compose.js";
+async function loadLogger(config, level = "info") {
+  let cause = void 0;
+  try {
+    switch (config.entrypoint) {
+      case "astro/logger/node": {
+        return new AstroLogger({
+          destination: nodeLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/console": {
+        return new AstroLogger({
+          destination: consoleLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/json": {
+        return new AstroLogger({
+          destination: jsonLoggerCreator(config.config),
+          level
+        });
+      }
+      case "astro/logger/compose": {
+        let destinations = [];
+        if (config.config?.loggers) {
+          const loggers = config.config?.loggers;
+          destinations = await Promise.all(
+            loggers.map(async (loggerConfig) => {
+              const logger = await import(
+                /* @vite-ignore */
+                loggerConfig.entrypoint
+              );
+              return logger.default(loggerConfig.config);
+            })
+          );
+        }
+        return new AstroLogger({
+          destination: composeLoggerCreator(destinations),
+          level
+        });
+      }
+      default: {
+        const nodeLogger = await import(
+          /* @vite-ignore */
+          config.entrypoint
+        );
+        return new AstroLogger({
+          destination: nodeLogger.default(config.config),
+          level
+        });
+      }
+    }
+  } catch (e) {
+    if (e instanceof Error) {
+      cause = e;
+    }
+  }
+  const error = new AstroError({
+    ...UnableToLoadLogger,
+    message: UnableToLoadLogger.message(config.entrypoint)
+  });
+  if (cause) {
+    error.cause = cause;
+  }
+  throw error;
+}
+async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
+  try {
+    if (astroConfig.experimental.logger) {
+      return await loadLogger(astroConfig.experimental.logger, inlineAstroConfig.logLevel);
+    } else {
+      return createNodeLoggerFromFlags(inlineAstroConfig);
+    }
+  } catch {
+    return createNodeLoggerFromFlags(inlineAstroConfig);
+  }
+}
+export {
+  loadLogger,
+  loadOrCreateNodeLogger
+};

node_modules/astro/dist/core/logger/node.d.ts

@@ -0,0 +1 @@
+export declare function enableVerboseLogging(): void;

node_modules/astro/dist/core/logger/node.js

@@ -0,0 +1,19 @@
+import { createDebug, enable as obugEnable } from "obug";
+const debuggers = {};
+function debug(type, ...messages) {
+  const namespace = `astro:${type}`;
+  debuggers[namespace] = debuggers[namespace] || createDebug(namespace);
+  return debuggers[namespace](...messages);
+}
+globalThis._astroGlobalDebug = debug;
+function enableVerboseLogging() {
+  obugEnable("astro:*,vite:*");
+  debug("cli", '--verbose flag enabled! Enabling: DEBUG="astro:*,vite:*"');
+  debug(
+    "cli",
+    'Tip: Set the DEBUG env variable directly for more control. Example: "DEBUG=astro:*,vite:* astro build".'
+  );
+}
+export {
+  enableVerboseLogging
+};

node_modules/astro/dist/core/logger/public.d.ts

@@ -0,0 +1,17 @@
+import { type AstroLoggerLevel } from './core.js';
+/**
+ * Returns `true` if `messageLevel` has a level equals or higher than `configuredLevel`. As a golden rule,
+ * the first argument should be level of the incoming message, and the second argument should be the
+ * configured level of the logger.
+ *
+ * @param messageLevel The level of the incoming message
+ * @param configuredLevel The level the logger is configured with
+ *
+ * @example
+ *
+ * ```js
+ * matchesLevel('error', 'info') // true, because 'error' has higher priority than 'info'
+ * matchesLevel('info', 'error') // false, because 'info' has lower priority than 'error'
+ * ```
+ */
+export declare function matchesLevel(messageLevel: AstroLoggerLevel, configuredLevel: AstroLoggerLevel): boolean;

node_modules/astro/dist/core/logger/public.js

@@ -0,0 +1,7 @@
+import { levels } from "./core.js";
+function matchesLevel(messageLevel, configuredLevel) {
+  return levels[messageLevel] >= levels[configuredLevel];
+}
+export {
+  matchesLevel
+};

node_modules/astro/dist/core/logger/vite.d.ts

@@ -0,0 +1,3 @@
+import type { LogLevel, Logger as ViteLogger } from 'vite';
+import { type AstroLogger as AstroLogger } from './core.js';
+export declare function createViteLogger(astroLogger: AstroLogger, viteLogLevel?: LogLevel): ViteLogger;

node_modules/astro/dist/core/logger/vite.js

@@ -0,0 +1,76 @@
+import { fileURLToPath } from "node:url";
+import { stripVTControlCharacters } from "node:util";
+import { isAstroError } from "../errors/errors.js";
+import { serverShortcuts as formatServerShortcuts } from "../messages/runtime.js";
+import { isLogLevelEnabled } from "./core.js";
+const PKG_PREFIX = fileURLToPath(new URL("../../../", import.meta.url));
+const E2E_PREFIX = fileURLToPath(new URL("../../../e2e", import.meta.url));
+function isAstroSrcFile(id) {
+  return id?.startsWith(PKG_PREFIX) && !id.startsWith(E2E_PREFIX);
+}
+const vitePageReloadMsg = /page reload (.*)/;
+const viteHmrUpdateMsg = /hmr update (.*)/;
+const viteBuildMsg = /vite.*building.*for production/;
+const viteShortcutTitleMsg = /^\s*Shortcuts\s*$/;
+const viteShortcutHelpMsg = /press (.+?) to (.+)$/s;
+const lightningcssUnsupportedPseudoMsg = /\[lightningcss\] 'global'.*not recognized.*pseudo-class/s;
+function createViteLogger(astroLogger, viteLogLevel = "info") {
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const logger = {
+    hasWarned: false,
+    info(msg) {
+      if (!isLogLevelEnabled(viteLogLevel, "info")) return;
+      const stripped = stripVTControlCharacters(msg);
+      let m;
+      if (m = vitePageReloadMsg.exec(stripped)) {
+        if (isAstroSrcFile(m[1])) return;
+        astroLogger.info("watch", m[1]);
+      } else if (m = viteHmrUpdateMsg.exec(stripped)) {
+        if (isAstroSrcFile(m[1])) return;
+        astroLogger.info("watch", m[1]);
+      } else if (viteBuildMsg.test(stripped) || viteShortcutTitleMsg.test(stripped)) {
+      } else if (viteShortcutHelpMsg.test(stripped)) {
+        const [, key, label] = viteShortcutHelpMsg.exec(stripped);
+        astroLogger.info("SKIP_FORMAT", formatServerShortcuts({ key, label }));
+      } else {
+        astroLogger.info("vite", msg);
+      }
+    },
+    warn(msg) {
+      if (!isLogLevelEnabled(viteLogLevel, "warn")) return;
+      if (lightningcssUnsupportedPseudoMsg.test(msg)) return;
+      logger.hasWarned = true;
+      astroLogger.warn("vite", msg);
+    },
+    warnOnce(msg) {
+      if (!isLogLevelEnabled(viteLogLevel, "warn")) return;
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      astroLogger.warn("vite", msg);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      if (!isLogLevelEnabled(viteLogLevel, "error")) return;
+      logger.hasWarned = true;
+      const err = opts?.error;
+      if (err) loggedErrors.add(err);
+      if (err && isAstroError(err)) return;
+      if (msg.includes("Error when evaluating SSR module") || msg.includes("Pre-transform error:")) {
+        astroLogger.debug("vite", msg);
+        return;
+      }
+      astroLogger.error("vite", msg);
+    },
+    // Don't allow clear screen
+    clearScreen: () => {
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
+    }
+  };
+  return logger;
+}
+export {
+  createViteLogger
+};