Refactor routing in App component to enhance navigation and improve error handling by integrating dynamic routes and updating the NotFound route.

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

@@ -0,0 +1,25 @@
+import fs from 'node:fs';
+import type { AstroConfig, AstroInlineConfig, AstroUserConfig } from '../../@types/astro.js';
+export declare function resolveRoot(cwd?: string | URL): string;
+export declare const configPaths: readonly string[];
+interface ResolveConfigPathOptions {
+    root: string;
+    configFile?: string | false;
+    fs: typeof fs;
+}
+/**
+ * Resolve the file URL of the user's `astro.config.js|cjs|mjs|ts` file
+ */
+export declare function resolveConfigPath(options: ResolveConfigPathOptions): Promise<string | undefined>;
+interface ResolveConfigResult {
+    userConfig: AstroUserConfig;
+    astroConfig: AstroConfig;
+}
+/**
+ * Resolves the Astro config with a given inline config.
+ *
+ * @param inlineConfig An inline config that takes highest priority when merging and resolving the final config.
+ * @param command The running command that uses this config. Usually 'dev' or 'build'.
+ */
+export declare function resolveConfig(inlineConfig: AstroInlineConfig, command: string, fsMod?: typeof fs): Promise<ResolveConfigResult>;
+export {};

node_modules/astro/dist/core/config/config.js

@@ -0,0 +1,108 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as colors from "kleur/colors";
+import { ZodError } from "zod";
+import { eventConfigError, telemetry } from "../../events/index.js";
+import { trackAstroConfigZodError } from "../errors/errors.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { formatConfigErrorMessage } from "../messages.js";
+import { mergeConfig } from "./merge.js";
+import { validateConfig } from "./validate.js";
+import { loadConfigWithVite } from "./vite-load.js";
+function resolveRoot(cwd) {
+  if (cwd instanceof URL) {
+    cwd = fileURLToPath(cwd);
+  }
+  return cwd ? path.resolve(cwd) : process.cwd();
+}
+const configPaths = Object.freeze([
+  "astro.config.mjs",
+  "astro.config.js",
+  "astro.config.ts",
+  "astro.config.mts",
+  "astro.config.cjs",
+  "astro.config.cts"
+]);
+async function search(fsMod, root) {
+  const paths = configPaths.map((p) => path.join(root, p));
+  for (const file of paths) {
+    if (fsMod.existsSync(file)) {
+      return file;
+    }
+  }
+}
+async function resolveConfigPath(options) {
+  let userConfigPath;
+  if (options.configFile) {
+    userConfigPath = path.join(options.root, options.configFile);
+    if (!options.fs.existsSync(userConfigPath)) {
+      throw new AstroError({
+        ...AstroErrorData.ConfigNotFound,
+        message: AstroErrorData.ConfigNotFound.message(options.configFile)
+      });
+    }
+  } else {
+    userConfigPath = await search(options.fs, options.root);
+  }
+  return userConfigPath;
+}
+async function loadConfig(root, configFile, fsMod = fs) {
+  if (configFile === false) return {};
+  const configPath = await resolveConfigPath({
+    root,
+    configFile,
+    fs: fsMod
+  });
+  if (!configPath) return {};
+  try {
+    return await loadConfigWithVite({
+      root,
+      configPath,
+      fs: fsMod
+    });
+  } catch (e) {
+    const configPathText = configFile ? colors.bold(configFile) : "your Astro config";
+    console.error(`${colors.bold(colors.red("[astro]"))} Unable to load ${configPathText}
+`);
+    throw e;
+  }
+}
+function splitInlineConfig(inlineConfig) {
+  const { configFile, mode, logLevel, ...inlineUserConfig } = inlineConfig;
+  return {
+    inlineUserConfig,
+    inlineOnlyConfig: {
+      configFile,
+      mode,
+      logLevel
+    }
+  };
+}
+async function resolveConfig(inlineConfig, command, fsMod = fs) {
+  const root = resolveRoot(inlineConfig.root);
+  const { inlineUserConfig, inlineOnlyConfig } = splitInlineConfig(inlineConfig);
+  if (inlineConfig.root) {
+    inlineUserConfig.root = root;
+  }
+  const userConfig = await loadConfig(root, inlineOnlyConfig.configFile, fsMod);
+  const mergedConfig = mergeConfig(userConfig, inlineUserConfig);
+  let astroConfig;
+  try {
+    astroConfig = await validateConfig(mergedConfig, root, command);
+  } catch (e) {
+    if (e instanceof ZodError) {
+      trackAstroConfigZodError(e);
+      console.error(formatConfigErrorMessage(e) + "\n");
+      telemetry.record(eventConfigError({ cmd: command, err: e, isFatal: true }));
+    }
+    throw e;
+  }
+  return { userConfig: mergedConfig, astroConfig };
+}
+export {
+  configPaths,
+  resolveConfig,
+  resolveConfigPath,
+  resolveRoot
+};

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

@@ -0,0 +1,6 @@
+export { configPaths, resolveConfig, resolveConfigPath, resolveRoot, } from './config.js';
+export { createNodeLogger } from './logging.js';
+export { mergeConfig } from './merge.js';
+export type { AstroConfigType } from './schema.js';
+export { createSettings } from './settings.js';
+export { loadTSConfig, updateTSConfigForFramework } from './tsconfig.js';

node_modules/astro/dist/core/config/index.js

@@ -0,0 +1,21 @@
+import {
+  configPaths,
+  resolveConfig,
+  resolveConfigPath,
+  resolveRoot
+} from "./config.js";
+import { createNodeLogger } from "./logging.js";
+import { mergeConfig } from "./merge.js";
+import { createSettings } from "./settings.js";
+import { loadTSConfig, updateTSConfigForFramework } from "./tsconfig.js";
+export {
+  configPaths,
+  createNodeLogger,
+  createSettings,
+  loadTSConfig,
+  mergeConfig,
+  resolveConfig,
+  resolveConfigPath,
+  resolveRoot,
+  updateTSConfigForFramework
+};

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

@@ -0,0 +1,3 @@
+import type { AstroInlineConfig } from '../../@types/astro.js';
+import { Logger } from '../logger/core.js';
+export declare function createNodeLogger(inlineConfig: AstroInlineConfig): Logger;

node_modules/astro/dist/core/config/logging.js

@@ -0,0 +1,12 @@
+import { Logger } from "../logger/core.js";
+import { nodeLogDestination } from "../logger/node.js";
+function createNodeLogger(inlineConfig) {
+  if (inlineConfig.logger) return inlineConfig.logger;
+  return new Logger({
+    dest: nodeLogDestination,
+    level: inlineConfig.logLevel ?? "info"
+  });
+}
+export {
+  createNodeLogger
+};

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

@@ -0,0 +1 @@
+export declare function mergeConfig(defaults: Record<string, any>, overrides: Record<string, any>, isRoot?: boolean): Record<string, any>;

node_modules/astro/dist/core/config/merge.js

@@ -0,0 +1,55 @@
+import { mergeConfig as mergeViteConfig } from "vite";
+import { arraify, isObject, isURL } from "../util.js";
+function mergeConfigRecursively(defaults, overrides, rootPath) {
+  const merged = { ...defaults };
+  for (const key in overrides) {
+    const value = overrides[key];
+    if (value == null) {
+      continue;
+    }
+    let existing = merged[key];
+    if (existing == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (key === "vite" && rootPath === "") {
+      merged[key] = mergeViteConfig(existing, value);
+      continue;
+    }
+    if (key === "server" && rootPath === "") {
+      if (typeof existing === "function" || typeof value === "function") {
+        merged[key] = (...args) => {
+          const existingConfig = typeof existing === "function" ? existing(...args) : existing;
+          const valueConfig = typeof value === "function" ? value(...args) : value;
+          return mergeConfigRecursively(existingConfig, valueConfig, key);
+        };
+        continue;
+      }
+    }
+    if (key === "data" && rootPath === "db") {
+      if (!Array.isArray(existing) && !Array.isArray(value)) {
+        existing = [existing];
+      }
+    }
+    if (Array.isArray(existing) || Array.isArray(value)) {
+      merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
+      continue;
+    }
+    if (isURL(existing) && isURL(value)) {
+      merged[key] = value;
+      continue;
+    }
+    if (isObject(existing) && isObject(value)) {
+      merged[key] = mergeConfigRecursively(existing, value, rootPath ? `${rootPath}.${key}` : key);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function mergeConfig(defaults, overrides, isRoot = true) {
+  return mergeConfigRecursively(defaults, overrides, isRoot ? "" : ".");
+}
+export {
+  mergeConfig
+};

node_modules/astro/dist/core/config/schema.js

@@ -0,0 +1,446 @@
+import { markdownConfigDefaults } from "@astrojs/markdown-remark";
+import { bundledThemes } from "shiki";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+import { EnvSchema } from "../../env/schema.js";
+import { appendForwardSlash, prependForwardSlash, removeTrailingForwardSlash } from "../path.js";
+const ASTRO_CONFIG_DEFAULTS = {
+  root: ".",
+  srcDir: "./src",
+  publicDir: "./public",
+  outDir: "./dist",
+  cacheDir: "./node_modules/.astro",
+  base: "/",
+  trailingSlash: "ignore",
+  build: {
+    format: "directory",
+    client: "./dist/client/",
+    server: "./dist/server/",
+    assets: "_astro",
+    serverEntry: "entry.mjs",
+    redirects: true,
+    inlineStylesheets: "auto",
+    concurrency: 1
+  },
+  image: {
+    service: { entrypoint: "astro/assets/services/sharp", config: {} }
+  },
+  devToolbar: {
+    enabled: true
+  },
+  compressHTML: true,
+  server: {
+    host: false,
+    port: 4321,
+    open: false
+  },
+  integrations: [],
+  markdown: markdownConfigDefaults,
+  vite: {},
+  legacy: {},
+  redirects: {},
+  security: {},
+  experimental: {
+    directRenderScript: false,
+    contentCollectionCache: false,
+    clientPrerender: false,
+    globalRoutePriority: false,
+    serverIslands: false,
+    contentIntellisense: false,
+    env: {
+      validateSecrets: false
+    },
+    contentLayer: false
+  }
+};
+const AstroConfigSchema = z.object({
+  root: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => new URL(val)),
+  srcDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => new URL(val)),
+  publicDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => new URL(val)),
+  outDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => new URL(val)),
+  cacheDir: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.cacheDir).transform((val) => new URL(val)),
+  site: z.string().url().optional(),
+  compressHTML: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.compressHTML),
+  base: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.base),
+  trailingSlash: z.union([z.literal("always"), z.literal("never"), z.literal("ignore")]).optional().default(ASTRO_CONFIG_DEFAULTS.trailingSlash),
+  output: z.union([z.literal("static"), z.literal("server"), z.literal("hybrid")]).optional().default("static"),
+  scopedStyleStrategy: z.union([z.literal("where"), z.literal("class"), z.literal("attribute")]).optional().default("attribute"),
+  adapter: z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) }).optional(),
+  integrations: z.preprocess(
+    // preprocess
+    (val) => Array.isArray(val) ? val.flat(Infinity).filter(Boolean) : val,
+    // validate
+    z.array(z.object({ name: z.string(), hooks: z.object({}).passthrough().default({}) })).default(ASTRO_CONFIG_DEFAULTS.integrations)
+  ),
+  build: z.object({
+    format: z.union([z.literal("file"), z.literal("directory"), z.literal("preserve")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
+    client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => new URL(val)),
+    server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => new URL(val)),
+    assets: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.assets),
+    assetsPrefix: z.string().optional().or(z.object({ fallback: z.string() }).and(z.record(z.string())).optional()).refine(
+      (value) => {
+        if (value && typeof value !== "string") {
+          if (!value.fallback) {
+            return false;
+          }
+        }
+        return true;
+      },
+      {
+        message: "The `fallback` is mandatory when defining the option as an object."
+      }
+    ),
+    serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry),
+    redirects: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.redirects),
+    inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets),
+    concurrency: z.number().min(1).optional().default(ASTRO_CONFIG_DEFAULTS.build.concurrency)
+  }).default({}),
+  server: z.preprocess(
+    // preprocess
+    // NOTE: Uses the "error" command here because this is overwritten by the
+    // individualized schema parser with the correct command.
+    (val) => typeof val === "function" ? val({ command: "error" }) : val,
+    // validate
+    z.object({
+      open: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.open),
+      host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
+      port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
+      headers: z.custom().optional()
+    }).default({})
+  ),
+  redirects: z.record(
+    z.string(),
+    z.union([
+      z.string(),
+      z.object({
+        status: z.union([
+          z.literal(300),
+          z.literal(301),
+          z.literal(302),
+          z.literal(303),
+          z.literal(304),
+          z.literal(307),
+          z.literal(308)
+        ]),
+        destination: z.string()
+      })
+    ])
+  ).default(ASTRO_CONFIG_DEFAULTS.redirects),
+  prefetch: z.union([
+    z.boolean(),
+    z.object({
+      prefetchAll: z.boolean().optional(),
+      defaultStrategy: z.enum(["tap", "hover", "viewport", "load"]).optional()
+    })
+  ]).optional(),
+  image: z.object({
+    endpoint: z.string().optional(),
+    service: z.object({
+      entrypoint: z.union([
+        z.literal("astro/assets/services/sharp"),
+        z.literal("astro/assets/services/squoosh"),
+        z.string()
+      ]).default(ASTRO_CONFIG_DEFAULTS.image.service.entrypoint),
+      config: z.record(z.any()).default({})
+    }).default(ASTRO_CONFIG_DEFAULTS.image.service),
+    domains: z.array(z.string()).default([]),
+    remotePatterns: z.array(
+      z.object({
+        protocol: z.string().optional(),
+        hostname: z.string().refine(
+          (val) => !val.includes("*") || val.startsWith("*.") || val.startsWith("**."),
+          {
+            message: "wildcards can only be placed at the beginning of the hostname"
+          }
+        ).optional(),
+        port: z.string().optional(),
+        pathname: z.string().refine((val) => !val.includes("*") || val.endsWith("/*") || val.endsWith("/**"), {
+          message: "wildcards can only be placed at the end of a pathname"
+        }).optional()
+      })
+    ).default([])
+  }).default(ASTRO_CONFIG_DEFAULTS.image),
+  devToolbar: z.object({
+    enabled: z.boolean().default(ASTRO_CONFIG_DEFAULTS.devToolbar.enabled)
+  }).default(ASTRO_CONFIG_DEFAULTS.devToolbar),
+  markdown: z.object({
+    syntaxHighlight: z.union([z.literal("shiki"), z.literal("prism"), z.literal(false)]).default(ASTRO_CONFIG_DEFAULTS.markdown.syntaxHighlight),
+    shikiConfig: z.object({
+      langs: z.custom().array().transform((langs) => {
+        for (const lang of langs) {
+          if (typeof lang === "object") {
+            if (lang.id) {
+              lang.name = lang.id;
+            }
+            if (lang.grammar) {
+              Object.assign(lang, lang.grammar);
+            }
+          }
+        }
+        return langs;
+      }).default([]),
+      langAlias: z.record(z.string(), z.string()).optional().default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.langAlias),
+      theme: z.enum(Object.keys(bundledThemes)).or(z.custom()).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.theme),
+      themes: z.record(
+        z.enum(Object.keys(bundledThemes)).or(z.custom())
+      ).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.themes),
+      defaultColor: z.union([z.literal("light"), z.literal("dark"), z.string(), z.literal(false)]).optional(),
+      wrap: z.boolean().or(z.null()).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.wrap),
+      transformers: z.custom().array().transform((transformers) => {
+        for (const transformer of transformers) {
+          if (transformer.token && !("span" in transformer)) {
+            transformer.span = transformer.token;
+          }
+        }
+        return transformers;
+      }).default(ASTRO_CONFIG_DEFAULTS.markdown.shikiConfig.transformers)
+    }).default({}),
+    remarkPlugins: z.union([
+      z.string(),
+      z.tuple([z.string(), z.any()]),
+      z.custom((data) => typeof data === "function"),
+      z.tuple([z.custom((data) => typeof data === "function"), z.any()])
+    ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.remarkPlugins),
+    rehypePlugins: z.union([
+      z.string(),
+      z.tuple([z.string(), z.any()]),
+      z.custom((data) => typeof data === "function"),
+      z.tuple([z.custom((data) => typeof data === "function"), z.any()])
+    ]).array().default(ASTRO_CONFIG_DEFAULTS.markdown.rehypePlugins),
+    remarkRehype: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.markdown.remarkRehype),
+    gfm: z.boolean().default(ASTRO_CONFIG_DEFAULTS.markdown.gfm),
+    smartypants: z.boolean().default(ASTRO_CONFIG_DEFAULTS.markdown.smartypants)
+  }).default({}),
+  vite: z.custom((data) => data instanceof Object && !Array.isArray(data)).default(ASTRO_CONFIG_DEFAULTS.vite),
+  i18n: z.optional(
+    z.object({
+      defaultLocale: z.string(),
+      locales: z.array(
+        z.union([
+          z.string(),
+          z.object({
+            path: z.string(),
+            codes: z.string().array().nonempty()
+          })
+        ])
+      ),
+      domains: z.record(
+        z.string(),
+        z.string().url(
+          "The domain value must be a valid URL, and it has to start with 'https' or 'http'."
+        )
+      ).optional(),
+      fallback: z.record(z.string(), z.string()).optional(),
+      routing: z.literal("manual").or(
+        z.object({
+          prefixDefaultLocale: z.boolean().optional().default(false),
+          redirectToDefaultLocale: z.boolean().optional().default(true),
+          fallbackType: z.enum(["redirect", "rewrite"]).optional().default("redirect")
+        }).refine(
+          ({ prefixDefaultLocale, redirectToDefaultLocale }) => {
+            return !(prefixDefaultLocale === false && redirectToDefaultLocale === false);
+          },
+          {
+            message: "The option `i18n.redirectToDefaultLocale` is only useful when the `i18n.prefixDefaultLocale` is set to `true`. Remove the option `i18n.redirectToDefaultLocale`, or change its value to `true`."
+          }
+        )
+      ).optional().default({})
+    }).optional().superRefine((i18n, ctx) => {
+      if (i18n) {
+        const { defaultLocale, locales: _locales, fallback, domains } = i18n;
+        const locales = _locales.map((locale) => {
+          if (typeof locale === "string") {
+            return locale;
+          } else {
+            return locale.path;
+          }
+        });
+        if (!locales.includes(defaultLocale)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `The default locale \`${defaultLocale}\` is not present in the \`i18n.locales\` array.`
+          });
+        }
+        if (fallback) {
+          for (const [fallbackFrom, fallbackTo] of Object.entries(fallback)) {
+            if (!locales.includes(fallbackFrom)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `The locale \`${fallbackFrom}\` key in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`
+              });
+            }
+            if (fallbackFrom === defaultLocale) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `You can't use the default locale as a key. The default locale can only be used as value.`
+              });
+            }
+            if (!locales.includes(fallbackTo)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `The locale \`${fallbackTo}\` value in the \`i18n.fallback\` record doesn't exist in the \`i18n.locales\` array.`
+              });
+            }
+          }
+        }
+        if (domains) {
+          const entries = Object.entries(domains);
+          const hasDomains = domains ? Object.keys(domains).length > 0 : false;
+          if (entries.length > 0 && !hasDomains) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: `When specifying some domains, the property \`i18n.routingStrategy\` must be set to \`"domains"\`.`
+            });
+          }
+          for (const [domainKey, domainValue] of entries) {
+            if (!locales.includes(domainKey)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `The locale \`${domainKey}\` key in the \`i18n.domains\` record doesn't exist in the \`i18n.locales\` array.`
+              });
+            }
+            if (!domainValue.startsWith("https") && !domainValue.startsWith("http")) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: "The domain value must be a valid URL, and it has to start with 'https' or 'http'.",
+                path: ["domains"]
+              });
+            } else {
+              try {
+                const domainUrl = new URL(domainValue);
+                if (domainUrl.pathname !== "/") {
+                  ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `The URL \`${domainValue}\` must contain only the origin. A subsequent pathname isn't allowed here. Remove \`${domainUrl.pathname}\`.`,
+                    path: ["domains"]
+                  });
+                }
+              } catch {
+              }
+            }
+          }
+        }
+      }
+    })
+  ),
+  security: z.object({
+    checkOrigin: z.boolean().default(false)
+  }).optional().default(ASTRO_CONFIG_DEFAULTS.security),
+  experimental: z.object({
+    directRenderScript: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.directRenderScript),
+    contentCollectionCache: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentCollectionCache),
+    clientPrerender: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.clientPrerender),
+    globalRoutePriority: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.globalRoutePriority),
+    env: z.object({
+      schema: EnvSchema.optional(),
+      validateSecrets: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.env.validateSecrets)
+    }).strict().optional(),
+    serverIslands: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.serverIslands),
+    contentIntellisense: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentIntellisense),
+    contentLayer: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.experimental.contentLayer)
+  }).strict(
+    `Invalid or outdated experimental feature.
+Check for incorrect spelling or outdated Astro version.
+See https://docs.astro.build/en/reference/configuration-reference/#experimental-flags for a list of all current experiments.`
+  ).default({}),
+  legacy: z.object({}).default({})
+});
+function createRelativeSchema(cmd, fileProtocolRoot) {
+  const AstroConfigRelativeSchema = AstroConfigSchema.extend({
+    root: z.string().default(ASTRO_CONFIG_DEFAULTS.root).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    srcDir: z.string().default(ASTRO_CONFIG_DEFAULTS.srcDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    compressHTML: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.compressHTML),
+    publicDir: z.string().default(ASTRO_CONFIG_DEFAULTS.publicDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    outDir: z.string().default(ASTRO_CONFIG_DEFAULTS.outDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    cacheDir: z.string().default(ASTRO_CONFIG_DEFAULTS.cacheDir).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+    build: z.object({
+      format: z.union([z.literal("file"), z.literal("directory"), z.literal("preserve")]).optional().default(ASTRO_CONFIG_DEFAULTS.build.format),
+      client: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.client).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+      server: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.server).transform((val) => resolveDirAsUrl(val, fileProtocolRoot)),
+      assets: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.assets),
+      assetsPrefix: z.string().optional().or(z.object({ fallback: z.string() }).and(z.record(z.string())).optional()).refine(
+        (value) => {
+          if (value && typeof value !== "string") {
+            if (!value.fallback) {
+              return false;
+            }
+          }
+          return true;
+        },
+        {
+          message: "The `fallback` is mandatory when defining the option as an object."
+        }
+      ),
+      serverEntry: z.string().optional().default(ASTRO_CONFIG_DEFAULTS.build.serverEntry),
+      redirects: z.boolean().optional().default(ASTRO_CONFIG_DEFAULTS.build.redirects),
+      inlineStylesheets: z.enum(["always", "auto", "never"]).optional().default(ASTRO_CONFIG_DEFAULTS.build.inlineStylesheets),
+      concurrency: z.number().min(1).optional().default(ASTRO_CONFIG_DEFAULTS.build.concurrency)
+    }).optional().default({}),
+    server: z.preprocess(
+      // preprocess
+      (val) => {
+        if (typeof val === "function") {
+          return val({ command: cmd === "dev" ? "dev" : "preview" });
+        } else {
+          return val;
+        }
+      },
+      // validate
+      z.object({
+        open: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.open),
+        host: z.union([z.string(), z.boolean()]).optional().default(ASTRO_CONFIG_DEFAULTS.server.host),
+        port: z.number().optional().default(ASTRO_CONFIG_DEFAULTS.server.port),
+        headers: z.custom().optional(),
+        streaming: z.boolean().optional().default(true)
+      }).optional().default({})
+    )
+  }).transform((config) => {
+    if (!config.build.server.toString().startsWith(config.outDir.toString()) && config.build.server.toString().endsWith("dist/server/")) {
+      config.build.server = new URL("./dist/server/", config.outDir);
+    }
+    if (!config.build.client.toString().startsWith(config.outDir.toString()) && config.build.client.toString().endsWith("dist/client/")) {
+      config.build.client = new URL("./dist/client/", config.outDir);
+    }
+    if (config.trailingSlash === "never") {
+      config.base = prependForwardSlash(removeTrailingForwardSlash(config.base));
+    } else if (config.trailingSlash === "always") {
+      config.base = prependForwardSlash(appendForwardSlash(config.base));
+    } else {
+      config.base = prependForwardSlash(config.base);
+    }
+    return config;
+  }).refine((obj) => !obj.outDir.toString().startsWith(obj.publicDir.toString()), {
+    message: "The value of `outDir` must not point to a path within the folder set as `publicDir`, this will cause an infinite loop"
+  }).superRefine((configuration, ctx) => {
+    const { site, i18n, output } = configuration;
+    const hasDomains = i18n?.domains ? Object.keys(i18n.domains).length > 0 : false;
+    if (hasDomains) {
+      if (!site) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: "The option `site` isn't set. When using the 'domains' strategy for `i18n`, `site` is required to create absolute URLs for locales that aren't mapped to a domain."
+        });
+      }
+      if (output !== "server") {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: 'Domain support is only available when `output` is `"server"`.'
+        });
+      }
+    }
+  });
+  return AstroConfigRelativeSchema;
+}
+function resolveDirAsUrl(dir, root) {
+  let resolvedDir = path.resolve(root, dir);
+  if (!resolvedDir.endsWith(path.sep)) {
+    resolvedDir += path.sep;
+  }
+  return pathToFileURL(resolvedDir);
+}
+export {
+  ASTRO_CONFIG_DEFAULTS,
+  AstroConfigSchema,
+  createRelativeSchema
+};

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

@@ -0,0 +1,3 @@
+import type { AstroConfig, AstroSettings } from '../../@types/astro.js';
+export declare function createBaseSettings(config: AstroConfig): AstroSettings;
+export declare function createSettings(config: AstroConfig, cwd?: string): Promise<AstroSettings>;

node_modules/astro/dist/core/config/settings.js

@@ -0,0 +1,124 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import yaml from "js-yaml";
+import { getContentPaths } from "../../content/index.js";
+import createPreferences from "../../preferences/index.js";
+import { markdownContentEntryType } from "../../vite-plugin-markdown/content-entry-type.js";
+import { getDefaultClientDirectives } from "../client-directive/index.js";
+import { AstroError, AstroErrorData } from "../errors/index.js";
+import { formatYAMLException, isYAMLException } from "../errors/utils.js";
+import { SUPPORTED_MARKDOWN_FILE_EXTENSIONS } from "./../constants.js";
+import { AstroTimer } from "./timer.js";
+import { loadTSConfig } from "./tsconfig.js";
+function createBaseSettings(config) {
+  const { contentDir } = getContentPaths(config);
+  const dotAstroDir = new URL(".astro/", config.root);
+  const preferences = createPreferences(config, dotAstroDir);
+  return {
+    config,
+    preferences,
+    tsConfig: void 0,
+    tsConfigPath: void 0,
+    adapter: void 0,
+    injectedRoutes: [],
+    resolvedInjectedRoutes: [],
+    serverIslandMap: /* @__PURE__ */ new Map(),
+    serverIslandNameMap: /* @__PURE__ */ new Map(),
+    pageExtensions: [".astro", ".html", ...SUPPORTED_MARKDOWN_FILE_EXTENSIONS],
+    contentEntryTypes: [markdownContentEntryType],
+    dataEntryTypes: [
+      {
+        extensions: [".json"],
+        getEntryInfo({ contents, fileUrl }) {
+          if (contents === void 0 || contents === "") return { data: {} };
+          const pathRelToContentDir = path.relative(
+            fileURLToPath(contentDir),
+            fileURLToPath(fileUrl)
+          );
+          let data;
+          try {
+            data = JSON.parse(contents);
+          } catch (e) {
+            throw new AstroError({
+              ...AstroErrorData.DataCollectionEntryParseError,
+              message: AstroErrorData.DataCollectionEntryParseError.message(
+                pathRelToContentDir,
+                e instanceof Error ? e.message : "contains invalid JSON."
+              ),
+              location: { file: fileUrl.pathname },
+              stack: e instanceof Error ? e.stack : void 0
+            });
+          }
+          if (data == null || typeof data !== "object") {
+            throw new AstroError({
+              ...AstroErrorData.DataCollectionEntryParseError,
+              message: AstroErrorData.DataCollectionEntryParseError.message(
+                pathRelToContentDir,
+                "data is not an object."
+              ),
+              location: { file: fileUrl.pathname }
+            });
+          }
+          return { data };
+        }
+      },
+      {
+        extensions: [".yaml", ".yml"],
+        getEntryInfo({ contents, fileUrl }) {
+          try {
+            const data = yaml.load(contents, { filename: fileURLToPath(fileUrl) });
+            const rawData = contents;
+            return { data, rawData };
+          } catch (e) {
+            const pathRelToContentDir = path.relative(
+              fileURLToPath(contentDir),
+              fileURLToPath(fileUrl)
+            );
+            const formattedError = isYAMLException(e) ? formatYAMLException(e) : new Error("contains invalid YAML.");
+            throw new AstroError({
+              ...AstroErrorData.DataCollectionEntryParseError,
+              message: AstroErrorData.DataCollectionEntryParseError.message(
+                pathRelToContentDir,
+                formattedError.message
+              ),
+              stack: formattedError.stack,
+              location: "loc" in formattedError ? { file: fileUrl.pathname, ...formattedError.loc } : { file: fileUrl.pathname }
+            });
+          }
+        }
+      }
+    ],
+    renderers: [],
+    scripts: [],
+    clientDirectives: getDefaultClientDirectives(),
+    middlewares: { pre: [], post: [] },
+    watchFiles: [],
+    devToolbarApps: [],
+    timer: new AstroTimer(),
+    dotAstroDir,
+    latestAstroVersion: void 0,
+    // Will be set later if applicable when the dev server starts
+    injectedTypes: []
+  };
+}
+async function createSettings(config, cwd) {
+  const tsconfig = await loadTSConfig(cwd);
+  const settings = createBaseSettings(config);
+  let watchFiles = [];
+  if (cwd) {
+    watchFiles.push(fileURLToPath(new URL("./package.json", pathToFileURL(cwd))));
+  }
+  if (typeof tsconfig !== "string") {
+    watchFiles.push(
+      ...[tsconfig.tsconfigFile, ...(tsconfig.extended ?? []).map((e) => e.tsconfigFile)]
+    );
+    settings.tsConfig = tsconfig.tsconfig;
+    settings.tsConfigPath = tsconfig.tsconfigFile;
+  }
+  settings.watchFiles = watchFiles;
+  return settings;
+}
+export {
+  createBaseSettings,
+  createSettings
+};

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

@@ -0,0 +1,27 @@
+export interface Stat {
+    elapsedTime: number;
+    heapUsedChange: number;
+    heapUsedTotal: number;
+}
+/**
+ * Timer to track certain operations' performance. Used by Astro's scripts only.
+ * Set `process.env.ASTRO_TIMER_PATH` truthy to enable.
+ */
+export declare class AstroTimer {
+    private enabled;
+    private ongoingTimers;
+    private stats;
+    constructor();
+    /**
+     * Start a timer for a scope with a given name.
+     */
+    start(name: string): void;
+    /**
+     * End a timer for a scope with a given name.
+     */
+    end(name: string): void;
+    /**
+     * Write stats to `process.env.ASTRO_TIMER_PATH`
+     */
+    writeStats(): void;
+}

node_modules/astro/dist/core/config/timer.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+class AstroTimer {
+  enabled;
+  ongoingTimers = /* @__PURE__ */ new Map();
+  stats = {};
+  constructor() {
+    this.enabled = !!process.env.ASTRO_TIMER_PATH;
+  }
+  /**
+   * Start a timer for a scope with a given name.
+   */
+  start(name) {
+    if (!this.enabled) return;
+    globalThis.gc?.();
+    this.ongoingTimers.set(name, {
+      startTime: performance.now(),
+      startHeap: process.memoryUsage().heapUsed
+    });
+  }
+  /**
+   * End a timer for a scope with a given name.
+   */
+  end(name) {
+    if (!this.enabled) return;
+    const stat = this.ongoingTimers.get(name);
+    if (!stat) return;
+    globalThis.gc?.();
+    const endHeap = process.memoryUsage().heapUsed;
+    this.stats[name] = {
+      elapsedTime: performance.now() - stat.startTime,
+      heapUsedChange: endHeap - stat.startHeap,
+      heapUsedTotal: endHeap
+    };
+    this.ongoingTimers.delete(name);
+  }
+  /**
+   * Write stats to `process.env.ASTRO_TIMER_PATH`
+   */
+  writeStats() {
+    if (!this.enabled) return;
+    fs.writeFileSync(process.env.ASTRO_TIMER_PATH, JSON.stringify(this.stats, null, 2));
+  }
+}
+export {
+  AstroTimer
+};

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

@@ -0,0 +1,28 @@
+import { type TSConfckParseResult } from 'tsconfck';
+import type { CompilerOptions, TypeAcquisition } from 'typescript';
+export declare const defaultTSConfig: TSConfig;
+export type frameworkWithTSSettings = 'vue' | 'react' | 'preact' | 'solid-js';
+export declare const presets: Map<frameworkWithTSSettings, TSConfig>;
+type TSConfigResult<T = object> = Promise<(TSConfckParseResult & T) | 'invalid-config' | 'missing-config' | 'unknown-error'>;
+/**
+ * Load a tsconfig.json or jsconfig.json is the former is not found
+ * @param root The root directory to search in, defaults to `process.cwd()`.
+ * @param findUp Whether to search for the config file in parent directories, by default only the root directory is searched.
+ */
+export declare function loadTSConfig(root: string | undefined, findUp?: boolean): Promise<TSConfigResult<{
+    rawConfig: TSConfig;
+}>>;
+export declare function updateTSConfigForFramework(target: TSConfig, framework: frameworkWithTSSettings): TSConfig;
+export type StripEnums<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any;
+};
+export interface TSConfig {
+    compilerOptions?: StripEnums<CompilerOptions>;
+    compileOnSave?: boolean;
+    extends?: string;
+    files?: string[];
+    include?: string[];
+    exclude?: string[];
+    typeAcquisition?: TypeAcquisition;
+}
+export {};

node_modules/astro/dist/core/config/tsconfig.js

@@ -0,0 +1,123 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  TSConfckParseError,
+  find,
+  parse,
+  toJson
+} from "tsconfck";
+const defaultTSConfig = { extends: "astro/tsconfigs/base" };
+const presets = /* @__PURE__ */ new Map([
+  [
+    "vue",
+    // Settings needed for template intellisense when using Volar
+    {
+      compilerOptions: {
+        jsx: "preserve"
+      }
+    }
+  ],
+  [
+    "react",
+    // Default TypeScript settings, but we need to redefine them in case the users changed them previously
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "react"
+      }
+    }
+  ],
+  [
+    "preact",
+    // https://preactjs.com/guide/v10/typescript/#typescript-configuration
+    {
+      compilerOptions: {
+        jsx: "react-jsx",
+        jsxImportSource: "preact"
+      }
+    }
+  ],
+  [
+    "solid-js",
+    // https://www.solidjs.com/guides/typescript#configuring-typescript
+    {
+      compilerOptions: {
+        jsx: "preserve",
+        jsxImportSource: "solid-js"
+      }
+    }
+  ]
+]);
+async function loadTSConfig(root, findUp = false) {
+  const safeCwd = root ?? process.cwd();
+  const [jsconfig, tsconfig] = await Promise.all(
+    ["jsconfig.json", "tsconfig.json"].map(
+      (configName) => (
+        // `tsconfck` expects its first argument to be a file path, not a directory path, so we'll fake one
+        find(join(safeCwd, "./dummy.txt"), {
+          root: findUp ? void 0 : root,
+          configName
+        })
+      )
+    )
+  );
+  if (tsconfig) {
+    const parsedConfig = await safeParse(tsconfig, { root });
+    if (typeof parsedConfig === "string") {
+      return parsedConfig;
+    }
+    const rawConfig = await readFile(tsconfig, "utf-8").then(toJson).then((content) => JSON.parse(content));
+    return { ...parsedConfig, rawConfig };
+  }
+  if (jsconfig) {
+    const parsedConfig = await safeParse(jsconfig, { root });
+    if (typeof parsedConfig === "string") {
+      return parsedConfig;
+    }
+    const rawConfig = await readFile(jsconfig, "utf-8").then(toJson).then((content) => JSON.parse(content));
+    return { ...parsedConfig, rawConfig };
+  }
+  return "missing-config";
+}
+async function safeParse(tsconfigPath, options = {}) {
+  try {
+    const parseResult = await parse(tsconfigPath, options);
+    if (parseResult.tsconfig == null) {
+      return "missing-config";
+    }
+    return parseResult;
+  } catch (e) {
+    if (e instanceof TSConfckParseError) {
+      return "invalid-config";
+    }
+    return "unknown-error";
+  }
+}
+function updateTSConfigForFramework(target, framework) {
+  if (!presets.has(framework)) {
+    return target;
+  }
+  return deepMergeObjects(target, presets.get(framework));
+}
+function deepMergeObjects(a, b) {
+  const merged = { ...a };
+  for (const key in b) {
+    const value = b[key];
+    if (a[key] == null) {
+      merged[key] = value;
+      continue;
+    }
+    if (typeof a[key] === "object" && typeof value === "object") {
+      merged[key] = deepMergeObjects(a[key], value);
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+export {
+  defaultTSConfig,
+  loadTSConfig,
+  presets,
+  updateTSConfigForFramework
+};

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

@@ -0,0 +1,3 @@
+import type { AstroConfig } from '../../@types/astro.js';
+/** Turn raw config values into normalized values */
+export declare function validateConfig(userConfig: any, root: string, cmd: string): Promise<AstroConfig>;

node_modules/astro/dist/core/config/validate.js

@@ -0,0 +1,8 @@
+import { createRelativeSchema } from "./schema.js";
+async function validateConfig(userConfig, root, cmd) {
+  const AstroConfigRelativeSchema = createRelativeSchema(cmd, root);
+  return await AstroConfigRelativeSchema.parseAsync(userConfig);
+}
+export {
+  validateConfig
+};

node_modules/astro/dist/core/config/vite-load.d.ts

@@ -0,0 +1,8 @@
+import type fsType from 'node:fs';
+interface LoadConfigWithViteOptions {
+    root: string;
+    configPath: string;
+    fs: typeof fsType;
+}
+export declare function loadConfigWithVite({ configPath, fs, root, }: LoadConfigWithViteOptions): Promise<Record<string, any>>;
+export {};

node_modules/astro/dist/core/config/vite-load.js

@@ -0,0 +1,56 @@
+import { pathToFileURL } from "node:url";
+import { createServer } from "vite";
+import loadFallbackPlugin from "../../vite-plugin-load-fallback/index.js";
+import { debug } from "../logger/core.js";
+async function createViteServer(root, fs) {
+  const viteServer = await createServer({
+    configFile: false,
+    server: { middlewareMode: true, hmr: false, watch: null, ws: false },
+    optimizeDeps: { noDiscovery: true },
+    clearScreen: false,
+    appType: "custom",
+    ssr: {
+      // NOTE: Vite doesn't externalize linked packages by default. During testing locally,
+      // these dependencies trip up Vite's dev SSR transform. Awaiting upstream feature:
+      // https://github.com/vitejs/vite/pull/10939
+      external: [
+        "@astrojs/tailwind",
+        "@astrojs/mdx",
+        "@astrojs/react",
+        "@astrojs/preact",
+        "@astrojs/sitemap",
+        "@astrojs/markdoc",
+        "@astrojs/db"
+      ]
+    },
+    plugins: [loadFallbackPlugin({ fs, root: pathToFileURL(root) })]
+  });
+  return viteServer;
+}
+async function loadConfigWithVite({
+  configPath,
+  fs,
+  root
+}) {
+  if (/\.[cm]?js$/.test(configPath)) {
+    try {
+      const config = await import(pathToFileURL(configPath).toString() + "?t=" + Date.now());
+      return config.default ?? {};
+    } catch (e) {
+      debug("Failed to load config with Node", e);
+    }
+  }
+  let server;
+  try {
+    server = await createViteServer(root, fs);
+    const mod = await server.ssrLoadModule(configPath, { fixStacktrace: true });
+    return mod.default ?? {};
+  } finally {
+    if (server) {
+      await server.close();
+    }
+  }
+}
+export {
+  loadConfigWithVite
+};