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/content/consts.d.ts

@@ -0,0 +1,25 @@
+export declare const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+export declare const CONTENT_RENDER_FLAG = "astroRenderContent";
+export declare const CONTENT_FLAG = "astroContentCollectionEntry";
+export declare const DATA_FLAG = "astroDataCollectionEntry";
+export declare const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+export declare const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
+export declare const VIRTUAL_MODULE_ID = "astro:content";
+export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
+export declare const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+export declare const RESOLVED_DATA_STORE_VIRTUAL_ID: string;
+export declare const MODULES_MJS_ID = "astro:content-module-imports";
+export declare const MODULES_MJS_VIRTUAL_ID: string;
+export declare const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+export declare const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+export declare const ASSET_IMPORTS_RESOLVED_STUB_ID: string;
+export declare const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
+export declare const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
+export declare const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+export declare const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
+export declare const CONTENT_FLAGS: readonly ["astroContentCollectionEntry", "astroRenderContent", "astroDataCollectionEntry", "astroPropagatedAssets", "astroContentImageFlag", "astroContentModuleFlag"];
+export declare const CONTENT_TYPES_FILE = "astro/content.d.ts";
+export declare const DATA_STORE_FILE = "data-store.json";
+export declare const ASSET_IMPORTS_FILE = "assets.mjs";
+export declare const MODULES_IMPORTS_FILE = "modules.mjs";
+export declare const CONTENT_LAYER_TYPE = "content_layer";

node_modules/astro/dist/content/consts.js

@@ -0,0 +1,59 @@
+const PROPAGATED_ASSET_FLAG = "astroPropagatedAssets";
+const CONTENT_RENDER_FLAG = "astroRenderContent";
+const CONTENT_FLAG = "astroContentCollectionEntry";
+const DATA_FLAG = "astroDataCollectionEntry";
+const CONTENT_IMAGE_FLAG = "astroContentImageFlag";
+const CONTENT_MODULE_FLAG = "astroContentModuleFlag";
+const VIRTUAL_MODULE_ID = "astro:content";
+const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
+const DATA_STORE_VIRTUAL_ID = "astro:data-layer-content";
+const RESOLVED_DATA_STORE_VIRTUAL_ID = "\0" + DATA_STORE_VIRTUAL_ID;
+const MODULES_MJS_ID = "astro:content-module-imports";
+const MODULES_MJS_VIRTUAL_ID = "\0" + MODULES_MJS_ID;
+const DEFERRED_MODULE = "astro:content-layer-deferred-module";
+const ASSET_IMPORTS_VIRTUAL_ID = "astro:asset-imports";
+const ASSET_IMPORTS_RESOLVED_STUB_ID = "\0" + ASSET_IMPORTS_VIRTUAL_ID;
+const LINKS_PLACEHOLDER = "@@ASTRO-LINKS@@";
+const STYLES_PLACEHOLDER = "@@ASTRO-STYLES@@";
+const SCRIPTS_PLACEHOLDER = "@@ASTRO-SCRIPTS@@";
+const IMAGE_IMPORT_PREFIX = "__ASTRO_IMAGE_";
+const CONTENT_FLAGS = [
+  CONTENT_FLAG,
+  CONTENT_RENDER_FLAG,
+  DATA_FLAG,
+  PROPAGATED_ASSET_FLAG,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_MODULE_FLAG
+];
+const CONTENT_TYPES_FILE = "astro/content.d.ts";
+const DATA_STORE_FILE = "data-store.json";
+const ASSET_IMPORTS_FILE = "assets.mjs";
+const MODULES_IMPORTS_FILE = "modules.mjs";
+const CONTENT_LAYER_TYPE = "content_layer";
+export {
+  ASSET_IMPORTS_FILE,
+  ASSET_IMPORTS_RESOLVED_STUB_ID,
+  ASSET_IMPORTS_VIRTUAL_ID,
+  CONTENT_FLAG,
+  CONTENT_FLAGS,
+  CONTENT_IMAGE_FLAG,
+  CONTENT_LAYER_TYPE,
+  CONTENT_MODULE_FLAG,
+  CONTENT_RENDER_FLAG,
+  CONTENT_TYPES_FILE,
+  DATA_FLAG,
+  DATA_STORE_FILE,
+  DATA_STORE_VIRTUAL_ID,
+  DEFERRED_MODULE,
+  IMAGE_IMPORT_PREFIX,
+  LINKS_PLACEHOLDER,
+  MODULES_IMPORTS_FILE,
+  MODULES_MJS_ID,
+  MODULES_MJS_VIRTUAL_ID,
+  PROPAGATED_ASSET_FLAG,
+  RESOLVED_DATA_STORE_VIRTUAL_ID,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  SCRIPTS_PLACEHOLDER,
+  STYLES_PLACEHOLDER,
+  VIRTUAL_MODULE_ID
+};

node_modules/astro/dist/content/content-layer.d.ts

@@ -0,0 +1,46 @@
+import type { FSWatcher } from 'vite';
+import type { AstroSettings, RefreshContentOptions } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+import type { LoaderContext } from './loaders/types.js';
+import type { MutableDataStore } from './mutable-data-store.js';
+export interface ContentLayerOptions {
+    store: MutableDataStore;
+    settings: AstroSettings;
+    logger: Logger;
+    watcher?: FSWatcher;
+}
+export declare class ContentLayer {
+    #private;
+    constructor({ settings, logger, store, watcher }: ContentLayerOptions);
+    /**
+     * Whether the content layer is currently loading content
+     */
+    get loading(): boolean;
+    /**
+     * Watch for changes to the content config and trigger a sync when it changes.
+     */
+    watchContentConfig(): void;
+    unwatchContentConfig(): void;
+    /**
+     * Enqueues a sync job that runs the `load()` method of each collection's loader, which will load the data and save it in the data store.
+     * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+     * perform an incremental update. After the data is loaded, the data store is written to disk. Jobs are queued,
+     * so that only one sync can run at a time. The function returns a promise that resolves when this sync job is complete.
+     */
+    sync(options?: RefreshContentOptions): Promise<void>;
+    regenerateCollectionFileManifest(): Promise<void>;
+}
+export declare function simpleLoader<TData extends {
+    id: string;
+}>(handler: () => Array<TData> | Promise<Array<TData>>, context: LoaderContext): Promise<void>;
+/**
+ * Get the path to the data store file.
+ * During development, this is in the `.astro` directory so that the Vite watcher can see it.
+ * In production, it's in the cache directory so that it's preserved between builds.
+ */
+export declare function getDataStoreFile(settings: AstroSettings, isDev?: boolean): URL;
+export declare const globalContentLayer: {
+    init: (options: ContentLayerOptions) => ContentLayer;
+    get: () => ContentLayer | null;
+    dispose: () => void;
+};

node_modules/astro/dist/content/content-layer.js

@@ -0,0 +1,267 @@
+import { promises as fs, existsSync } from "node:fs";
+import PQueue from "p-queue";
+import xxhash from "xxhash-wasm";
+import { AstroUserError } from "../core/errors/errors.js";
+import {
+  ASSET_IMPORTS_FILE,
+  CONTENT_LAYER_TYPE,
+  DATA_STORE_FILE,
+  MODULES_IMPORTS_FILE
+} from "./consts.js";
+import {
+  getEntryConfigByExtMap,
+  getEntryDataAndImages,
+  globalContentConfigObserver
+} from "./utils.js";
+class ContentLayer {
+  #logger;
+  #store;
+  #settings;
+  #watcher;
+  #lastConfigDigest;
+  #unsubscribe;
+  #generateDigest;
+  #queue;
+  constructor({ settings, logger, store, watcher }) {
+    watcher?.setMaxListeners(50);
+    this.#logger = logger;
+    this.#store = store;
+    this.#settings = settings;
+    this.#watcher = watcher;
+    this.#queue = new PQueue({ concurrency: 1 });
+  }
+  /**
+   * Whether the content layer is currently loading content
+   */
+  get loading() {
+    return this.#queue.size > 0 || this.#queue.pending > 0;
+  }
+  /**
+   * Watch for changes to the content config and trigger a sync when it changes.
+   */
+  watchContentConfig() {
+    this.#unsubscribe?.();
+    this.#unsubscribe = globalContentConfigObserver.subscribe(async (ctx) => {
+      if (ctx.status === "loaded" && ctx.config.digest !== this.#lastConfigDigest) {
+        this.sync();
+      }
+    });
+  }
+  unwatchContentConfig() {
+    this.#unsubscribe?.();
+  }
+  async #getGenerateDigest() {
+    if (this.#generateDigest) {
+      return this.#generateDigest;
+    }
+    const { h64ToString } = await xxhash();
+    this.#generateDigest = (data) => {
+      const dataString = typeof data === "string" ? data : JSON.stringify(data);
+      return h64ToString(dataString);
+    };
+    return this.#generateDigest;
+  }
+  async #getLoaderContext({
+    collectionName,
+    loaderName = "content",
+    parseData,
+    refreshContextData
+  }) {
+    return {
+      collection: collectionName,
+      store: this.#store.scopedStore(collectionName),
+      meta: this.#store.metaStore(collectionName),
+      logger: this.#logger.forkIntegrationLogger(loaderName),
+      config: this.#settings.config,
+      parseData,
+      generateDigest: await this.#getGenerateDigest(),
+      watcher: this.#watcher,
+      refreshContextData,
+      entryTypes: getEntryConfigByExtMap([
+        ...this.#settings.contentEntryTypes,
+        ...this.#settings.dataEntryTypes
+      ])
+    };
+  }
+  /**
+   * Enqueues a sync job that runs the `load()` method of each collection's loader, which will load the data and save it in the data store.
+   * The loader itself is responsible for deciding whether this will clear and reload the full collection, or
+   * perform an incremental update. After the data is loaded, the data store is written to disk. Jobs are queued,
+   * so that only one sync can run at a time. The function returns a promise that resolves when this sync job is complete.
+   */
+  sync(options = {}) {
+    return this.#queue.add(() => this.#doSync(options));
+  }
+  async #doSync(options) {
+    const contentConfig = globalContentConfigObserver.get();
+    const logger = this.#logger.forkIntegrationLogger("content");
+    if (contentConfig?.status !== "loaded") {
+      logger.debug("Content config not loaded, skipping sync");
+      return;
+    }
+    if (!this.#settings.config.experimental.contentLayer) {
+      const contentLayerCollections = Object.entries(contentConfig.config.collections).filter(
+        ([_, collection]) => collection.type === CONTENT_LAYER_TYPE
+      );
+      if (contentLayerCollections.length > 0) {
+        throw new AstroUserError(
+          `The following collections have a loader defined, but the content layer is not enabled: ${contentLayerCollections.map(([title]) => title).join(", ")}.`,
+          "To enable the Content Layer API, set `experimental: { contentLayer: true }` in your Astro config file."
+        );
+      }
+      return;
+    }
+    logger.info("Syncing content");
+    const { digest: currentConfigDigest } = contentConfig.config;
+    this.#lastConfigDigest = currentConfigDigest;
+    let shouldClear = false;
+    const previousConfigDigest = await this.#store.metaStore().get("config-digest");
+    const previousAstroVersion = await this.#store.metaStore().get("astro-version");
+    if (currentConfigDigest && previousConfigDigest !== currentConfigDigest) {
+      logger.info("Content config changed");
+      shouldClear = true;
+    }
+    if (previousAstroVersion !== "4.16.18") {
+      logger.info("Astro version changed");
+      shouldClear = true;
+    }
+    if (shouldClear) {
+      logger.info("Clearing content store");
+      this.#store.clearAll();
+    }
+    if ("4.16.18") {
+      await this.#store.metaStore().set("astro-version", "4.16.18");
+    }
+    if (currentConfigDigest) {
+      await this.#store.metaStore().set("config-digest", currentConfigDigest);
+    }
+    await Promise.all(
+      Object.entries(contentConfig.config.collections).map(async ([name, collection]) => {
+        if (collection.type !== CONTENT_LAYER_TYPE) {
+          return;
+        }
+        let { schema } = collection;
+        if (!schema && typeof collection.loader === "object") {
+          schema = collection.loader.schema;
+          if (typeof schema === "function") {
+            schema = await schema();
+          }
+        }
+        if (options?.loaders && (typeof collection.loader !== "object" || !options.loaders.includes(collection.loader.name))) {
+          return;
+        }
+        const collectionWithResolvedSchema = { ...collection, schema };
+        const parseData = async ({ id, data, filePath = "" }) => {
+          const { data: parsedData } = await getEntryDataAndImages(
+            {
+              id,
+              collection: name,
+              unvalidatedData: data,
+              _internal: {
+                rawData: void 0,
+                filePath
+              }
+            },
+            collectionWithResolvedSchema,
+            false
+          );
+          return parsedData;
+        };
+        const context = await this.#getLoaderContext({
+          collectionName: name,
+          parseData,
+          loaderName: collection.loader.name,
+          refreshContextData: options?.context
+        });
+        if (typeof collection.loader === "function") {
+          return simpleLoader(collection.loader, context);
+        }
+        if (!collection.loader.load) {
+          throw new Error(`Collection loader for ${name} does not have a load method`);
+        }
+        return collection.loader.load(context);
+      })
+    );
+    if (!existsSync(this.#settings.config.cacheDir)) {
+      await fs.mkdir(this.#settings.config.cacheDir, { recursive: true });
+    }
+    const cacheFile = getDataStoreFile(this.#settings);
+    await this.#store.writeToDisk(cacheFile);
+    if (!existsSync(this.#settings.dotAstroDir)) {
+      await fs.mkdir(this.#settings.dotAstroDir, { recursive: true });
+    }
+    const assetImportsFile = new URL(ASSET_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeAssetImports(assetImportsFile);
+    const modulesImportsFile = new URL(MODULES_IMPORTS_FILE, this.#settings.dotAstroDir);
+    await this.#store.writeModuleImports(modulesImportsFile);
+    logger.info("Synced content");
+    if (this.#settings.config.experimental.contentIntellisense) {
+      await this.regenerateCollectionFileManifest();
+    }
+  }
+  async regenerateCollectionFileManifest() {
+    const collectionsManifest = new URL("collections/collections.json", this.#settings.dotAstroDir);
+    this.#logger.debug("content", "Regenerating collection file manifest");
+    if (existsSync(collectionsManifest)) {
+      try {
+        const collections = await fs.readFile(collectionsManifest, "utf-8");
+        const collectionsJson = JSON.parse(collections);
+        collectionsJson.entries ??= {};
+        for (const { hasSchema, name } of collectionsJson.collections) {
+          if (!hasSchema) {
+            continue;
+          }
+          const entries = this.#store.values(name);
+          if (!entries?.[0]?.filePath) {
+            continue;
+          }
+          for (const { filePath } of entries) {
+            if (!filePath) {
+              continue;
+            }
+            const key = new URL(filePath, this.#settings.config.root).href.toLowerCase();
+            collectionsJson.entries[key] = name;
+          }
+        }
+        await fs.writeFile(collectionsManifest, JSON.stringify(collectionsJson, null, 2));
+      } catch {
+        this.#logger.error("content", "Failed to regenerate collection file manifest");
+      }
+    }
+    this.#logger.debug("content", "Regenerated collection file manifest");
+  }
+}
+async function simpleLoader(handler, context) {
+  const data = await handler();
+  context.store.clear();
+  for (const raw of data) {
+    const item = await context.parseData({ id: raw.id, data: raw });
+    context.store.set({ id: raw.id, data: item });
+  }
+}
+function getDataStoreFile(settings, isDev) {
+  isDev ??= process?.env.NODE_ENV === "development";
+  return new URL(DATA_STORE_FILE, isDev ? settings.dotAstroDir : settings.config.cacheDir);
+}
+function contentLayerSingleton() {
+  let instance = null;
+  return {
+    init: (options) => {
+      instance?.unwatchContentConfig();
+      instance = new ContentLayer(options);
+      return instance;
+    },
+    get: () => instance,
+    dispose: () => {
+      instance?.unwatchContentConfig();
+      instance = null;
+    }
+  };
+}
+const globalContentLayer = contentLayerSingleton();
+export {
+  ContentLayer,
+  getDataStoreFile,
+  globalContentLayer,
+  simpleLoader
+};

node_modules/astro/dist/content/data-store.d.ts

@@ -0,0 +1,55 @@
+import type { MarkdownHeading } from '@astrojs/markdown-remark';
+export interface RenderedContent {
+    /** Rendered HTML string. If present then `render(entry)` will return a component that renders this HTML. */
+    html: string;
+    metadata?: {
+        /** Any images that are present in this entry. Relative to the {@link DataEntry} filePath. */
+        imagePaths?: Array<string>;
+        /** Any headings that are present in this file. */
+        headings?: MarkdownHeading[];
+        /** Raw frontmatter, parsed parsed from the file. This may include data from remark plugins. */
+        frontmatter?: Record<string, any>;
+        /** Any other metadata that is present in this file. */
+        [key: string]: unknown;
+    };
+}
+export interface DataEntry<TData extends Record<string, unknown> = Record<string, unknown>> {
+    /** The ID of the entry. Unique per collection. */
+    id: string;
+    /** The parsed entry data */
+    data: TData;
+    /** The file path of the content, if applicable. Relative to the site root. */
+    filePath?: string;
+    /** The raw body of the content, if applicable. */
+    body?: string;
+    /** An optional content digest, to check if the content has changed. */
+    digest?: number | string;
+    /** The rendered content of the entry, if applicable. */
+    rendered?: RenderedContent;
+    /**
+     * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase when calling `renderEntry`.
+     */
+    deferredRender?: boolean;
+    assetImports?: Array<string>;
+}
+/**
+ * A read-only data store for content collections. This is used to retrieve data from the content layer at runtime.
+ * To add or modify data, use {@link MutableDataStore} instead.
+ */
+export declare class DataStore {
+    protected _collections: Map<string, Map<string, any>>;
+    constructor();
+    get<T = DataEntry>(collectionName: string, key: string): T | undefined;
+    entries<T = DataEntry>(collectionName: string): Array<[id: string, T]>;
+    values<T = DataEntry>(collectionName: string): Array<T>;
+    keys(collectionName: string): Array<string>;
+    has(collectionName: string, key: string): boolean;
+    hasCollection(collectionName: string): boolean;
+    collections(): Map<string, Map<string, any>>;
+    /**
+     * Attempts to load a DataStore from the virtual module.
+     * This only works in Vite.
+     */
+    static fromModule(): Promise<DataStore>;
+    static fromMap(data: Map<string, Map<string, any>>): Promise<DataStore>;
+}

node_modules/astro/dist/content/data-store.js

@@ -0,0 +1,75 @@
+import * as devalue from "devalue";
+class DataStore {
+  _collections = /* @__PURE__ */ new Map();
+  constructor() {
+    this._collections = /* @__PURE__ */ new Map();
+  }
+  get(collectionName, key) {
+    return this._collections.get(collectionName)?.get(String(key));
+  }
+  entries(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.entries()];
+  }
+  values(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.values()];
+  }
+  keys(collectionName) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    return [...collection.keys()];
+  }
+  has(collectionName, key) {
+    const collection = this._collections.get(collectionName);
+    if (collection) {
+      return collection.has(String(key));
+    }
+    return false;
+  }
+  hasCollection(collectionName) {
+    return this._collections.has(collectionName);
+  }
+  collections() {
+    return this._collections;
+  }
+  /**
+   * Attempts to load a DataStore from the virtual module.
+   * This only works in Vite.
+   */
+  static async fromModule() {
+    try {
+      const data = await import("astro:data-layer-content");
+      if (data.default instanceof Map) {
+        return DataStore.fromMap(data.default);
+      }
+      const map = devalue.unflatten(data.default);
+      return DataStore.fromMap(map);
+    } catch {
+    }
+    return new DataStore();
+  }
+  static async fromMap(data) {
+    const store = new DataStore();
+    store._collections = data;
+    return store;
+  }
+}
+function dataStoreSingleton() {
+  let instance = void 0;
+  return {
+    get: async () => {
+      if (!instance) {
+        instance = DataStore.fromModule();
+      }
+      return instance;
+    },
+    set: (store) => {
+      instance = store;
+    }
+  };
+}
+const globalDataStore = dataStoreSingleton();
+export {
+  DataStore,
+  globalDataStore
+};

node_modules/astro/dist/content/index.d.ts

@@ -0,0 +1,7 @@
+export { CONTENT_FLAG, PROPAGATED_ASSET_FLAG } from './consts.js';
+export { attachContentServerListeners } from './server-listeners.js';
+export { createContentTypesGenerator } from './types-generator.js';
+export { contentObservable, getContentPaths, hasAssetPropagationFlag } from './utils.js';
+export { astroContentAssetPropagationPlugin } from './vite-plugin-content-assets.js';
+export { astroContentImportPlugin } from './vite-plugin-content-imports.js';
+export { astroContentVirtualModPlugin } from './vite-plugin-content-virtual-mod.js';

node_modules/astro/dist/content/index.js

@@ -0,0 +1,19 @@
+import { CONTENT_FLAG, PROPAGATED_ASSET_FLAG } from "./consts.js";
+import { attachContentServerListeners } from "./server-listeners.js";
+import { createContentTypesGenerator } from "./types-generator.js";
+import { contentObservable, getContentPaths, hasAssetPropagationFlag } from "./utils.js";
+import { astroContentAssetPropagationPlugin } from "./vite-plugin-content-assets.js";
+import { astroContentImportPlugin } from "./vite-plugin-content-imports.js";
+import { astroContentVirtualModPlugin } from "./vite-plugin-content-virtual-mod.js";
+export {
+  CONTENT_FLAG,
+  PROPAGATED_ASSET_FLAG,
+  astroContentAssetPropagationPlugin,
+  astroContentImportPlugin,
+  astroContentVirtualModPlugin,
+  attachContentServerListeners,
+  contentObservable,
+  createContentTypesGenerator,
+  getContentPaths,
+  hasAssetPropagationFlag
+};

node_modules/astro/dist/content/loaders/file.d.ts

@@ -0,0 +1,7 @@
+import type { Loader } from './types.js';
+/**
+ * Loads entries from a JSON file. The file must contain an array of objects that contain unique `id` fields, or an object with string keys.
+ * @todo Add support for other file types, such as YAML, CSV etc.
+ * @param fileName The path to the JSON file to load, relative to the content directory.
+ */
+export declare function file(fileName: string): Loader;

node_modules/astro/dist/content/loaders/file.js

@@ -0,0 +1,69 @@
+import { promises as fs, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { posixRelative } from "../utils.js";
+function file(fileName) {
+  if (fileName.includes("*")) {
+    throw new Error("Glob patterns are not supported in `file` loader. Use `glob` loader instead.");
+  }
+  async function syncData(filePath, { logger, parseData, store, config }) {
+    let json;
+    try {
+      const data = await fs.readFile(filePath, "utf-8");
+      json = JSON.parse(data);
+    } catch (error) {
+      logger.error(`Error reading data from ${fileName}`);
+      logger.debug(error.message);
+      return;
+    }
+    const normalizedFilePath = posixRelative(fileURLToPath(config.root), filePath);
+    if (Array.isArray(json)) {
+      if (json.length === 0) {
+        logger.warn(`No items found in ${fileName}`);
+      }
+      logger.debug(`Found ${json.length} item array in ${fileName}`);
+      store.clear();
+      for (const rawItem of json) {
+        const id = (rawItem.id ?? rawItem.slug)?.toString();
+        if (!id) {
+          logger.error(`Item in ${fileName} is missing an id or slug field.`);
+          continue;
+        }
+        const data = await parseData({ id, data: rawItem, filePath });
+        store.set({ id, data, filePath: normalizedFilePath });
+      }
+    } else if (typeof json === "object") {
+      const entries = Object.entries(json);
+      logger.debug(`Found object with ${entries.length} entries in ${fileName}`);
+      store.clear();
+      for (const [id, rawItem] of entries) {
+        const data = await parseData({ id, data: rawItem, filePath });
+        store.set({ id, data, filePath: normalizedFilePath });
+      }
+    } else {
+      logger.error(`Invalid data in ${fileName}. Must be an array or object.`);
+    }
+  }
+  return {
+    name: "file-loader",
+    load: async (context) => {
+      const { config, logger, watcher } = context;
+      logger.debug(`Loading data from ${fileName}`);
+      const url = new URL(fileName, config.root);
+      if (!existsSync(url)) {
+        logger.error(`File not found: ${fileName}`);
+        return;
+      }
+      const filePath = fileURLToPath(url);
+      await syncData(filePath, context);
+      watcher?.on("change", async (changedPath) => {
+        if (changedPath === filePath) {
+          logger.info(`Reloading data from ${fileName}`);
+          await syncData(filePath, context);
+        }
+      });
+    }
+  };
+}
+export {
+  file
+};

node_modules/astro/dist/content/loaders/glob.d.ts

@@ -0,0 +1,25 @@
+import type { Loader } from './types.js';
+export interface GenerateIdOptions {
+    /** The path to the entry file, relative to the base directory. */
+    entry: string;
+    /** The base directory URL. */
+    base: URL;
+    /** The parsed, unvalidated data of the entry. */
+    data: Record<string, unknown>;
+}
+export interface GlobOptions {
+    /** The glob pattern to match files, relative to the base directory */
+    pattern: string;
+    /** The base directory to resolve the glob pattern from. Relative to the root directory, or an absolute file URL. Defaults to `.` */
+    base?: string | URL;
+    /**
+     * Function that generates an ID for an entry. Default implementation generates a slug from the entry path.
+     * @returns The ID of the entry. Must be unique per collection.
+     **/
+    generateId?: (options: GenerateIdOptions) => string;
+}
+/**
+ * Loads multiple entries, using a glob pattern to match files.
+ * @param pattern A glob pattern to match files, relative to the content directory.
+ */
+export declare function glob(globOptions: GlobOptions): Loader;

node_modules/astro/dist/content/loaders/glob.js

@@ -0,0 +1,209 @@
+import { promises as fs } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import fastGlob from "fast-glob";
+import { bold, green } from "kleur/colors";
+import micromatch from "micromatch";
+import pLimit from "p-limit";
+import { getContentEntryIdAndSlug, posixRelative } from "../utils.js";
+function generateIdDefault({ entry, base, data }) {
+  if (data.slug) {
+    return data.slug;
+  }
+  const entryURL = new URL(entry, base);
+  const { slug } = getContentEntryIdAndSlug({
+    entry: entryURL,
+    contentDir: base,
+    collection: ""
+  });
+  return slug;
+}
+function glob(globOptions) {
+  if (globOptions.pattern.startsWith("../")) {
+    throw new Error(
+      "Glob patterns cannot start with `../`. Set the `base` option to a parent directory instead."
+    );
+  }
+  if (globOptions.pattern.startsWith("/")) {
+    throw new Error(
+      "Glob patterns cannot start with `/`. Set the `base` option to a parent directory or use a relative path instead."
+    );
+  }
+  const generateId = globOptions?.generateId ?? generateIdDefault;
+  const fileToIdMap = /* @__PURE__ */ new Map();
+  return {
+    name: "glob-loader",
+    load: async ({ config, logger, watcher, parseData, store, generateDigest, entryTypes }) => {
+      const renderFunctionByContentType = /* @__PURE__ */ new WeakMap();
+      const untouchedEntries = new Set(store.keys());
+      async function syncData(entry, base, entryType) {
+        if (!entryType) {
+          logger.warn(`No entry type found for ${entry}`);
+          return;
+        }
+        const fileUrl = new URL(entry, base);
+        const contents = await fs.readFile(fileUrl, "utf-8").catch((err) => {
+          logger.error(`Error reading ${entry}: ${err.message}`);
+          return;
+        });
+        if (!contents) {
+          logger.warn(`No contents found for ${entry}`);
+          return;
+        }
+        const { body, data } = await entryType.getEntryInfo({
+          contents,
+          fileUrl
+        });
+        const id = generateId({ entry, base, data });
+        untouchedEntries.delete(id);
+        const existingEntry = store.get(id);
+        const digest = generateDigest(contents);
+        const filePath = fileURLToPath(fileUrl);
+        if (existingEntry && existingEntry.digest === digest && existingEntry.filePath) {
+          if (existingEntry.deferredRender) {
+            store.addModuleImport(existingEntry.filePath);
+          }
+          if (existingEntry.assetImports?.length) {
+            store.addAssetImports(existingEntry.assetImports, existingEntry.filePath);
+          }
+          fileToIdMap.set(filePath, id);
+          return;
+        }
+        const relativePath = posixRelative(fileURLToPath(config.root), filePath);
+        const parsedData = await parseData({
+          id,
+          data,
+          filePath
+        });
+        if (entryType.getRenderFunction) {
+          let render = renderFunctionByContentType.get(entryType);
+          if (!render) {
+            render = await entryType.getRenderFunction(config);
+            renderFunctionByContentType.set(entryType, render);
+          }
+          let rendered = void 0;
+          try {
+            rendered = await render?.({
+              id,
+              data: parsedData,
+              body,
+              filePath,
+              digest
+            });
+          } catch (error) {
+            logger.error(`Error rendering ${entry}: ${error.message}`);
+          }
+          store.set({
+            id,
+            data: parsedData,
+            body,
+            filePath: relativePath,
+            digest,
+            rendered,
+            assetImports: rendered?.metadata?.imagePaths
+          });
+        } else if ("contentModuleTypes" in entryType) {
+          store.set({
+            id,
+            data: parsedData,
+            body,
+            filePath: relativePath,
+            digest,
+            deferredRender: true
+          });
+        } else {
+          store.set({ id, data: parsedData, body, filePath: relativePath, digest });
+        }
+        fileToIdMap.set(filePath, id);
+      }
+      const baseDir = globOptions.base ? new URL(globOptions.base, config.root) : config.root;
+      if (!baseDir.pathname.endsWith("/")) {
+        baseDir.pathname = `${baseDir.pathname}/`;
+      }
+      const files = await fastGlob(globOptions.pattern, {
+        cwd: fileURLToPath(baseDir)
+      });
+      function configForFile(file) {
+        const ext = file.split(".").at(-1);
+        if (!ext) {
+          logger.warn(`No extension found for ${file}`);
+          return;
+        }
+        return entryTypes.get(`.${ext}`);
+      }
+      const limit = pLimit(10);
+      const skippedFiles = [];
+      const contentDir = new URL("content/", config.srcDir);
+      function isInContentDir(file) {
+        const fileUrl = new URL(file, baseDir);
+        return fileUrl.href.startsWith(contentDir.href);
+      }
+      const configFiles = new Set(
+        ["config.js", "config.ts", "config.mjs"].map((file) => new URL(file, contentDir).href)
+      );
+      function isConfigFile(file) {
+        const fileUrl = new URL(file, baseDir);
+        return configFiles.has(fileUrl.href);
+      }
+      await Promise.all(
+        files.map((entry) => {
+          if (isConfigFile(entry)) {
+            return;
+          }
+          if (isInContentDir(entry)) {
+            skippedFiles.push(entry);
+            return;
+          }
+          return limit(async () => {
+            const entryType = configForFile(entry);
+            await syncData(entry, baseDir, entryType);
+          });
+        })
+      );
+      const skipCount = skippedFiles.length;
+      if (skipCount > 0) {
+        logger.warn(`The glob() loader cannot be used for files in ${bold("src/content")}.`);
+        if (skipCount > 10) {
+          logger.warn(
+            `Skipped ${green(skippedFiles.length)} files that matched ${green(globOptions.pattern)}.`
+          );
+        } else {
+          logger.warn(`Skipped the following files that matched ${green(globOptions.pattern)}:`);
+          skippedFiles.forEach((file) => logger.warn(`\u2022 ${green(file)}`));
+        }
+      }
+      untouchedEntries.forEach((id) => store.delete(id));
+      if (!watcher) {
+        return;
+      }
+      const matcher = micromatch.makeRe(globOptions.pattern);
+      const matchesGlob = (entry) => !entry.startsWith("../") && matcher.test(entry);
+      const basePath = fileURLToPath(baseDir);
+      async function onChange(changedPath) {
+        const entry = posixRelative(basePath, changedPath);
+        if (!matchesGlob(entry)) {
+          return;
+        }
+        const entryType = configForFile(changedPath);
+        const baseUrl = pathToFileURL(basePath);
+        await syncData(entry, baseUrl, entryType);
+        logger.info(`Reloaded data from ${green(entry)}`);
+      }
+      watcher.on("change", onChange);
+      watcher.on("add", onChange);
+      watcher.on("unlink", async (deletedPath) => {
+        const entry = posixRelative(basePath, deletedPath);
+        if (!matchesGlob(entry)) {
+          return;
+        }
+        const id = fileToIdMap.get(deletedPath);
+        if (id) {
+          store.delete(id);
+          fileToIdMap.delete(deletedPath);
+        }
+      });
+    }
+  };
+}
+export {
+  glob
+};

node_modules/astro/dist/content/loaders/index.d.ts

@@ -0,0 +1,3 @@
+export { file } from './file.js';
+export { glob } from './glob.js';
+export * from './types.js';

node_modules/astro/dist/content/loaders/index.js

@@ -0,0 +1,7 @@
+import { file } from "./file.js";
+import { glob } from "./glob.js";
+export * from "./types.js";
+export {
+  file,
+  glob
+};

node_modules/astro/dist/content/loaders/types.d.ts

@@ -0,0 +1,39 @@
+import type { FSWatcher } from 'vite';
+import type { ZodSchema } from 'zod';
+import type { AstroConfig, AstroIntegrationLogger, ContentEntryType } from '../../@types/astro.js';
+import type { MetaStore, ScopedDataStore } from '../mutable-data-store.js';
+export interface ParseDataOptions<TData extends Record<string, unknown>> {
+    /** The ID of the entry. Unique per collection */
+    id: string;
+    /** The raw, unvalidated data of the entry */
+    data: TData;
+    /** An optional file path, where the entry represents a local file. */
+    filePath?: string;
+}
+export interface LoaderContext {
+    /** The unique name of the collection */
+    collection: string;
+    /** A database abstraction to store the actual data */
+    store: ScopedDataStore;
+    /**  A simple KV store, designed for things like sync tokens */
+    meta: MetaStore;
+    logger: AstroIntegrationLogger;
+    /** Astro config, with user config and merged defaults */
+    config: AstroConfig;
+    /** Validates and parses the data according to the collection schema */
+    parseData<TData extends Record<string, unknown>>(props: ParseDataOptions<TData>): Promise<TData>;
+    /** Generates a non-cryptographic content digest. This can be used to check if the data has changed */
+    generateDigest(data: Record<string, unknown> | string): string;
+    /** When running in dev, this is a filesystem watcher that can be used to trigger updates */
+    watcher?: FSWatcher;
+    refreshContextData?: Record<string, unknown>;
+    entryTypes: Map<string, ContentEntryType>;
+}
+export interface Loader {
+    /** Unique name of the loader, e.g. the npm package name */
+    name: string;
+    /** Do the actual loading of the data */
+    load: (context: LoaderContext) => Promise<void>;
+    /** Optionally, define the schema of the data. Will be overridden by user-defined schema */
+    schema?: ZodSchema | Promise<ZodSchema> | (() => ZodSchema | Promise<ZodSchema>);
+}

node_modules/astro/dist/content/mutable-data-store.d.ts

@@ -0,0 +1,77 @@
+import { type PathLike } from 'node:fs';
+import { type DataEntry, DataStore, type RenderedContent } from './data-store.js';
+/**
+ * Extends the DataStore with the ability to change entries and write them to disk.
+ * This is kept as a separate class to avoid needing node builtins at runtime, when read-only access is all that is needed.
+ */
+export declare class MutableDataStore extends DataStore {
+    #private;
+    set(collectionName: string, key: string, value: unknown): void;
+    delete(collectionName: string, key: string): void;
+    clear(collectionName: string): void;
+    clearAll(): void;
+    addAssetImport(assetImport: string, filePath?: string): void;
+    addAssetImports(assets: Array<string>, filePath?: string): void;
+    addModuleImport(fileName: string): void;
+    writeAssetImports(filePath: PathLike): Promise<void>;
+    writeModuleImports(filePath: PathLike): Promise<void>;
+    scopedStore(collectionName: string): ScopedDataStore;
+    /**
+     * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
+     */
+    metaStore(collectionName?: string): MetaStore;
+    toString(): string;
+    writeToDisk(filePath: PathLike): Promise<void>;
+    /**
+     * Attempts to load a MutableDataStore from the virtual module.
+     * This only works in Vite.
+     */
+    static fromModule(): Promise<MutableDataStore>;
+    static fromMap(data: Map<string, Map<string, any>>): Promise<MutableDataStore>;
+    static fromString(data: string): Promise<MutableDataStore>;
+    static fromFile(filePath: string | URL): Promise<MutableDataStore>;
+}
+export interface ScopedDataStore {
+    get: <TData extends Record<string, unknown> = Record<string, unknown>>(key: string) => DataEntry<TData> | undefined;
+    entries: () => Array<[id: string, DataEntry]>;
+    set: <TData extends Record<string, unknown>>(opts: {
+        /** The ID of the entry. Must be unique per collection. */
+        id: string;
+        /** The data to store. */
+        data: TData;
+        /** The raw body of the content, if applicable. */
+        body?: string;
+        /** The file path of the content, if applicable. Relative to the site root. */
+        filePath?: string;
+        /** A content digest, to check if the content has changed. */
+        digest?: number | string;
+        /** The rendered content, if applicable. */
+        rendered?: RenderedContent;
+        /**
+         * If an entry is a deferred, its rendering phase is delegated to a virtual module during the runtime phase.
+         */
+        deferredRender?: boolean;
+    }) => boolean;
+    values: () => Array<DataEntry>;
+    keys: () => Array<string>;
+    delete: (key: string) => void;
+    clear: () => void;
+    has: (key: string) => boolean;
+    /**
+     * Adds a single asset to the store. This asset will be transformed
+     * by Vite, and the URL will be available in the final build.
+     * @param fileName
+     * @param specifier
+     * @returns
+     */
+    addModuleImport: (fileName: string) => void;
+}
+/**
+ * A key-value store for metadata strings. Useful for storing things like sync tokens.
+ */
+export interface MetaStore {
+    get: (key: string) => string | undefined;
+    set: (key: string, value: string) => void;
+    has: (key: string) => boolean;
+    delete: (key: string) => void;
+}

node_modules/astro/dist/content/mutable-data-store.js

@@ -0,0 +1,282 @@
+import { promises as fs, existsSync } from "node:fs";
+import * as devalue from "devalue";
+import { Traverse } from "neotraverse/modern";
+import { imageSrcToImportId, importIdToSymbolName } from "../assets/utils/resolveImports.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { IMAGE_IMPORT_PREFIX } from "./consts.js";
+import { DataStore } from "./data-store.js";
+import { contentModuleToId } from "./utils.js";
+const SAVE_DEBOUNCE_MS = 500;
+class MutableDataStore extends DataStore {
+  #file;
+  #assetsFile;
+  #modulesFile;
+  #saveTimeout;
+  #assetsSaveTimeout;
+  #modulesSaveTimeout;
+  #dirty = false;
+  #assetsDirty = false;
+  #modulesDirty = false;
+  #assetImports = /* @__PURE__ */ new Set();
+  #moduleImports = /* @__PURE__ */ new Map();
+  set(collectionName, key, value) {
+    const collection = this._collections.get(collectionName) ?? /* @__PURE__ */ new Map();
+    collection.set(String(key), value);
+    this._collections.set(collectionName, collection);
+    this.#saveToDiskDebounced();
+  }
+  delete(collectionName, key) {
+    const collection = this._collections.get(collectionName);
+    if (collection) {
+      collection.delete(String(key));
+      this.#saveToDiskDebounced();
+    }
+  }
+  clear(collectionName) {
+    this._collections.delete(collectionName);
+    this.#saveToDiskDebounced();
+  }
+  clearAll() {
+    this._collections.clear();
+    this.#saveToDiskDebounced();
+  }
+  addAssetImport(assetImport, filePath) {
+    const id = imageSrcToImportId(assetImport, filePath);
+    if (id) {
+      this.#assetImports.add(id);
+      this.#writeAssetsImportsDebounced();
+    }
+  }
+  addAssetImports(assets, filePath) {
+    assets.forEach((asset) => this.addAssetImport(asset, filePath));
+  }
+  addModuleImport(fileName) {
+    const id = contentModuleToId(fileName);
+    if (id) {
+      this.#moduleImports.set(fileName, id);
+      this.#writeModulesImportsDebounced();
+    }
+  }
+  async writeAssetImports(filePath) {
+    this.#assetsFile = filePath;
+    if (this.#assetImports.size === 0) {
+      try {
+        await fs.writeFile(filePath, "export default new Map();");
+      } catch (err) {
+        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+      }
+    }
+    if (!this.#assetsDirty && existsSync(filePath)) {
+      return;
+    }
+    const imports = [];
+    const exports = [];
+    this.#assetImports.forEach((id) => {
+      const symbol = importIdToSymbolName(id);
+      imports.push(`import ${symbol} from '${id}';`);
+      exports.push(`[${JSON.stringify(id)}, ${symbol}]`);
+    });
+    const code = (
+      /* js */
+      `
+${imports.join("\n")}
+export default new Map([${exports.join(", ")}]);
+		`
+    );
+    try {
+      await fs.writeFile(filePath, code);
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+    this.#assetsDirty = false;
+  }
+  async writeModuleImports(filePath) {
+    this.#modulesFile = filePath;
+    if (this.#moduleImports.size === 0) {
+      try {
+        await fs.writeFile(filePath, "export default new Map();");
+      } catch (err) {
+        throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+      }
+    }
+    if (!this.#modulesDirty && existsSync(filePath)) {
+      return;
+    }
+    const lines = [];
+    for (const [fileName, specifier] of this.#moduleImports) {
+      lines.push(`['${fileName}', () => import('${specifier}')]`);
+    }
+    const code = `
+export default new Map([
+${lines.join(",\n")}]);
+		`;
+    try {
+      await fs.writeFile(filePath, code);
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+    this.#modulesDirty = false;
+  }
+  #writeAssetsImportsDebounced() {
+    this.#assetsDirty = true;
+    if (this.#assetsFile) {
+      if (this.#assetsSaveTimeout) {
+        clearTimeout(this.#assetsSaveTimeout);
+      }
+      this.#assetsSaveTimeout = setTimeout(() => {
+        this.#assetsSaveTimeout = void 0;
+        this.writeAssetImports(this.#assetsFile);
+      }, SAVE_DEBOUNCE_MS);
+    }
+  }
+  #writeModulesImportsDebounced() {
+    this.#modulesDirty = true;
+    if (this.#modulesFile) {
+      if (this.#modulesSaveTimeout) {
+        clearTimeout(this.#modulesSaveTimeout);
+      }
+      this.#modulesSaveTimeout = setTimeout(() => {
+        this.#modulesSaveTimeout = void 0;
+        this.writeModuleImports(this.#modulesFile);
+      }, SAVE_DEBOUNCE_MS);
+    }
+  }
+  #saveToDiskDebounced() {
+    this.#dirty = true;
+    if (this.#file) {
+      if (this.#saveTimeout) {
+        clearTimeout(this.#saveTimeout);
+      }
+      this.#saveTimeout = setTimeout(() => {
+        this.#saveTimeout = void 0;
+        this.writeToDisk(this.#file);
+      }, SAVE_DEBOUNCE_MS);
+    }
+  }
+  scopedStore(collectionName) {
+    return {
+      get: (key) => this.get(collectionName, key),
+      entries: () => this.entries(collectionName),
+      values: () => this.values(collectionName),
+      keys: () => this.keys(collectionName),
+      set: ({ id: key, data, body, filePath, deferredRender, digest, rendered, assetImports }) => {
+        if (!key) {
+          throw new Error(`ID must be a non-empty string`);
+        }
+        const id = String(key);
+        if (digest) {
+          const existing = this.get(collectionName, id);
+          if (existing && existing.digest === digest) {
+            return false;
+          }
+        }
+        const foundAssets = new Set(assetImports);
+        new Traverse(data).forEach((_, val) => {
+          if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
+            const src = val.replace(IMAGE_IMPORT_PREFIX, "");
+            foundAssets.add(src);
+          }
+        });
+        const entry = {
+          id,
+          data
+        };
+        if (body) {
+          entry.body = body;
+        }
+        if (filePath) {
+          if (filePath.startsWith("/")) {
+            throw new Error(`File path must be relative to the site root. Got: ${filePath}`);
+          }
+          entry.filePath = filePath;
+        }
+        if (foundAssets.size) {
+          entry.assetImports = Array.from(foundAssets);
+          this.addAssetImports(entry.assetImports, filePath);
+        }
+        if (digest) {
+          entry.digest = digest;
+        }
+        if (rendered) {
+          entry.rendered = rendered;
+        }
+        if (deferredRender) {
+          entry.deferredRender = deferredRender;
+          if (filePath) {
+            this.addModuleImport(filePath);
+          }
+        }
+        this.set(collectionName, id, entry);
+        return true;
+      },
+      delete: (key) => this.delete(collectionName, key),
+      clear: () => this.clear(collectionName),
+      has: (key) => this.has(collectionName, key),
+      addAssetImport: (assetImport, fileName) => this.addAssetImport(assetImport, fileName),
+      addAssetImports: (assets, fileName) => this.addAssetImports(assets, fileName),
+      addModuleImport: (fileName) => this.addModuleImport(fileName)
+    };
+  }
+  /**
+   * Returns a MetaStore for a given collection, or if no collection is provided, the default meta collection.
+   */
+  metaStore(collectionName = ":meta") {
+    const collectionKey = `meta:${collectionName}`;
+    return {
+      get: (key) => this.get(collectionKey, key),
+      set: (key, data) => this.set(collectionKey, key, data),
+      delete: (key) => this.delete(collectionKey, key),
+      has: (key) => this.has(collectionKey, key)
+    };
+  }
+  toString() {
+    return devalue.stringify(this._collections);
+  }
+  async writeToDisk(filePath) {
+    if (!this.#dirty) {
+      return;
+    }
+    try {
+      await fs.writeFile(filePath, this.toString());
+      this.#file = filePath;
+      this.#dirty = false;
+    } catch (err) {
+      throw new AstroError(AstroErrorData.UnknownFilesystemError, { cause: err });
+    }
+  }
+  /**
+   * Attempts to load a MutableDataStore from the virtual module.
+   * This only works in Vite.
+   */
+  static async fromModule() {
+    try {
+      const data = await import("astro:data-layer-content");
+      const map = devalue.unflatten(data.default);
+      return MutableDataStore.fromMap(map);
+    } catch {
+    }
+    return new MutableDataStore();
+  }
+  static async fromMap(data) {
+    const store = new MutableDataStore();
+    store._collections = data;
+    return store;
+  }
+  static async fromString(data) {
+    const map = devalue.parse(data);
+    return MutableDataStore.fromMap(map);
+  }
+  static async fromFile(filePath) {
+    try {
+      if (existsSync(filePath)) {
+        const data = await fs.readFile(filePath, "utf-8");
+        return MutableDataStore.fromString(data);
+      }
+    } catch {
+    }
+    return new MutableDataStore();
+  }
+}
+export {
+  MutableDataStore
+};

node_modules/astro/dist/content/runtime-assets.d.ts

@@ -0,0 +1,11 @@
+import type { PluginContext } from 'rollup';
+import { z } from 'zod';
+export declare function createImage(pluginContext: PluginContext, shouldEmitFile: boolean, entryFilePath: string): () => z.ZodEffects<z.ZodString, z.ZodNever | {
+    ASTRO_ASSET: string;
+    width: number;
+    height: number;
+    format: import("../assets/types.js").ImageInputFormat;
+    src: string;
+    fsPath: string;
+    orientation?: number | undefined;
+}, string>;

node_modules/astro/dist/content/runtime-assets.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { emitESMImage } from "../assets/utils/node/emitAsset.js";
+function createImage(pluginContext, shouldEmitFile, entryFilePath) {
+  return () => {
+    return z.string().transform(async (imagePath, ctx) => {
+      const resolvedFilePath = (await pluginContext.resolve(imagePath, entryFilePath))?.id;
+      const metadata = await emitESMImage(
+        resolvedFilePath,
+        pluginContext.meta.watchMode,
+        shouldEmitFile ? pluginContext.emitFile : void 0
+      );
+      if (!metadata) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Image ${imagePath} does not exist. Is the path correct?`,
+          fatal: true
+        });
+        return z.never();
+      }
+      return { ...metadata, ASTRO_ASSET: metadata.fsPath };
+    });
+  };
+}
+export {
+  createImage
+};

node_modules/astro/dist/content/runtime.d.ts

@@ -0,0 +1,118 @@
+import type { MarkdownHeading } from '@astrojs/markdown-remark';
+import { z } from 'zod';
+import { type AstroComponentFactory } from '../runtime/server/index.js';
+import { type DataEntry } from './data-store.js';
+import type { ContentLookupMap } from './utils.js';
+type LazyImport = () => Promise<any>;
+type GlobResult = Record<string, LazyImport>;
+type CollectionToEntryMap = Record<string, GlobResult>;
+type GetEntryImport = (collection: string, lookupId: string) => Promise<LazyImport>;
+export declare function defineCollection(config: any): any;
+export declare function createCollectionToGlobResultMap({ globResult, contentDir, }: {
+    globResult: GlobResult;
+    contentDir: string;
+}): CollectionToEntryMap;
+export declare function createGetCollection({ contentCollectionToEntryMap, dataCollectionToEntryMap, getRenderEntryImport, cacheEntriesByCollection, }: {
+    contentCollectionToEntryMap: CollectionToEntryMap;
+    dataCollectionToEntryMap: CollectionToEntryMap;
+    getRenderEntryImport: GetEntryImport;
+    cacheEntriesByCollection: Map<string, any[]>;
+}): (collection: string, filter?: (entry: any) => unknown) => Promise<any[]>;
+export declare function createGetEntryBySlug({ getEntryImport, getRenderEntryImport, collectionNames, }: {
+    getEntryImport: GetEntryImport;
+    getRenderEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
+}): (collection: string, slug: string) => Promise<{
+    id: any;
+    slug: any;
+    body: any;
+    collection: any;
+    data: any;
+    render(): Promise<RenderResult>;
+} | undefined>;
+export declare function createGetDataEntryById({ getEntryImport, collectionNames, }: {
+    getEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
+}): (collection: string, id: string) => Promise<{
+    id: any;
+    collection: any;
+    data: any;
+} | undefined>;
+type ContentEntryResult = {
+    id: string;
+    slug: string;
+    body: string;
+    collection: string;
+    data: Record<string, any>;
+    render(): Promise<RenderResult>;
+};
+type DataEntryResult = {
+    id: string;
+    collection: string;
+    data: Record<string, any>;
+};
+type EntryLookupObject = {
+    collection: string;
+    id: string;
+} | {
+    collection: string;
+    slug: string;
+};
+export declare function createGetEntry({ getEntryImport, getRenderEntryImport, collectionNames, }: {
+    getEntryImport: GetEntryImport;
+    getRenderEntryImport: GetEntryImport;
+    collectionNames: Set<string>;
+}): (collectionOrLookupObject: string | EntryLookupObject, _lookupId?: string) => Promise<ContentEntryResult | DataEntryResult | undefined>;
+export declare function createGetEntries(getEntry: ReturnType<typeof createGetEntry>): (entries: {
+    collection: string;
+    id: string;
+}[] | {
+    collection: string;
+    slug: string;
+}[]) => Promise<(ContentEntryResult | DataEntryResult | undefined)[]>;
+type RenderResult = {
+    Content: AstroComponentFactory;
+    headings: MarkdownHeading[];
+    remarkPluginFrontmatter: Record<string, any>;
+};
+export declare function renderEntry(entry: DataEntry | {
+    render: () => Promise<{
+        Content: AstroComponentFactory;
+    }>;
+}): Promise<{
+    Content: AstroComponentFactory;
+}>;
+export declare function createReference({ lookupMap }: {
+    lookupMap: ContentLookupMap;
+}): (collection: string) => z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+    collection: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    collection: string;
+}, {
+    id: string;
+    collection: string;
+}>, z.ZodObject<{
+    slug: z.ZodString;
+    collection: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    collection: string;
+    slug: string;
+}, {
+    collection: string;
+    slug: string;
+}>]>, {
+    id: string;
+    collection: string;
+} | {
+    slug: string;
+    collection: string;
+} | undefined, string | {
+    id: string;
+    collection: string;
+} | {
+    collection: string;
+    slug: string;
+}>;
+export {};

node_modules/astro/dist/content/runtime.js

@@ -0,0 +1,485 @@
+import { Traverse } from "neotraverse/modern";
+import pLimit from "p-limit";
+import { ZodIssueCode, z } from "zod";
+import { imageSrcToImportId } from "../assets/utils/resolveImports.js";
+import { AstroError, AstroErrorData, AstroUserError } from "../core/errors/index.js";
+import { prependForwardSlash } from "../core/path.js";
+import {
+  createComponent,
+  createHeadAndContent,
+  renderComponent,
+  renderScriptElement,
+  renderTemplate,
+  renderUniqueStylesheet,
+  render as serverRender,
+  unescapeHTML
+} from "../runtime/server/index.js";
+import { CONTENT_LAYER_TYPE, IMAGE_IMPORT_PREFIX } from "./consts.js";
+import { globalDataStore } from "./data-store.js";
+function defineCollection(config) {
+  if ("loader" in config) {
+    if (config.type && config.type !== CONTENT_LAYER_TYPE) {
+      throw new AstroUserError(
+        "Collections that use the Content Layer API must have a `loader` defined and no `type` set.",
+        "Check your collection definitions in `src/content/config.*`.'"
+      );
+    }
+    config.type = CONTENT_LAYER_TYPE;
+  }
+  if (!config.type) config.type = "content";
+  return config;
+}
+function createCollectionToGlobResultMap({
+  globResult,
+  contentDir
+}) {
+  const collectionToGlobResultMap = {};
+  for (const key in globResult) {
+    const keyRelativeToContentDir = key.replace(new RegExp(`^${contentDir}`), "");
+    const segments = keyRelativeToContentDir.split("/");
+    if (segments.length <= 1) continue;
+    const collection = segments[0];
+    collectionToGlobResultMap[collection] ??= {};
+    collectionToGlobResultMap[collection][key] = globResult[key];
+  }
+  return collectionToGlobResultMap;
+}
+function createGetCollection({
+  contentCollectionToEntryMap,
+  dataCollectionToEntryMap,
+  getRenderEntryImport,
+  cacheEntriesByCollection
+}) {
+  return async function getCollection(collection, filter) {
+    const hasFilter = typeof filter === "function";
+    const store = await globalDataStore.get();
+    let type;
+    if (collection in contentCollectionToEntryMap) {
+      type = "content";
+    } else if (collection in dataCollectionToEntryMap) {
+      type = "data";
+    } else if (store.hasCollection(collection)) {
+      const { default: imageAssetMap } = await import("astro:asset-imports");
+      const result = [];
+      for (const rawEntry of store.values(collection)) {
+        const data = updateImageReferencesInData(rawEntry.data, rawEntry.filePath, imageAssetMap);
+        const entry = {
+          ...rawEntry,
+          data,
+          collection
+        };
+        if (hasFilter && !filter(entry)) {
+          continue;
+        }
+        result.push(entry);
+      }
+      return result;
+    } else {
+      console.warn(
+        `The collection ${JSON.stringify(
+          collection
+        )} does not exist or is empty. Ensure a collection directory with this name exists.`
+      );
+      return [];
+    }
+    const lazyImports = Object.values(
+      type === "content" ? contentCollectionToEntryMap[collection] : dataCollectionToEntryMap[collection]
+    );
+    let entries = [];
+    if (!import.meta.env?.DEV && cacheEntriesByCollection.has(collection)) {
+      entries = cacheEntriesByCollection.get(collection);
+    } else {
+      const limit = pLimit(10);
+      entries = await Promise.all(
+        lazyImports.map(
+          (lazyImport) => limit(async () => {
+            const entry = await lazyImport();
+            return type === "content" ? {
+              id: entry.id,
+              slug: entry.slug,
+              body: entry.body,
+              collection: entry.collection,
+              data: entry.data,
+              async render() {
+                return render({
+                  collection: entry.collection,
+                  id: entry.id,
+                  renderEntryImport: await getRenderEntryImport(collection, entry.slug)
+                });
+              }
+            } : {
+              id: entry.id,
+              collection: entry.collection,
+              data: entry.data
+            };
+          })
+        )
+      );
+      cacheEntriesByCollection.set(collection, entries);
+    }
+    if (hasFilter) {
+      return entries.filter(filter);
+    } else {
+      return entries.slice();
+    }
+  };
+}
+function createGetEntryBySlug({
+  getEntryImport,
+  getRenderEntryImport,
+  collectionNames
+}) {
+  return async function getEntryBySlug(collection, slug) {
+    const store = await globalDataStore.get();
+    if (!collectionNames.has(collection)) {
+      if (store.hasCollection(collection)) {
+        throw new AstroError({
+          ...AstroErrorData.GetEntryDeprecationError,
+          message: AstroErrorData.GetEntryDeprecationError.message(collection, "getEntryBySlug")
+        });
+      }
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
+    const entryImport = await getEntryImport(collection, slug);
+    if (typeof entryImport !== "function") return void 0;
+    const entry = await entryImport();
+    return {
+      id: entry.id,
+      slug: entry.slug,
+      body: entry.body,
+      collection: entry.collection,
+      data: entry.data,
+      async render() {
+        return render({
+          collection: entry.collection,
+          id: entry.id,
+          renderEntryImport: await getRenderEntryImport(collection, slug)
+        });
+      }
+    };
+  };
+}
+function createGetDataEntryById({
+  getEntryImport,
+  collectionNames
+}) {
+  return async function getDataEntryById(collection, id) {
+    const store = await globalDataStore.get();
+    if (!collectionNames.has(collection)) {
+      if (store.hasCollection(collection)) {
+        throw new AstroError({
+          ...AstroErrorData.GetEntryDeprecationError,
+          message: AstroErrorData.GetEntryDeprecationError.message(collection, "getDataEntryById")
+        });
+      }
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
+    const lazyImport = await getEntryImport(collection, id);
+    if (!lazyImport) throw new Error(`Entry ${collection} \u2192 ${id} was not found.`);
+    const entry = await lazyImport();
+    return {
+      id: entry.id,
+      collection: entry.collection,
+      data: entry.data
+    };
+  };
+}
+function createGetEntry({
+  getEntryImport,
+  getRenderEntryImport,
+  collectionNames
+}) {
+  return async function getEntry(collectionOrLookupObject, _lookupId) {
+    let collection, lookupId;
+    if (typeof collectionOrLookupObject === "string") {
+      collection = collectionOrLookupObject;
+      if (!_lookupId)
+        throw new AstroError({
+          ...AstroErrorData.UnknownContentCollectionError,
+          message: "`getEntry()` requires an entry identifier as the second argument."
+        });
+      lookupId = _lookupId;
+    } else {
+      collection = collectionOrLookupObject.collection;
+      lookupId = "id" in collectionOrLookupObject ? collectionOrLookupObject.id : collectionOrLookupObject.slug;
+    }
+    const store = await globalDataStore.get();
+    if (store.hasCollection(collection)) {
+      const entry2 = store.get(collection, lookupId);
+      if (!entry2) {
+        console.warn(`Entry ${collection} \u2192 ${lookupId} was not found.`);
+        return;
+      }
+      const { default: imageAssetMap } = await import("astro:asset-imports");
+      entry2.data = updateImageReferencesInData(entry2.data, entry2.filePath, imageAssetMap);
+      return {
+        ...entry2,
+        collection
+      };
+    }
+    if (!collectionNames.has(collection)) {
+      console.warn(`The collection ${JSON.stringify(collection)} does not exist.`);
+      return void 0;
+    }
+    const entryImport = await getEntryImport(collection, lookupId);
+    if (typeof entryImport !== "function") return void 0;
+    const entry = await entryImport();
+    if (entry._internal.type === "content") {
+      return {
+        id: entry.id,
+        slug: entry.slug,
+        body: entry.body,
+        collection: entry.collection,
+        data: entry.data,
+        async render() {
+          return render({
+            collection: entry.collection,
+            id: entry.id,
+            renderEntryImport: await getRenderEntryImport(collection, lookupId)
+          });
+        }
+      };
+    } else if (entry._internal.type === "data") {
+      return {
+        id: entry.id,
+        collection: entry.collection,
+        data: entry.data
+      };
+    }
+    return void 0;
+  };
+}
+function createGetEntries(getEntry) {
+  return async function getEntries(entries) {
+    return Promise.all(entries.map((e) => getEntry(e)));
+  };
+}
+const CONTENT_LAYER_IMAGE_REGEX = /__ASTRO_IMAGE_="([^"]+)"/g;
+async function updateImageReferencesInBody(html, fileName) {
+  const { default: imageAssetMap } = await import("astro:asset-imports");
+  const imageObjects = /* @__PURE__ */ new Map();
+  const { getImage } = await import("astro:assets");
+  for (const [_full, imagePath] of html.matchAll(CONTENT_LAYER_IMAGE_REGEX)) {
+    try {
+      const decodedImagePath = JSON.parse(imagePath.replaceAll("&#x22;", '"'));
+      const id = imageSrcToImportId(decodedImagePath.src, fileName);
+      const imported = imageAssetMap.get(id);
+      if (!id || imageObjects.has(id) || !imported) {
+        continue;
+      }
+      const image = await getImage({ ...decodedImagePath, src: imported });
+      imageObjects.set(imagePath, image);
+    } catch {
+      throw new Error(`Failed to parse image reference: ${imagePath}`);
+    }
+  }
+  return html.replaceAll(CONTENT_LAYER_IMAGE_REGEX, (full, imagePath) => {
+    const image = imageObjects.get(imagePath);
+    if (!image) {
+      return full;
+    }
+    const { index, ...attributes } = image.attributes;
+    return Object.entries({
+      ...attributes,
+      src: image.src,
+      srcset: image.srcSet.attribute
+    }).map(([key, value]) => value ? `${key}=${JSON.stringify(String(value))}` : "").join(" ");
+  });
+}
+function updateImageReferencesInData(data, fileName, imageAssetMap) {
+  return new Traverse(data).map(function(ctx, val) {
+    if (typeof val === "string" && val.startsWith(IMAGE_IMPORT_PREFIX)) {
+      const src = val.replace(IMAGE_IMPORT_PREFIX, "");
+      const id = imageSrcToImportId(src, fileName);
+      if (!id) {
+        ctx.update(src);
+        return;
+      }
+      const imported = imageAssetMap?.get(id);
+      if (imported) {
+        ctx.update(imported);
+      } else {
+        ctx.update(src);
+      }
+    }
+  });
+}
+async function renderEntry(entry) {
+  if (!entry) {
+    throw new AstroError(AstroErrorData.RenderUndefinedEntryError);
+  }
+  if ("render" in entry) {
+    return entry.render();
+  }
+  if (entry.deferredRender) {
+    try {
+      const { default: contentModules } = await import("astro:content-module-imports");
+      const renderEntryImport = contentModules.get(entry.filePath);
+      return render({
+        collection: "",
+        id: entry.id,
+        renderEntryImport
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  const html = entry?.rendered?.metadata?.imagePaths?.length && entry.filePath ? await updateImageReferencesInBody(entry.rendered.html, entry.filePath) : entry?.rendered?.html;
+  const Content = createComponent(() => serverRender`${unescapeHTML(html)}`);
+  return {
+    Content,
+    headings: entry?.rendered?.metadata?.headings ?? [],
+    remarkPluginFrontmatter: entry?.rendered?.metadata?.frontmatter ?? {}
+  };
+}
+async function render({
+  collection,
+  id,
+  renderEntryImport
+}) {
+  const UnexpectedRenderError = new AstroError({
+    ...AstroErrorData.UnknownContentCollectionError,
+    message: `Unexpected error while rendering ${String(collection)} \u2192 ${String(id)}.`
+  });
+  if (typeof renderEntryImport !== "function") throw UnexpectedRenderError;
+  const baseMod = await renderEntryImport();
+  if (baseMod == null || typeof baseMod !== "object") throw UnexpectedRenderError;
+  const { default: defaultMod } = baseMod;
+  if (isPropagatedAssetsModule(defaultMod)) {
+    const { collectedStyles, collectedLinks, collectedScripts, getMod } = defaultMod;
+    if (typeof getMod !== "function") throw UnexpectedRenderError;
+    const propagationMod = await getMod();
+    if (propagationMod == null || typeof propagationMod !== "object") throw UnexpectedRenderError;
+    const Content = createComponent({
+      factory(result, baseProps, slots) {
+        let styles = "", links = "", scripts = "";
+        if (Array.isArray(collectedStyles)) {
+          styles = collectedStyles.map((style) => {
+            return renderUniqueStylesheet(result, {
+              type: "inline",
+              content: style
+            });
+          }).join("");
+        }
+        if (Array.isArray(collectedLinks)) {
+          links = collectedLinks.map((link) => {
+            return renderUniqueStylesheet(result, {
+              type: "external",
+              src: prependForwardSlash(link)
+            });
+          }).join("");
+        }
+        if (Array.isArray(collectedScripts)) {
+          scripts = collectedScripts.map((script) => renderScriptElement(script)).join("");
+        }
+        let props = baseProps;
+        if (id.endsWith("mdx")) {
+          props = {
+            components: propagationMod.components ?? {},
+            ...baseProps
+          };
+        }
+        return createHeadAndContent(
+          unescapeHTML(styles + links + scripts),
+          renderTemplate`${renderComponent(
+            result,
+            "Content",
+            propagationMod.Content,
+            props,
+            slots
+          )}`
+        );
+      },
+      propagation: "self"
+    });
+    return {
+      Content,
+      headings: propagationMod.getHeadings?.() ?? [],
+      remarkPluginFrontmatter: propagationMod.frontmatter ?? {}
+    };
+  } else if (baseMod.Content && typeof baseMod.Content === "function") {
+    return {
+      Content: baseMod.Content,
+      headings: baseMod.getHeadings?.() ?? [],
+      remarkPluginFrontmatter: baseMod.frontmatter ?? {}
+    };
+  } else {
+    throw UnexpectedRenderError;
+  }
+}
+function createReference({ lookupMap }) {
+  return function reference(collection) {
+    return z.union([
+      z.string(),
+      z.object({
+        id: z.string(),
+        collection: z.string()
+      }),
+      z.object({
+        slug: z.string(),
+        collection: z.string()
+      })
+    ]).transform(
+      async (lookup, ctx) => {
+        const flattenedErrorPath = ctx.path.join(".");
+        const store = await globalDataStore.get();
+        const collectionIsInStore = store.hasCollection(collection);
+        if (typeof lookup === "object") {
+          if (lookup.collection !== collection) {
+            ctx.addIssue({
+              code: ZodIssueCode.custom,
+              message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${collection}. Received ${lookup.collection}.`
+            });
+            return;
+          }
+          return lookup;
+        }
+        if (collectionIsInStore) {
+          const entry2 = store.get(collection, lookup);
+          if (!entry2) {
+            ctx.addIssue({
+              code: ZodIssueCode.custom,
+              message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Entry ${lookup} does not exist.`
+            });
+            return;
+          }
+          return { id: lookup, collection };
+        }
+        if (!lookupMap[collection] && store.collections().size <= 1) {
+          return { id: lookup, collection };
+        }
+        const { type, entries } = lookupMap[collection];
+        const entry = entries[lookup];
+        if (!entry) {
+          ctx.addIssue({
+            code: ZodIssueCode.custom,
+            message: `**${flattenedErrorPath}**: Reference to ${collection} invalid. Expected ${Object.keys(
+              entries
+            ).map((c) => JSON.stringify(c)).join(" | ")}. Received ${JSON.stringify(lookup)}.`
+          });
+          return;
+        }
+        if (type === "content") {
+          return { slug: lookup, collection };
+        }
+        return { id: lookup, collection };
+      }
+    );
+  };
+}
+function isPropagatedAssetsModule(module) {
+  return typeof module === "object" && module != null && "__astroPropagation" in module;
+}
+export {
+  createCollectionToGlobResultMap,
+  createGetCollection,
+  createGetDataEntryById,
+  createGetEntries,
+  createGetEntry,
+  createGetEntryBySlug,
+  createReference,
+  defineCollection,
+  renderEntry
+};

node_modules/astro/dist/content/server-listeners.d.ts

@@ -0,0 +1,12 @@
+import type fsMod from 'node:fs';
+import type { ViteDevServer } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+interface ContentServerListenerParams {
+    fs: typeof fsMod;
+    logger: Logger;
+    settings: AstroSettings;
+    viteServer: ViteDevServer;
+}
+export declare function attachContentServerListeners({ viteServer, fs, logger, settings, }: ContentServerListenerParams): Promise<void>;
+export {};

node_modules/astro/dist/content/server-listeners.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { bold, cyan, underline } from "kleur/colors";
+import { loadTSConfig } from "../core/config/tsconfig.js";
+import { appendForwardSlash } from "../core/path.js";
+import { createContentTypesGenerator } from "./types-generator.js";
+import { getContentPaths, globalContentConfigObserver } from "./utils.js";
+async function attachContentServerListeners({
+  viteServer,
+  fs,
+  logger,
+  settings
+}) {
+  const contentPaths = getContentPaths(settings.config, fs);
+  if (fs.existsSync(contentPaths.contentDir)) {
+    logger.debug(
+      "content",
+      `Watching ${cyan(
+        contentPaths.contentDir.href.replace(settings.config.root.href, "")
+      )} for changes`
+    );
+    const maybeTsConfigStats = await getTSConfigStatsWhenAllowJsFalse({ contentPaths, settings });
+    if (maybeTsConfigStats) warnAllowJsIsFalse({ ...maybeTsConfigStats, logger });
+    await attachListeners();
+  } else {
+    viteServer.watcher.on("addDir", contentDirListener);
+    async function contentDirListener(dir) {
+      if (appendForwardSlash(pathToFileURL(dir).href) === contentPaths.contentDir.href) {
+        logger.debug("content", `Content directory found. Watching for changes`);
+        await attachListeners();
+        viteServer.watcher.removeListener("addDir", contentDirListener);
+      }
+    }
+  }
+  async function attachListeners() {
+    const contentGenerator = await createContentTypesGenerator({
+      fs,
+      settings,
+      logger,
+      viteServer,
+      contentConfigObserver: globalContentConfigObserver
+    });
+    await contentGenerator.init();
+    logger.debug("content", "Types generated");
+    viteServer.watcher.on("add", (entry) => {
+      contentGenerator.queueEvent({ name: "add", entry });
+    });
+    viteServer.watcher.on(
+      "addDir",
+      (entry) => contentGenerator.queueEvent({ name: "addDir", entry })
+    );
+    viteServer.watcher.on(
+      "change",
+      (entry) => contentGenerator.queueEvent({ name: "change", entry })
+    );
+    viteServer.watcher.on("unlink", (entry) => {
+      contentGenerator.queueEvent({ name: "unlink", entry });
+    });
+    viteServer.watcher.on(
+      "unlinkDir",
+      (entry) => contentGenerator.queueEvent({ name: "unlinkDir", entry })
+    );
+  }
+}
+function warnAllowJsIsFalse({
+  logger,
+  tsConfigFileName,
+  contentConfigFileName
+}) {
+  logger.warn(
+    "content",
+    `Make sure you have the ${bold("allowJs")} compiler option set to ${bold(
+      "true"
+    )} in your ${bold(tsConfigFileName)} file to have autocompletion in your ${bold(
+      contentConfigFileName
+    )} file. See ${underline(
+      cyan("https://www.typescriptlang.org/tsconfig#allowJs")
+    )} for more information.`
+  );
+}
+async function getTSConfigStatsWhenAllowJsFalse({
+  contentPaths,
+  settings
+}) {
+  const isContentConfigJsFile = [".js", ".mjs"].some(
+    (ext) => contentPaths.config.url.pathname.endsWith(ext)
+  );
+  if (!isContentConfigJsFile) return;
+  const inputConfig = await loadTSConfig(fileURLToPath(settings.config.root));
+  if (typeof inputConfig === "string") return;
+  const tsConfigFileName = inputConfig.tsconfigFile.split(path.sep).pop();
+  if (!tsConfigFileName) return;
+  const contentConfigFileName = contentPaths.config.url.pathname.split(path.sep).pop();
+  const allowJSOption = inputConfig.tsconfig.compilerOptions?.allowJs;
+  if (allowJSOption) return;
+  return { tsConfigFileName, contentConfigFileName };
+}
+export {
+  attachContentServerListeners
+};

node_modules/astro/dist/content/types-generator.d.ts

@@ -0,0 +1,28 @@
+import type fsMod from 'node:fs';
+import { type ViteDevServer } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+import { type ContentObservable } from './utils.js';
+type ChokidarEvent = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+type RawContentEvent = {
+    name: ChokidarEvent;
+    entry: string;
+};
+type CreateContentGeneratorParams = {
+    contentConfigObserver: ContentObservable;
+    logger: Logger;
+    settings: AstroSettings;
+    /** This is required for loading the content config */
+    viteServer: ViteDevServer;
+    fs: typeof fsMod;
+};
+export declare function createContentTypesGenerator({ contentConfigObserver, fs, logger, settings, viteServer, }: CreateContentGeneratorParams): Promise<{
+    init: () => Promise<{
+        typesGenerated: true;
+    } | {
+        typesGenerated: false;
+        reason: "no-content-dir";
+    }>;
+    queueEvent: (rawEvent: RawContentEvent) => void;
+}>;
+export {};

node_modules/astro/dist/content/types-generator.js

@@ -0,0 +1,533 @@
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import glob from "fast-glob";
+import { bold, cyan } from "kleur/colors";
+import { normalizePath } from "vite";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { AstroError } from "../core/errors/errors.js";
+import { AstroErrorData } from "../core/errors/index.js";
+import { isRelativePath } from "../core/path.js";
+import { CONTENT_LAYER_TYPE, CONTENT_TYPES_FILE, VIRTUAL_MODULE_ID } from "./consts.js";
+import {
+  getContentEntryIdAndSlug,
+  getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
+  getEntryCollectionName,
+  getEntryConfigByExtMap,
+  getEntrySlug,
+  getEntryType,
+  reloadContentConfigObserver
+} from "./utils.js";
+async function createContentTypesGenerator({
+  contentConfigObserver,
+  fs,
+  logger,
+  settings,
+  viteServer
+}) {
+  const collectionEntryMap = {};
+  const contentPaths = getContentPaths(settings.config, fs);
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+  const contentEntryExts = [...contentEntryConfigByExt.keys()];
+  const dataEntryExts = getDataEntryExts(settings);
+  let events = [];
+  let debounceTimeout;
+  const typeTemplateContent = await fs.promises.readFile(contentPaths.typesTemplate, "utf-8");
+  async function init() {
+    if (!fs.existsSync(contentPaths.contentDir)) {
+      return { typesGenerated: false, reason: "no-content-dir" };
+    }
+    events.push({ name: "add", entry: contentPaths.config.url });
+    const globResult = await glob("**", {
+      cwd: fileURLToPath(contentPaths.contentDir),
+      fs: {
+        readdir: fs.readdir.bind(fs),
+        readdirSync: fs.readdirSync.bind(fs)
+      },
+      onlyFiles: false,
+      objectMode: true
+    });
+    for (const entry of globResult) {
+      const fullPath = path.join(fileURLToPath(contentPaths.contentDir), entry.path);
+      const entryURL = pathToFileURL(fullPath);
+      if (entryURL.href.startsWith(contentPaths.config.url.href)) continue;
+      if (entry.dirent.isFile()) {
+        events.push({ name: "add", entry: entryURL });
+      } else if (entry.dirent.isDirectory()) {
+        events.push({ name: "addDir", entry: entryURL });
+      }
+    }
+    await runEvents();
+    return { typesGenerated: true };
+  }
+  async function handleEvent(event) {
+    if (event.name === "addDir" || event.name === "unlinkDir") {
+      const collection2 = normalizePath(
+        path.relative(fileURLToPath(contentPaths.contentDir), fileURLToPath(event.entry))
+      );
+      const collectionKey2 = JSON.stringify(collection2);
+      const isCollectionEvent = collection2.split("/").length === 1;
+      if (!isCollectionEvent) return { shouldGenerateTypes: false };
+      switch (event.name) {
+        case "addDir":
+          collectionEntryMap[collectionKey2] = {
+            type: "unknown",
+            entries: {}
+          };
+          logger.debug("content", `${cyan(collection2)} collection added`);
+          break;
+        case "unlinkDir":
+          delete collectionEntryMap[collectionKey2];
+          break;
+      }
+      return { shouldGenerateTypes: true };
+    }
+    const fileType = getEntryType(
+      fileURLToPath(event.entry),
+      contentPaths,
+      contentEntryExts,
+      dataEntryExts
+    );
+    if (fileType === "ignored") {
+      return { shouldGenerateTypes: false };
+    }
+    if (fileType === "config") {
+      await reloadContentConfigObserver({ fs, settings, viteServer });
+      return { shouldGenerateTypes: true };
+    }
+    const { entry } = event;
+    const { contentDir } = contentPaths;
+    const collection = getEntryCollectionName({ entry, contentDir });
+    if (collection === void 0) {
+      logger.warn(
+        "content",
+        `${bold(
+          normalizePath(
+            path.relative(fileURLToPath(contentPaths.contentDir), fileURLToPath(event.entry))
+          )
+        )} must live in a ${bold("content/...")} collection subdirectory.`
+      );
+      return { shouldGenerateTypes: false };
+    }
+    if (fileType === "data") {
+      const id2 = getDataEntryId({ entry, contentDir, collection });
+      const collectionKey2 = JSON.stringify(collection);
+      const entryKey2 = JSON.stringify(id2);
+      switch (event.name) {
+        case "add":
+          if (!(collectionKey2 in collectionEntryMap)) {
+            collectionEntryMap[collectionKey2] = { type: "data", entries: {} };
+          }
+          const collectionInfo2 = collectionEntryMap[collectionKey2];
+          if (collectionInfo2.type === "content") {
+            viteServer.hot.send({
+              type: "error",
+              err: new AstroError({
+                ...AstroErrorData.MixedContentDataCollectionError,
+                message: AstroErrorData.MixedContentDataCollectionError.message(collectionKey2),
+                location: { file: entry.pathname }
+              })
+            });
+            return { shouldGenerateTypes: false };
+          }
+          if (!(entryKey2 in collectionEntryMap[collectionKey2])) {
+            collectionEntryMap[collectionKey2] = {
+              type: "data",
+              entries: { ...collectionInfo2.entries, [entryKey2]: {} }
+            };
+          }
+          return { shouldGenerateTypes: true };
+        case "unlink":
+          if (collectionKey2 in collectionEntryMap && entryKey2 in collectionEntryMap[collectionKey2].entries) {
+            delete collectionEntryMap[collectionKey2].entries[entryKey2];
+          }
+          return { shouldGenerateTypes: true };
+        case "change":
+          return { shouldGenerateTypes: false };
+      }
+    }
+    const contentEntryType = contentEntryConfigByExt.get(path.extname(event.entry.pathname));
+    if (!contentEntryType) return { shouldGenerateTypes: false };
+    const { id, slug: generatedSlug } = getContentEntryIdAndSlug({
+      entry,
+      contentDir,
+      collection
+    });
+    const collectionKey = JSON.stringify(collection);
+    if (!(collectionKey in collectionEntryMap)) {
+      collectionEntryMap[collectionKey] = { type: "content", entries: {} };
+    }
+    const collectionInfo = collectionEntryMap[collectionKey];
+    if (collectionInfo.type === "data") {
+      viteServer.hot.send({
+        type: "error",
+        err: new AstroError({
+          ...AstroErrorData.MixedContentDataCollectionError,
+          message: AstroErrorData.MixedContentDataCollectionError.message(collectionKey),
+          location: { file: entry.pathname }
+        })
+      });
+      return { shouldGenerateTypes: false };
+    }
+    const entryKey = JSON.stringify(id);
+    switch (event.name) {
+      case "add":
+        const addedSlug = await getEntrySlug({
+          generatedSlug,
+          id,
+          collection,
+          fileUrl: event.entry,
+          contentEntryType,
+          fs
+        });
+        if (!(entryKey in collectionEntryMap[collectionKey].entries)) {
+          collectionEntryMap[collectionKey] = {
+            type: "content",
+            entries: {
+              ...collectionInfo.entries,
+              [entryKey]: { slug: addedSlug }
+            }
+          };
+        }
+        return { shouldGenerateTypes: true };
+      case "unlink":
+        if (collectionKey in collectionEntryMap && entryKey in collectionEntryMap[collectionKey].entries) {
+          delete collectionEntryMap[collectionKey].entries[entryKey];
+        }
+        return { shouldGenerateTypes: true };
+      case "change":
+        const changedSlug = await getEntrySlug({
+          generatedSlug,
+          id,
+          collection,
+          fileUrl: event.entry,
+          contentEntryType,
+          fs
+        });
+        const entryMetadata = collectionInfo.entries[entryKey];
+        if (entryMetadata?.slug !== changedSlug) {
+          collectionInfo.entries[entryKey].slug = changedSlug;
+          return { shouldGenerateTypes: true };
+        }
+        return { shouldGenerateTypes: false };
+    }
+  }
+  function queueEvent(rawEvent) {
+    const event = {
+      entry: pathToFileURL(rawEvent.entry),
+      name: rawEvent.name
+    };
+    if (!event.entry.pathname.startsWith(contentPaths.contentDir.pathname)) return;
+    events.push(event);
+    debounceTimeout && clearTimeout(debounceTimeout);
+    const runEventsSafe = async () => {
+      try {
+        await runEvents();
+      } catch {
+      }
+    };
+    debounceTimeout = setTimeout(
+      runEventsSafe,
+      50
+      /* debounce to batch chokidar events */
+    );
+  }
+  async function runEvents() {
+    const eventResponses = [];
+    for (const event of events) {
+      const response = await handleEvent(event);
+      eventResponses.push(response);
+    }
+    events = [];
+    const observable = contentConfigObserver.get();
+    if (eventResponses.some((r) => r.shouldGenerateTypes)) {
+      await writeContentFiles({
+        fs,
+        collectionEntryMap,
+        contentPaths,
+        typeTemplateContent,
+        contentConfig: observable.status === "loaded" ? observable.config : void 0,
+        contentEntryTypes: settings.contentEntryTypes,
+        viteServer,
+        logger,
+        settings
+      });
+      invalidateVirtualMod(viteServer);
+    }
+  }
+  return { init, queueEvent };
+}
+function invalidateVirtualMod(viteServer) {
+  const virtualMod = viteServer.moduleGraph.getModuleById("\0" + VIRTUAL_MODULE_ID);
+  if (!virtualMod) return;
+  viteServer.moduleGraph.invalidateModule(virtualMod);
+}
+function normalizeConfigPath(from, to) {
+  const configPath = path.relative(from, to).replace(/\.ts$/, ".js");
+  const normalizedPath = configPath.replaceAll("\\", "/");
+  return `"${isRelativePath(configPath) ? "" : "./"}${normalizedPath}"`;
+}
+const schemaCache = /* @__PURE__ */ new Map();
+async function getContentLayerSchema(collection, collectionKey) {
+  const cached = schemaCache.get(collectionKey);
+  if (cached) {
+    return cached;
+  }
+  if (collection?.type === CONTENT_LAYER_TYPE && typeof collection.loader === "object" && collection.loader.schema) {
+    let schema = collection.loader.schema;
+    if (typeof schema === "function") {
+      schema = await schema();
+    }
+    if (schema) {
+      schemaCache.set(collectionKey, await schema);
+      return schema;
+    }
+  }
+}
+async function typeForCollection(collection, collectionKey) {
+  if (collection?.schema) {
+    return `InferEntrySchema<${collectionKey}>`;
+  }
+  if (collection?.type === CONTENT_LAYER_TYPE) {
+    const schema = await getContentLayerSchema(collection, collectionKey);
+    if (schema) {
+      try {
+        const zodToTs = await import("zod-to-ts");
+        const ast = zodToTs.zodToTs(schema);
+        return zodToTs.printNode(ast.node);
+      } catch (err) {
+        if (err.message.includes("Cannot find package 'typescript'")) {
+          return "any";
+        }
+        throw err;
+      }
+    }
+  }
+  return "any";
+}
+async function writeContentFiles({
+  fs,
+  contentPaths,
+  collectionEntryMap,
+  typeTemplateContent,
+  contentEntryTypes,
+  contentConfig,
+  viteServer,
+  logger,
+  settings
+}) {
+  let contentTypesStr = "";
+  let dataTypesStr = "";
+  const collectionSchemasDir = new URL("./collections/", settings.dotAstroDir);
+  if (!fs.existsSync(collectionSchemasDir)) {
+    fs.mkdirSync(collectionSchemasDir, { recursive: true });
+  }
+  for (const [collection, config] of Object.entries(contentConfig?.collections ?? {})) {
+    collectionEntryMap[JSON.stringify(collection)] ??= {
+      type: config.type,
+      entries: {}
+    };
+  }
+  let contentCollectionsMap = {};
+  for (const collectionKey of Object.keys(collectionEntryMap).sort()) {
+    const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
+    const collection = collectionEntryMap[collectionKey];
+    if (collectionConfig?.type && collection.type !== "unknown" && collectionConfig.type !== CONTENT_LAYER_TYPE && collection.type !== collectionConfig.type) {
+      viteServer.hot.send({
+        type: "error",
+        err: new AstroError({
+          ...AstroErrorData.ContentCollectionTypeMismatchError,
+          message: AstroErrorData.ContentCollectionTypeMismatchError.message(
+            collectionKey,
+            collection.type,
+            collectionConfig.type
+          ),
+          hint: collection.type === "data" ? "Try adding `type: 'data'` to your collection config." : void 0,
+          location: {
+            file: ""
+          }
+        })
+      });
+      return;
+    }
+    const resolvedType = collection.type === "unknown" ? (
+      // Add empty / unknown collections to the data type map by default
+      // This ensures `getCollection('empty-collection')` doesn't raise a type error
+      collectionConfig?.type ?? "data"
+    ) : collection.type;
+    const collectionEntryKeys = Object.keys(collection.entries).sort();
+    const dataType = await typeForCollection(collectionConfig, collectionKey);
+    switch (resolvedType) {
+      case "content":
+        if (collectionEntryKeys.length === 0) {
+          contentTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  slug: string;
+  body: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+  render(): Render[".md"];
+}>;
+`;
+          break;
+        }
+        contentTypesStr += `${collectionKey}: {
+`;
+        for (const entryKey of collectionEntryKeys) {
+          const entryMetadata = collection.entries[entryKey];
+          const renderType = `{ render(): Render[${JSON.stringify(
+            path.extname(JSON.parse(entryKey))
+          )}] }`;
+          const slugType = JSON.stringify(entryMetadata.slug);
+          contentTypesStr += `${entryKey}: {
+	id: ${entryKey};
+  slug: ${slugType};
+  body: string;
+  collection: ${collectionKey};
+  data: ${dataType}
+} & ${renderType};
+`;
+        }
+        contentTypesStr += `};
+`;
+        break;
+      case CONTENT_LAYER_TYPE:
+        dataTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+  rendered?: RenderedContent;
+  filePath?: string;
+  body?: string 
+}>;
+`;
+        break;
+      case "data":
+        if (collectionEntryKeys.length === 0) {
+          dataTypesStr += `${collectionKey}: Record<string, {
+  id: string;
+  collection: ${collectionKey};
+  data: ${dataType};
+}>;
+`;
+        } else {
+          dataTypesStr += `${collectionKey}: {
+`;
+          for (const entryKey of collectionEntryKeys) {
+            dataTypesStr += `${entryKey}: {
+	id: ${entryKey};
+  collection: ${collectionKey};
+  data: ${dataType}
+};
+`;
+          }
+          dataTypesStr += `};
+`;
+        }
+        if (collectionConfig?.schema) {
+          await generateJSONSchema(
+            fs,
+            collectionConfig,
+            collectionKey,
+            collectionSchemasDir,
+            logger
+          );
+        }
+        break;
+    }
+    if (settings.config.experimental.contentIntellisense && collectionConfig && (collectionConfig.schema || await getContentLayerSchema(collectionConfig, collectionKey))) {
+      await generateJSONSchema(fs, collectionConfig, collectionKey, collectionSchemasDir, logger);
+      contentCollectionsMap[collectionKey] = collection;
+    }
+  }
+  if (settings.config.experimental.contentIntellisense) {
+    let contentCollectionManifest = {
+      collections: [],
+      entries: {}
+    };
+    Object.entries(contentCollectionsMap).forEach(([collectionKey, collection]) => {
+      const collectionConfig = contentConfig?.collections[JSON.parse(collectionKey)];
+      const key = JSON.parse(collectionKey);
+      contentCollectionManifest.collections.push({
+        hasSchema: Boolean(collectionConfig?.schema || schemaCache.has(collectionKey)),
+        name: key
+      });
+      Object.keys(collection.entries).forEach((entryKey) => {
+        const entryPath = new URL(
+          JSON.parse(entryKey),
+          contentPaths.contentDir + `${key}/`
+        ).toString();
+        contentCollectionManifest.entries[entryPath.toLowerCase()] = key;
+      });
+    });
+    await fs.promises.writeFile(
+      new URL("./collections.json", collectionSchemasDir),
+      JSON.stringify(contentCollectionManifest, null, 2)
+    );
+  }
+  if (!fs.existsSync(settings.dotAstroDir)) {
+    fs.mkdirSync(settings.dotAstroDir, { recursive: true });
+  }
+  const configPathRelativeToCacheDir = normalizeConfigPath(
+    new URL("astro", settings.dotAstroDir).pathname,
+    contentPaths.config.url.pathname
+  );
+  for (const contentEntryType of contentEntryTypes) {
+    if (contentEntryType.contentModuleTypes) {
+      typeTemplateContent = contentEntryType.contentModuleTypes + "\n" + typeTemplateContent;
+    }
+  }
+  typeTemplateContent = typeTemplateContent.replace("// @@CONTENT_ENTRY_MAP@@", contentTypesStr);
+  typeTemplateContent = typeTemplateContent.replace("// @@DATA_ENTRY_MAP@@", dataTypesStr);
+  typeTemplateContent = typeTemplateContent.replace(
+    "'@@CONTENT_CONFIG_TYPE@@'",
+    contentConfig ? `typeof import(${configPathRelativeToCacheDir})` : "never"
+  );
+  if (settings.injectedTypes.some((t) => t.filename === CONTENT_TYPES_FILE)) {
+    const filePath = fileURLToPath(new URL(CONTENT_TYPES_FILE, settings.dotAstroDir));
+    await fs.promises.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.promises.writeFile(filePath, typeTemplateContent, "utf-8");
+  } else {
+    settings.injectedTypes.push({
+      filename: CONTENT_TYPES_FILE,
+      content: typeTemplateContent
+    });
+  }
+}
+async function generateJSONSchema(fsMod, collectionConfig, collectionKey, collectionSchemasDir, logger) {
+  let zodSchemaForJson = typeof collectionConfig.schema === "function" ? collectionConfig.schema({ image: () => z.string() }) : collectionConfig.schema;
+  if (!zodSchemaForJson && collectionConfig.type === CONTENT_LAYER_TYPE) {
+    zodSchemaForJson = await getContentLayerSchema(collectionConfig, collectionKey);
+  }
+  if (zodSchemaForJson instanceof z.ZodObject) {
+    zodSchemaForJson = zodSchemaForJson.extend({
+      $schema: z.string().optional()
+    });
+  }
+  try {
+    await fsMod.promises.writeFile(
+      new URL(`./${collectionKey.replace(/"/g, "")}.schema.json`, collectionSchemasDir),
+      JSON.stringify(
+        zodToJsonSchema(zodSchemaForJson, {
+          name: collectionKey.replace(/"/g, ""),
+          markdownDescription: true,
+          errorMessages: true,
+          // Fix for https://github.com/StefanTerdell/zod-to-json-schema/issues/110
+          dateStrategy: ["format:date-time", "format:date", "integer"]
+        }),
+        null,
+        2
+      )
+    );
+  } catch (err) {
+    logger.warn(
+      "content",
+      `An error was encountered while creating the JSON schema for the ${collectionKey} collection. Proceeding without it. Error: ${err}`
+    );
+  }
+}
+export {
+  createContentTypesGenerator
+};

node_modules/astro/dist/content/utils.d.ts

@@ -0,0 +1,505 @@
+import fsMod from 'node:fs';
+import matter from 'gray-matter';
+import type { PluginContext } from 'rollup';
+import type { ViteDevServer } from 'vite';
+import { z } from 'zod';
+import type { AstroConfig, AstroSettings, ContentEntryType, DataEntryType } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+import { CONTENT_FLAGS } from './consts.js';
+/**
+ * Amap from a collection + slug to the local file path.
+ * This is used internally to resolve entry imports when using `getEntry()`.
+ * @see `templates/content/module.mjs`
+ */
+export type ContentLookupMap = {
+    [collectionName: string]: {
+        type: 'content' | 'data';
+        entries: {
+            [lookupId: string]: string;
+        };
+    };
+};
+declare const collectionConfigParser: z.ZodUnion<[z.ZodObject<{
+    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
+    schema: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type: "content";
+    schema?: any;
+}, {
+    type?: "content" | undefined;
+    schema?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"data">;
+    schema: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    type: "data";
+    schema?: any;
+}, {
+    type: "data";
+    schema?: any;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"content_layer">;
+    schema: z.ZodOptional<z.ZodAny>;
+    loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">>, "many">, z.ZodPromise<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, "strip", z.ZodUnknown, z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">, z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">>, "many">>]>>, z.ZodObject<{
+        name: z.ZodString;
+        load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+            collection: z.ZodString;
+            store: z.ZodAny;
+            meta: z.ZodAny;
+            logger: z.ZodAny;
+            config: z.ZodAny;
+            entryTypes: z.ZodAny;
+            parseData: z.ZodAny;
+            generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
+            watcher: z.ZodOptional<z.ZodAny>;
+        }, "strip", z.ZodTypeAny, {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }, {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }>], null>, z.ZodUnknown>;
+        schema: z.ZodOptional<z.ZodAny>;
+        render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    }, {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    }>]>;
+}, "strip", z.ZodTypeAny, {
+    type: "content_layer";
+    loader: ((...args: unknown[]) => z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[]>) | {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    };
+    schema?: any;
+}, {
+    type: "content_layer";
+    loader: ((...args: unknown[]) => z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+        id: z.ZodString;
+    }, z.ZodUnknown, "strip">[]>) | {
+        name: string;
+        load: (args_0: {
+            collection: string;
+            generateDigest: (args_0: any) => unknown;
+            config?: any;
+            meta?: any;
+            logger?: any;
+            store?: any;
+            entryTypes?: any;
+            parseData?: any;
+            watcher?: any;
+        }) => unknown;
+        schema?: any;
+        render?: ((args_0: any) => unknown) | undefined;
+    };
+    schema?: any;
+}>]>;
+declare const contentConfigParser: z.ZodObject<{
+    collections: z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodObject<{
+        type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"content">>>;
+        schema: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: "content";
+        schema?: any;
+    }, {
+        type?: "content" | undefined;
+        schema?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"data">;
+        schema: z.ZodOptional<z.ZodAny>;
+    }, "strip", z.ZodTypeAny, {
+        type: "data";
+        schema?: any;
+    }, {
+        type: "data";
+        schema?: any;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"content_layer">;
+        schema: z.ZodOptional<z.ZodAny>;
+        loader: z.ZodUnion<[z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">>, "many">, z.ZodPromise<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+        }, "strip", z.ZodUnknown, z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">, z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">>, "many">>]>>, z.ZodObject<{
+            name: z.ZodString;
+            load: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
+                collection: z.ZodString;
+                store: z.ZodAny;
+                meta: z.ZodAny;
+                logger: z.ZodAny;
+                config: z.ZodAny;
+                entryTypes: z.ZodAny;
+                parseData: z.ZodAny;
+                generateDigest: z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>;
+                watcher: z.ZodOptional<z.ZodAny>;
+            }, "strip", z.ZodTypeAny, {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }, {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }>], null>, z.ZodUnknown>;
+            schema: z.ZodOptional<z.ZodAny>;
+            render: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], null>, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        }, {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
+    }, {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    collections: Record<string, {
+        type: "content";
+        schema?: any;
+    } | {
+        type: "data";
+        schema?: any;
+    } | {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectOutputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
+    }>;
+}, {
+    collections: Record<string, {
+        type?: "content" | undefined;
+        schema?: any;
+    } | {
+        type: "data";
+        schema?: any;
+    } | {
+        type: "content_layer";
+        loader: ((...args: unknown[]) => z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[] | Promise<z.objectInputType<{
+            id: z.ZodString;
+        }, z.ZodUnknown, "strip">[]>) | {
+            name: string;
+            load: (args_0: {
+                collection: string;
+                generateDigest: (args_0: any) => unknown;
+                config?: any;
+                meta?: any;
+                logger?: any;
+                store?: any;
+                entryTypes?: any;
+                parseData?: any;
+                watcher?: any;
+            }) => unknown;
+            schema?: any;
+            render?: ((args_0: any) => unknown) | undefined;
+        };
+        schema?: any;
+    }>;
+}>;
+export type CollectionConfig = z.infer<typeof collectionConfigParser>;
+export type ContentConfig = z.infer<typeof contentConfigParser> & {
+    digest?: string;
+};
+type EntryInternal = {
+    rawData: string | undefined;
+    filePath: string;
+};
+export declare function parseEntrySlug({ id, collection, generatedSlug, frontmatterSlug, }: {
+    id: string;
+    collection: string;
+    generatedSlug: string;
+    frontmatterSlug?: unknown;
+}): string;
+export declare function getEntryDataAndImages<TInputData extends Record<string, unknown> = Record<string, unknown>, TOutputData extends TInputData = TInputData>(entry: {
+    id: string;
+    collection: string;
+    unvalidatedData: TInputData;
+    _internal: EntryInternal;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<{
+    data: TOutputData;
+    imageImports: Array<string>;
+}>;
+export declare function getEntryData(entry: {
+    id: string;
+    collection: string;
+    unvalidatedData: Record<string, unknown>;
+    _internal: EntryInternal;
+}, collectionConfig: CollectionConfig, shouldEmitFile: boolean, pluginContext?: PluginContext): Promise<Record<string, unknown>>;
+export declare function getContentEntryExts(settings: Pick<AstroSettings, 'contentEntryTypes'>): string[];
+export declare function getDataEntryExts(settings: Pick<AstroSettings, 'dataEntryTypes'>): string[];
+export declare function getEntryConfigByExtMap<TEntryType extends ContentEntryType | DataEntryType>(entryTypes: TEntryType[]): Map<string, TEntryType>;
+export declare function getSymlinkedContentCollections({ contentDir, logger, fs, }: {
+    contentDir: URL;
+    logger: Logger;
+    fs: typeof fsMod;
+}): Promise<Map<string, string>>;
+export declare function reverseSymlink({ entry, symlinks, contentDir, }: {
+    entry: string | URL;
+    contentDir: string | URL;
+    symlinks?: Map<string, string>;
+}): string;
+export declare function getEntryCollectionName({ contentDir, entry, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: string | URL;
+}): string | undefined;
+export declare function getDataEntryId({ entry, contentDir, collection, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: URL;
+    collection: string;
+}): string;
+export declare function getContentEntryIdAndSlug({ entry, contentDir, collection, }: Pick<ContentPaths, 'contentDir'> & {
+    entry: URL;
+    collection: string;
+}): {
+    id: string;
+    slug: string;
+};
+export declare function getEntryType(entryPath: string, paths: Pick<ContentPaths, 'config' | 'contentDir'>, contentFileExts: string[], dataFileExts: string[]): 'content' | 'data' | 'config' | 'ignored';
+export declare function safeParseFrontmatter(source: string, id?: string): matter.GrayMatterFile<string>;
+/**
+ * The content config is loaded separately from other `src/` files.
+ * This global observable lets dependent plugins (like the content flag plugin)
+ * subscribe to changes during dev server updates.
+ */
+export declare const globalContentConfigObserver: ContentObservable;
+export declare function hasAnyContentFlag(viteId: string): boolean;
+export declare function hasContentFlag(viteId: string, flag: (typeof CONTENT_FLAGS)[number]): boolean;
+export declare function isDeferredModule(viteId: string): boolean;
+export declare function reloadContentConfigObserver({ observer, ...loadContentConfigOpts }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+    viteServer: ViteDevServer;
+    observer?: ContentObservable;
+}): Promise<void>;
+type ContentCtx = {
+    status: 'init';
+} | {
+    status: 'loading';
+} | {
+    status: 'does-not-exist';
+} | {
+    status: 'loaded';
+    config: ContentConfig;
+} | {
+    status: 'error';
+    error: Error;
+};
+type Observable<C> = {
+    get: () => C;
+    set: (ctx: C) => void;
+    subscribe: (fn: (ctx: C) => void) => () => void;
+};
+export type ContentObservable = Observable<ContentCtx>;
+export declare function contentObservable(initialCtx: ContentCtx): ContentObservable;
+export type ContentPaths = {
+    contentDir: URL;
+    assetsDir: URL;
+    typesTemplate: URL;
+    virtualModTemplate: URL;
+    config: {
+        exists: boolean;
+        url: URL;
+    };
+};
+export declare function getContentPaths({ srcDir }: Pick<AstroConfig, 'root' | 'srcDir'>, fs?: typeof fsMod): ContentPaths;
+/**
+ * Check for slug in content entry frontmatter and validate the type,
+ * falling back to the `generatedSlug` if none is found.
+ */
+export declare function getEntrySlug({ id, collection, generatedSlug, contentEntryType, fileUrl, fs, }: {
+    fs: typeof fsMod;
+    id: string;
+    collection: string;
+    generatedSlug: string;
+    fileUrl: URL;
+    contentEntryType: Pick<ContentEntryType, 'getEntryInfo'>;
+}): Promise<string>;
+export declare function getExtGlob(exts: string[]): string;
+export declare function hasAssetPropagationFlag(id: string): boolean;
+/**
+ * Convert a platform path to a posix path.
+ */
+export declare function posixifyPath(filePath: string): string;
+/**
+ * Unlike `path.posix.relative`, this function will accept a platform path and return a posix path.
+ */
+export declare function posixRelative(from: string, to: string): string;
+export declare function contentModuleToId(fileName: string): string;
+export {};

node_modules/astro/dist/content/utils.js

@@ -0,0 +1,503 @@
+import fsMod from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { slug as githubSlug } from "github-slugger";
+import matter from "gray-matter";
+import xxhash from "xxhash-wasm";
+import { z } from "zod";
+import { AstroError, AstroErrorData, MarkdownError, errorMap } from "../core/errors/index.js";
+import { isYAMLException } from "../core/errors/utils.js";
+import { normalizePath } from "../core/viteUtils.js";
+import {
+  CONTENT_FLAGS,
+  CONTENT_LAYER_TYPE,
+  CONTENT_MODULE_FLAG,
+  DEFERRED_MODULE,
+  IMAGE_IMPORT_PREFIX,
+  PROPAGATED_ASSET_FLAG
+} from "./consts.js";
+import { createImage } from "./runtime-assets.js";
+const collectionConfigParser = z.union([
+  z.object({
+    type: z.literal("content").optional().default("content"),
+    schema: z.any().optional()
+  }),
+  z.object({
+    type: z.literal("data"),
+    schema: z.any().optional()
+  }),
+  z.object({
+    type: z.literal(CONTENT_LAYER_TYPE),
+    schema: z.any().optional(),
+    loader: z.union([
+      z.function().returns(
+        z.union([
+          z.array(
+            z.object({
+              id: z.string()
+            }).catchall(z.unknown())
+          ),
+          z.promise(
+            z.array(
+              z.object({
+                id: z.string()
+              }).catchall(z.unknown())
+            )
+          )
+        ])
+      ),
+      z.object({
+        name: z.string(),
+        load: z.function(
+          z.tuple(
+            [
+              z.object({
+                collection: z.string(),
+                store: z.any(),
+                meta: z.any(),
+                logger: z.any(),
+                config: z.any(),
+                entryTypes: z.any(),
+                parseData: z.any(),
+                generateDigest: z.function(z.tuple([z.any()], z.string())),
+                watcher: z.any().optional()
+              })
+            ],
+            z.unknown()
+          )
+        ),
+        schema: z.any().optional(),
+        render: z.function(z.tuple([z.any()], z.unknown())).optional()
+      })
+    ])
+  })
+]);
+const contentConfigParser = z.object({
+  collections: z.record(collectionConfigParser)
+});
+function parseEntrySlug({
+  id,
+  collection,
+  generatedSlug,
+  frontmatterSlug
+}) {
+  try {
+    return z.string().default(generatedSlug).parse(frontmatterSlug);
+  } catch {
+    throw new AstroError({
+      ...AstroErrorData.InvalidContentEntrySlugError,
+      message: AstroErrorData.InvalidContentEntrySlugError.message(collection, id)
+    });
+  }
+}
+async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, pluginContext) {
+  let data;
+  if (collectionConfig.type === "data" || collectionConfig.type === CONTENT_LAYER_TYPE) {
+    data = entry.unvalidatedData;
+  } else {
+    const { slug, ...unvalidatedData } = entry.unvalidatedData;
+    data = unvalidatedData;
+  }
+  let schema = collectionConfig.schema;
+  const imageImports = /* @__PURE__ */ new Set();
+  if (typeof schema === "function") {
+    if (pluginContext) {
+      schema = schema({
+        image: createImage(pluginContext, shouldEmitFile, entry._internal.filePath)
+      });
+    } else if (collectionConfig.type === CONTENT_LAYER_TYPE) {
+      schema = schema({
+        image: () => z.string().transform((val) => {
+          imageImports.add(val);
+          return `${IMAGE_IMPORT_PREFIX}${val}`;
+        })
+      });
+    }
+  }
+  if (schema) {
+    if (collectionConfig.type === "content" && typeof schema === "object" && "shape" in schema && schema.shape.slug) {
+      throw new AstroError({
+        ...AstroErrorData.ContentSchemaContainsSlugError,
+        message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
+      });
+    }
+    let formattedError;
+    const parsed = await schema.safeParseAsync(data, {
+      errorMap(error, ctx) {
+        if (error.code === "custom" && error.params?.isHoistedAstroError) {
+          formattedError = error.params?.astroError;
+        }
+        return errorMap(error, ctx);
+      }
+    });
+    if (parsed.success) {
+      data = parsed.data;
+    } else {
+      if (!formattedError) {
+        formattedError = new AstroError({
+          ...AstroErrorData.InvalidContentEntryFrontmatterError,
+          message: AstroErrorData.InvalidContentEntryFrontmatterError.message(
+            entry.collection,
+            entry.id,
+            parsed.error
+          ),
+          location: {
+            file: entry._internal.filePath,
+            line: getYAMLErrorLine(entry._internal.rawData, String(parsed.error.errors[0].path[0])),
+            column: 0
+          }
+        });
+      }
+      throw formattedError;
+    }
+  }
+  return { data, imageImports: Array.from(imageImports) };
+}
+async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginContext) {
+  const { data } = await getEntryDataAndImages(
+    entry,
+    collectionConfig,
+    shouldEmitFile,
+    pluginContext
+  );
+  return data;
+}
+function getContentEntryExts(settings) {
+  return settings.contentEntryTypes.map((t) => t.extensions).flat();
+}
+function getDataEntryExts(settings) {
+  return settings.dataEntryTypes.map((t) => t.extensions).flat();
+}
+function getEntryConfigByExtMap(entryTypes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const entryType of entryTypes) {
+    for (const ext of entryType.extensions) {
+      map.set(ext, entryType);
+    }
+  }
+  return map;
+}
+async function getSymlinkedContentCollections({
+  contentDir,
+  logger,
+  fs
+}) {
+  const contentPaths = /* @__PURE__ */ new Map();
+  const contentDirPath = fileURLToPath(contentDir);
+  try {
+    if (!fs.existsSync(contentDirPath) || !fs.lstatSync(contentDirPath).isDirectory()) {
+      return contentPaths;
+    }
+  } catch {
+    return contentPaths;
+  }
+  try {
+    const contentDirEntries = await fs.promises.readdir(contentDir, { withFileTypes: true });
+    for (const entry of contentDirEntries) {
+      if (entry.isSymbolicLink()) {
+        const entryPath = path.join(contentDirPath, entry.name);
+        const realPath = await fs.promises.realpath(entryPath);
+        contentPaths.set(normalizePath(realPath), entry.name);
+      }
+    }
+  } catch (e) {
+    logger.warn("content", `Error when reading content directory "${contentDir}"`);
+    logger.debug("content", e);
+    return /* @__PURE__ */ new Map();
+  }
+  return contentPaths;
+}
+function reverseSymlink({
+  entry,
+  symlinks,
+  contentDir
+}) {
+  const entryPath = normalizePath(typeof entry === "string" ? entry : fileURLToPath(entry));
+  const contentDirPath = typeof contentDir === "string" ? contentDir : fileURLToPath(contentDir);
+  if (!symlinks || symlinks.size === 0) {
+    return entryPath;
+  }
+  for (const [realPath, symlinkName] of symlinks) {
+    if (entryPath.startsWith(realPath)) {
+      return normalizePath(path.join(contentDirPath, symlinkName, entryPath.replace(realPath, "")));
+    }
+  }
+  return entryPath;
+}
+function getEntryCollectionName({
+  contentDir,
+  entry
+}) {
+  const entryPath = typeof entry === "string" ? entry : fileURLToPath(entry);
+  const rawRelativePath = path.relative(fileURLToPath(contentDir), entryPath);
+  const collectionName = path.dirname(rawRelativePath).split(path.sep)[0];
+  const isOutsideCollection = !collectionName || collectionName === "" || collectionName === ".." || collectionName === ".";
+  if (isOutsideCollection) {
+    return void 0;
+  }
+  return collectionName;
+}
+function getDataEntryId({
+  entry,
+  contentDir,
+  collection
+}) {
+  const relativePath = getRelativeEntryPath(entry, collection, contentDir);
+  const withoutFileExt = normalizePath(relativePath).replace(
+    new RegExp(path.extname(relativePath) + "$"),
+    ""
+  );
+  return withoutFileExt;
+}
+function getContentEntryIdAndSlug({
+  entry,
+  contentDir,
+  collection
+}) {
+  const relativePath = getRelativeEntryPath(entry, collection, contentDir);
+  const withoutFileExt = relativePath.replace(new RegExp(path.extname(relativePath) + "$"), "");
+  const rawSlugSegments = withoutFileExt.split(path.sep);
+  const slug = rawSlugSegments.map((segment) => githubSlug(segment)).join("/").replace(/\/index$/, "");
+  const res = {
+    id: normalizePath(relativePath),
+    slug
+  };
+  return res;
+}
+function getRelativeEntryPath(entry, collection, contentDir) {
+  const relativeToContent = path.relative(fileURLToPath(contentDir), fileURLToPath(entry));
+  const relativeToCollection = path.relative(collection, relativeToContent);
+  return relativeToCollection;
+}
+function getEntryType(entryPath, paths, contentFileExts, dataFileExts) {
+  const { ext } = path.parse(entryPath);
+  const fileUrl = pathToFileURL(entryPath);
+  if (hasUnderscoreBelowContentDirectoryPath(fileUrl, paths.contentDir)) {
+    return "ignored";
+  } else if (contentFileExts.includes(ext)) {
+    return "content";
+  } else if (dataFileExts.includes(ext)) {
+    return "data";
+  } else if (fileUrl.href === paths.config.url.href) {
+    return "config";
+  } else {
+    return "ignored";
+  }
+}
+function hasUnderscoreBelowContentDirectoryPath(fileUrl, contentDir) {
+  const parts = fileUrl.pathname.replace(contentDir.pathname, "").split("/");
+  for (const part of parts) {
+    if (part.startsWith("_")) return true;
+  }
+  return false;
+}
+function getYAMLErrorLine(rawData, objectKey) {
+  if (!rawData) return 0;
+  const indexOfObjectKey = rawData.search(
+    // Match key either at the top of the file or after a newline
+    // Ensures matching on top-level object keys only
+    new RegExp(`(
+|^)${objectKey}`)
+  );
+  if (indexOfObjectKey === -1) return 0;
+  const dataBeforeKey = rawData.substring(0, indexOfObjectKey + 1);
+  const numNewlinesBeforeKey = dataBeforeKey.split("\n").length;
+  return numNewlinesBeforeKey;
+}
+function safeParseFrontmatter(source, id) {
+  try {
+    return matter(source);
+  } catch (err) {
+    const markdownError = new MarkdownError({
+      name: "MarkdownError",
+      message: err.message,
+      stack: err.stack,
+      location: id ? {
+        file: id
+      } : void 0
+    });
+    if (isYAMLException(err)) {
+      markdownError.setLocation({
+        file: id,
+        line: err.mark.line,
+        column: err.mark.column
+      });
+      markdownError.setMessage(err.reason);
+    }
+    throw markdownError;
+  }
+}
+const globalContentConfigObserver = contentObservable({ status: "init" });
+function hasAnyContentFlag(viteId) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  const flag = Array.from(flags.keys()).at(0);
+  if (typeof flag !== "string") {
+    return false;
+  }
+  return CONTENT_FLAGS.includes(flag);
+}
+function hasContentFlag(viteId, flag) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  return flags.has(flag);
+}
+function isDeferredModule(viteId) {
+  const flags = new URLSearchParams(viteId.split("?")[1] ?? "");
+  return flags.has(CONTENT_MODULE_FLAG);
+}
+async function loadContentConfig({
+  fs,
+  settings,
+  viteServer
+}) {
+  const contentPaths = getContentPaths(settings.config, fs);
+  let unparsedConfig;
+  if (!contentPaths.config.exists) {
+    return void 0;
+  }
+  const configPathname = fileURLToPath(contentPaths.config.url);
+  unparsedConfig = await viteServer.ssrLoadModule(configPathname);
+  const config = contentConfigParser.safeParse(unparsedConfig);
+  if (config.success) {
+    const hasher = await xxhash();
+    const digest = await hasher.h64ToString(await fs.promises.readFile(configPathname, "utf-8"));
+    return { ...config.data, digest };
+  } else {
+    return void 0;
+  }
+}
+async function reloadContentConfigObserver({
+  observer = globalContentConfigObserver,
+  ...loadContentConfigOpts
+}) {
+  observer.set({ status: "loading" });
+  try {
+    const config = await loadContentConfig(loadContentConfigOpts);
+    if (config) {
+      observer.set({ status: "loaded", config });
+    } else {
+      observer.set({ status: "does-not-exist" });
+    }
+  } catch (e) {
+    observer.set({
+      status: "error",
+      error: e instanceof Error ? e : new AstroError(AstroErrorData.UnknownContentCollectionError)
+    });
+  }
+}
+function contentObservable(initialCtx) {
+  const subscribers = /* @__PURE__ */ new Set();
+  let ctx = initialCtx;
+  function get() {
+    return ctx;
+  }
+  function set(_ctx) {
+    ctx = _ctx;
+    subscribers.forEach((fn) => fn(ctx));
+  }
+  function subscribe(fn) {
+    subscribers.add(fn);
+    return () => {
+      subscribers.delete(fn);
+    };
+  }
+  return {
+    get,
+    set,
+    subscribe
+  };
+}
+function getContentPaths({ srcDir }, fs = fsMod) {
+  const configStats = search(fs, srcDir);
+  const pkgBase = new URL("../../", import.meta.url);
+  return {
+    contentDir: new URL("./content/", srcDir),
+    assetsDir: new URL("./assets/", srcDir),
+    typesTemplate: new URL("templates/content/types.d.ts", pkgBase),
+    virtualModTemplate: new URL("templates/content/module.mjs", pkgBase),
+    config: configStats
+  };
+}
+function search(fs, srcDir) {
+  const paths = ["config.mjs", "config.js", "config.mts", "config.ts"].map(
+    (p) => new URL(`./content/${p}`, srcDir)
+  );
+  for (const file of paths) {
+    if (fs.existsSync(file)) {
+      return { exists: true, url: file };
+    }
+  }
+  return { exists: false, url: paths[0] };
+}
+async function getEntrySlug({
+  id,
+  collection,
+  generatedSlug,
+  contentEntryType,
+  fileUrl,
+  fs
+}) {
+  let contents;
+  try {
+    contents = await fs.promises.readFile(fileUrl, "utf-8");
+  } catch (e) {
+    throw new AstroError(AstroErrorData.UnknownContentCollectionError, { cause: e });
+  }
+  const { slug: frontmatterSlug } = await contentEntryType.getEntryInfo({
+    fileUrl,
+    contents
+  });
+  return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
+}
+function getExtGlob(exts) {
+  return exts.length === 1 ? (
+    // Wrapping {...} breaks when there is only one extension
+    exts[0]
+  ) : `{${exts.join(",")}}`;
+}
+function hasAssetPropagationFlag(id) {
+  try {
+    return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);
+  } catch {
+    return false;
+  }
+}
+function posixifyPath(filePath) {
+  return filePath.split(path.sep).join("/");
+}
+function posixRelative(from, to) {
+  return posixifyPath(path.relative(from, to));
+}
+function contentModuleToId(fileName) {
+  const params = new URLSearchParams(DEFERRED_MODULE);
+  params.set("fileName", fileName);
+  params.set(CONTENT_MODULE_FLAG, "true");
+  return `${DEFERRED_MODULE}?${params.toString()}`;
+}
+export {
+  contentModuleToId,
+  contentObservable,
+  getContentEntryExts,
+  getContentEntryIdAndSlug,
+  getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
+  getEntryCollectionName,
+  getEntryConfigByExtMap,
+  getEntryData,
+  getEntryDataAndImages,
+  getEntrySlug,
+  getEntryType,
+  getExtGlob,
+  getSymlinkedContentCollections,
+  globalContentConfigObserver,
+  hasAnyContentFlag,
+  hasAssetPropagationFlag,
+  hasContentFlag,
+  isDeferredModule,
+  parseEntrySlug,
+  posixRelative,
+  posixifyPath,
+  reloadContentConfigObserver,
+  reverseSymlink,
+  safeParseFrontmatter
+};

node_modules/astro/dist/content/vite-plugin-content-assets.d.ts

@@ -0,0 +1,10 @@
+import type { Plugin } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { BuildInternals } from '../core/build/internal.js';
+import type { AstroBuildPlugin } from '../core/build/plugin.js';
+import type { StaticBuildOptions } from '../core/build/types.js';
+export declare function astroContentAssetPropagationPlugin({ mode, settings, }: {
+    mode: string;
+    settings: AstroSettings;
+}): Plugin;
+export declare function astroConfigBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

node_modules/astro/dist/content/vite-plugin-content-assets.js

@@ -0,0 +1,200 @@
+import { extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { getAssetsPrefix } from "../assets/utils/getAssetsPrefix.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { createViteLoader } from "../core/module-loader/vite.js";
+import { joinPaths, prependForwardSlash } from "../core/path.js";
+import { getStylesForURL } from "../vite-plugin-astro-server/css.js";
+import { getScriptsForURL } from "../vite-plugin-astro-server/scripts.js";
+import {
+  CONTENT_IMAGE_FLAG,
+  CONTENT_RENDER_FLAG,
+  LINKS_PLACEHOLDER,
+  PROPAGATED_ASSET_FLAG,
+  SCRIPTS_PLACEHOLDER,
+  STYLES_PLACEHOLDER
+} from "./consts.js";
+import { hasContentFlag } from "./utils.js";
+function astroContentAssetPropagationPlugin({
+  mode,
+  settings
+}) {
+  let devModuleLoader;
+  return {
+    name: "astro:content-asset-propagation",
+    enforce: "pre",
+    async resolveId(id, importer, opts) {
+      if (hasContentFlag(id, CONTENT_IMAGE_FLAG)) {
+        const [base, query] = id.split("?");
+        const params = new URLSearchParams(query);
+        const importerParam = params.get("importer");
+        const importerPath = importerParam ? fileURLToPath(new URL(importerParam, settings.config.root)) : importer;
+        const resolved = this.resolve(base, importerPath, { skipSelf: true, ...opts });
+        if (!resolved) {
+          throw new AstroError({
+            ...AstroErrorData.ImageNotFound,
+            message: AstroErrorData.ImageNotFound.message(base)
+          });
+        }
+        return resolved;
+      }
+      if (hasContentFlag(id, CONTENT_RENDER_FLAG)) {
+        const base = id.split("?")[0];
+        for (const { extensions, handlePropagation = true } of settings.contentEntryTypes) {
+          if (handlePropagation && extensions.includes(extname(base))) {
+            return this.resolve(`${base}?${PROPAGATED_ASSET_FLAG}`, importer, {
+              skipSelf: true,
+              ...opts
+            });
+          }
+        }
+        return this.resolve(base, importer, { skipSelf: true, ...opts });
+      }
+    },
+    configureServer(server) {
+      if (mode === "dev") {
+        devModuleLoader = createViteLoader(server);
+      }
+    },
+    async transform(_, id, options) {
+      if (hasContentFlag(id, PROPAGATED_ASSET_FLAG)) {
+        const basePath = id.split("?")[0];
+        let stringifiedLinks, stringifiedStyles, stringifiedScripts;
+        if (options?.ssr && devModuleLoader) {
+          if (!devModuleLoader.getModuleById(basePath)?.ssrModule) {
+            await devModuleLoader.import(basePath);
+          }
+          const {
+            styles,
+            urls,
+            crawledFiles: styleCrawledFiles
+          } = await getStylesForURL(pathToFileURL(basePath), devModuleLoader);
+          const { scripts: hoistedScripts, crawledFiles: scriptCrawledFiles } = settings.config.experimental.directRenderScript ? { scripts: /* @__PURE__ */ new Set(), crawledFiles: /* @__PURE__ */ new Set() } : await getScriptsForURL(
+            pathToFileURL(basePath),
+            settings.config.root,
+            devModuleLoader
+          );
+          for (const file of styleCrawledFiles) {
+            if (!file.includes("node_modules")) {
+              this.addWatchFile(file);
+            }
+          }
+          for (const file of scriptCrawledFiles) {
+            if (!file.includes("node_modules")) {
+              this.addWatchFile(file);
+            }
+          }
+          stringifiedLinks = JSON.stringify([...urls]);
+          stringifiedStyles = JSON.stringify(styles.map((s) => s.content));
+          stringifiedScripts = JSON.stringify([...hoistedScripts]);
+        } else {
+          stringifiedLinks = JSON.stringify(LINKS_PLACEHOLDER);
+          stringifiedStyles = JSON.stringify(STYLES_PLACEHOLDER);
+          stringifiedScripts = JSON.stringify(SCRIPTS_PLACEHOLDER);
+        }
+        const code = `
+					async function getMod() {
+						return import(${JSON.stringify(basePath)});
+					}
+					const collectedLinks = ${stringifiedLinks};
+					const collectedStyles = ${stringifiedStyles};
+					const collectedScripts = ${stringifiedScripts};
+					const defaultMod = { __astroPropagation: true, getMod, collectedLinks, collectedStyles, collectedScripts };
+					export default defaultMod;
+				`;
+        return { code, map: { mappings: "" } };
+      }
+    }
+  };
+}
+function astroConfigBuildPlugin(options, internals) {
+  return {
+    targets: ["server"],
+    hooks: {
+      "build:post": ({ ssrOutputs, clientOutputs, mutate }) => {
+        const outputs = ssrOutputs.flatMap((o) => o.output);
+        const prependBase = (src) => {
+          const { assetsPrefix } = options.settings.config.build;
+          if (assetsPrefix) {
+            const fileExtension = extname(src);
+            const pf = getAssetsPrefix(fileExtension, assetsPrefix);
+            return joinPaths(pf, src);
+          } else {
+            return prependForwardSlash(joinPaths(options.settings.config.base, src));
+          }
+        };
+        for (const chunk of outputs) {
+          if (chunk.type === "chunk" && (chunk.code.includes(LINKS_PLACEHOLDER) || chunk.code.includes(SCRIPTS_PLACEHOLDER))) {
+            const entryStyles = /* @__PURE__ */ new Set();
+            const entryLinks = /* @__PURE__ */ new Set();
+            const entryScripts = /* @__PURE__ */ new Set();
+            for (const id of chunk.moduleIds) {
+              const _entryCss = internals.propagatedStylesMap.get(id);
+              const _entryScripts = internals.propagatedScriptsMap.get(id);
+              if (_entryCss) {
+                for (const value of _entryCss) {
+                  if (value.type === "inline") entryStyles.add(value.content);
+                  if (value.type === "external") entryLinks.add(value.src);
+                }
+              }
+              if (_entryScripts) {
+                for (const value of _entryScripts) {
+                  entryScripts.add(value);
+                }
+              }
+            }
+            let newCode = chunk.code;
+            if (entryStyles.size) {
+              newCode = newCode.replace(
+                JSON.stringify(STYLES_PLACEHOLDER),
+                JSON.stringify(Array.from(entryStyles))
+              );
+            } else {
+              newCode = newCode.replace(JSON.stringify(STYLES_PLACEHOLDER), "[]");
+            }
+            if (entryLinks.size) {
+              newCode = newCode.replace(
+                JSON.stringify(LINKS_PLACEHOLDER),
+                JSON.stringify(Array.from(entryLinks).map(prependBase))
+              );
+            } else {
+              newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
+            }
+            if (entryScripts.size) {
+              const entryFileNames = /* @__PURE__ */ new Set();
+              for (const output of clientOutputs) {
+                for (const clientChunk of output.output) {
+                  if (clientChunk.type !== "chunk") continue;
+                  for (const [id] of Object.entries(clientChunk.modules)) {
+                    if (entryScripts.has(id)) {
+                      entryFileNames.add(clientChunk.fileName);
+                    }
+                  }
+                }
+              }
+              newCode = newCode.replace(
+                JSON.stringify(SCRIPTS_PLACEHOLDER),
+                JSON.stringify(
+                  [...entryFileNames].map((src) => ({
+                    props: {
+                      src: prependBase(src),
+                      type: "module"
+                    },
+                    children: ""
+                  }))
+                )
+              );
+            } else {
+              newCode = newCode.replace(JSON.stringify(SCRIPTS_PLACEHOLDER), "[]");
+            }
+            mutate(chunk, ["server"], newCode);
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  astroConfigBuildPlugin,
+  astroContentAssetPropagationPlugin
+};

node_modules/astro/dist/content/vite-plugin-content-imports.d.ts

@@ -0,0 +1,9 @@
+import type fsMod from 'node:fs';
+import type { Plugin } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import type { Logger } from '../core/logger/core.js';
+export declare function astroContentImportPlugin({ fs, settings, logger, }: {
+    fs: typeof fsMod;
+    settings: AstroSettings;
+    logger: Logger;
+}): Plugin[];

node_modules/astro/dist/content/vite-plugin-content-imports.js

@@ -0,0 +1,306 @@
+import { extname } from "node:path";
+import { pathToFileURL } from "node:url";
+import * as devalue from "devalue";
+import { getProxyCode } from "../assets/utils/proxy.js";
+import { AstroError } from "../core/errors/errors.js";
+import { AstroErrorData } from "../core/errors/index.js";
+import { isServerLikeOutput } from "../core/util.js";
+import { CONTENT_FLAG, DATA_FLAG } from "./consts.js";
+import {
+  getContentEntryExts,
+  getContentEntryIdAndSlug,
+  getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
+  getEntryCollectionName,
+  getEntryConfigByExtMap,
+  getEntryData,
+  getEntryType,
+  getSymlinkedContentCollections,
+  globalContentConfigObserver,
+  hasContentFlag,
+  parseEntrySlug,
+  reloadContentConfigObserver,
+  reverseSymlink
+} from "./utils.js";
+function getContentRendererByViteId(viteId, settings) {
+  let ext = viteId.split(".").pop();
+  if (!ext) return void 0;
+  for (const contentEntryType of settings.contentEntryTypes) {
+    if (Boolean(contentEntryType.getRenderModule) && contentEntryType.extensions.includes("." + ext)) {
+      return contentEntryType.getRenderModule;
+    }
+  }
+  return void 0;
+}
+const CHOKIDAR_MODIFIED_EVENTS = ["add", "unlink", "change"];
+const COLLECTION_TYPES_TO_INVALIDATE_ON = ["data", "content", "config"];
+function astroContentImportPlugin({
+  fs,
+  settings,
+  logger
+}) {
+  const contentPaths = getContentPaths(settings.config, fs);
+  const contentEntryExts = getContentEntryExts(settings);
+  const dataEntryExts = getDataEntryExts(settings);
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+  const dataEntryConfigByExt = getEntryConfigByExtMap(settings.dataEntryTypes);
+  const { contentDir } = contentPaths;
+  let shouldEmitFile = false;
+  let symlinks;
+  const plugins = [
+    {
+      name: "astro:content-imports",
+      config(_config, env) {
+        shouldEmitFile = env.command === "build";
+      },
+      async buildStart() {
+        symlinks = await getSymlinkedContentCollections({ contentDir, logger, fs });
+      },
+      async transform(_, viteId) {
+        if (hasContentFlag(viteId, DATA_FLAG)) {
+          const fileId = reverseSymlink({
+            entry: viteId.split("?")[0] ?? viteId,
+            contentDir,
+            symlinks
+          });
+          const { id, data, collection, _internal } = await getDataEntryModule({
+            fileId,
+            entryConfigByExt: dataEntryConfigByExt,
+            contentDir,
+            config: settings.config,
+            fs,
+            pluginContext: this,
+            shouldEmitFile
+          });
+          const code = `
+export const id = ${JSON.stringify(id)};
+export const collection = ${JSON.stringify(collection)};
+export const data = ${stringifyEntryData(data, isServerLikeOutput(settings.config))};
+export const _internal = {
+	type: 'data',
+	filePath: ${JSON.stringify(_internal.filePath)},
+	rawData: ${JSON.stringify(_internal.rawData)},
+};
+`;
+          return code;
+        } else if (hasContentFlag(viteId, CONTENT_FLAG)) {
+          const fileId = reverseSymlink({ entry: viteId.split("?")[0], contentDir, symlinks });
+          const { id, slug, collection, body, data, _internal } = await getContentEntryModule({
+            fileId,
+            entryConfigByExt: contentEntryConfigByExt,
+            contentDir,
+            config: settings.config,
+            fs,
+            pluginContext: this,
+            shouldEmitFile
+          });
+          const code = `
+						export const id = ${JSON.stringify(id)};
+						export const collection = ${JSON.stringify(collection)};
+						export const slug = ${JSON.stringify(slug)};
+						export const body = ${JSON.stringify(body)};
+						export const data = ${stringifyEntryData(data, isServerLikeOutput(settings.config))};
+						export const _internal = {
+							type: 'content',
+							filePath: ${JSON.stringify(_internal.filePath)},
+							rawData: ${JSON.stringify(_internal.rawData)},
+						};`;
+          return { code, map: { mappings: "" } };
+        }
+      },
+      configureServer(viteServer) {
+        viteServer.watcher.on("all", async (event, entry) => {
+          if (CHOKIDAR_MODIFIED_EVENTS.includes(event)) {
+            const entryType = getEntryType(entry, contentPaths, contentEntryExts, dataEntryExts);
+            if (!COLLECTION_TYPES_TO_INVALIDATE_ON.includes(entryType)) return;
+            if (entryType === "content" || entryType === "data") {
+              await reloadContentConfigObserver({ fs, settings, viteServer });
+            }
+            for (const modUrl of viteServer.moduleGraph.urlToModuleMap.keys()) {
+              if (hasContentFlag(modUrl, CONTENT_FLAG) || hasContentFlag(modUrl, DATA_FLAG) || Boolean(getContentRendererByViteId(modUrl, settings))) {
+                try {
+                  const mod = await viteServer.moduleGraph.getModuleByUrl(modUrl);
+                  if (mod) {
+                    viteServer.moduleGraph.invalidateModule(mod);
+                  }
+                } catch (e) {
+                  if (e.code === "ERR_CLOSED_SERVER") break;
+                  throw e;
+                }
+              }
+            }
+          }
+        });
+      }
+    }
+  ];
+  if (settings.contentEntryTypes.some((t) => t.getRenderModule)) {
+    plugins.push({
+      name: "astro:content-render-imports",
+      async transform(contents, viteId) {
+        const contentRenderer = getContentRendererByViteId(viteId, settings);
+        if (!contentRenderer) return;
+        const fileId = viteId.split("?")[0];
+        return contentRenderer.bind(this)({ viteId, contents, fileUrl: pathToFileURL(fileId) });
+      }
+    });
+  }
+  return plugins;
+}
+async function getContentEntryModule(params) {
+  const { fileId, contentDir, pluginContext } = params;
+  const { collectionConfig, entryConfig, entry, rawContents, collection } = await getEntryModuleBaseInfo(params);
+  const {
+    rawData,
+    data: unvalidatedData,
+    body,
+    slug: frontmatterSlug
+  } = await entryConfig.getEntryInfo({
+    fileUrl: pathToFileURL(fileId),
+    contents: rawContents
+  });
+  const _internal = { filePath: fileId, rawData };
+  const { id, slug: generatedSlug } = getContentEntryIdAndSlug({ entry, contentDir, collection });
+  const slug = parseEntrySlug({
+    id,
+    collection,
+    generatedSlug,
+    frontmatterSlug
+  });
+  const data = collectionConfig ? await getEntryData(
+    { id, collection, _internal, unvalidatedData },
+    collectionConfig,
+    params.shouldEmitFile,
+    pluginContext
+  ) : unvalidatedData;
+  const contentEntryModule = {
+    id,
+    slug,
+    collection,
+    data,
+    body,
+    _internal
+  };
+  return contentEntryModule;
+}
+async function getDataEntryModule(params) {
+  const { fileId, contentDir, pluginContext } = params;
+  const { collectionConfig, entryConfig, entry, rawContents, collection } = await getEntryModuleBaseInfo(params);
+  const { rawData = "", data: unvalidatedData } = await entryConfig.getEntryInfo({
+    fileUrl: pathToFileURL(fileId),
+    contents: rawContents
+  });
+  const _internal = { filePath: fileId, rawData };
+  const id = getDataEntryId({ entry, contentDir, collection });
+  const data = collectionConfig ? await getEntryData(
+    { id, collection, _internal, unvalidatedData },
+    collectionConfig,
+    params.shouldEmitFile,
+    pluginContext
+  ) : unvalidatedData;
+  const dataEntryModule = {
+    id,
+    collection,
+    data,
+    _internal
+  };
+  return dataEntryModule;
+}
+async function getEntryModuleBaseInfo({
+  fileId,
+  entryConfigByExt,
+  contentDir,
+  fs
+}) {
+  const contentConfig = await getContentConfigFromGlobal();
+  let rawContents;
+  try {
+    rawContents = await fs.promises.readFile(fileId, "utf-8");
+  } catch (e) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `Unexpected error reading entry ${JSON.stringify(fileId)}.`,
+      stack: e instanceof Error ? e.stack : void 0
+    });
+  }
+  const fileExt = extname(fileId);
+  const entryConfig = entryConfigByExt.get(fileExt);
+  if (!entryConfig) {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: `No parser found for data entry ${JSON.stringify(
+        fileId
+      )}. Did you apply an integration for this file type?`
+    });
+  }
+  const entry = pathToFileURL(fileId);
+  const collection = getEntryCollectionName({ entry, contentDir });
+  if (collection === void 0) throw new AstroError(AstroErrorData.UnknownContentCollectionError);
+  const collectionConfig = contentConfig?.collections[collection];
+  return {
+    collectionConfig,
+    entry,
+    entryConfig,
+    collection,
+    rawContents
+  };
+}
+async function getContentConfigFromGlobal() {
+  const observable = globalContentConfigObserver.get();
+  if (observable.status === "init") {
+    throw new AstroError({
+      ...AstroErrorData.UnknownContentCollectionError,
+      message: "Content config failed to load."
+    });
+  }
+  if (observable.status === "error") {
+    throw observable.error;
+  }
+  let contentConfig = observable.status === "loaded" ? observable.config : void 0;
+  if (observable.status === "loading") {
+    contentConfig = await new Promise((resolve) => {
+      const unsubscribe = globalContentConfigObserver.subscribe((ctx) => {
+        if (ctx.status === "loaded") {
+          resolve(ctx.config);
+          unsubscribe();
+        }
+        if (ctx.status === "error") {
+          resolve(void 0);
+          unsubscribe();
+        }
+      });
+    });
+  }
+  return contentConfig;
+}
+function stringifyEntryData(data, isSSR) {
+  try {
+    return devalue.uneval(data, (value) => {
+      if (value instanceof URL) {
+        return `new URL(${JSON.stringify(value.href)})`;
+      }
+      if (typeof value === "object" && "ASTRO_ASSET" in value) {
+        const { ASTRO_ASSET, ...asset } = value;
+        asset.fsPath = ASTRO_ASSET;
+        return getProxyCode(asset, isSSR);
+      }
+    });
+  } catch (e) {
+    if (e instanceof Error) {
+      throw new AstroError({
+        ...AstroErrorData.UnsupportedConfigTransformError,
+        message: AstroErrorData.UnsupportedConfigTransformError.message(e.message),
+        stack: e.stack
+      });
+    } else {
+      throw new AstroError({
+        name: "PluginContentImportsError",
+        message: "Unexpected error processing content collection data."
+      });
+    }
+  }
+}
+export {
+  astroContentImportPlugin
+};

node_modules/astro/dist/content/vite-plugin-content-virtual-mod.d.ts

@@ -0,0 +1,27 @@
+import nodeFs from 'node:fs';
+import type { Plugin } from 'vite';
+import type { AstroSettings } from '../@types/astro.js';
+import { type ContentLookupMap } from './utils.js';
+interface AstroContentVirtualModPluginParams {
+    settings: AstroSettings;
+    fs: typeof nodeFs;
+}
+export declare function astroContentVirtualModPlugin({ settings, fs, }: AstroContentVirtualModPluginParams): Plugin;
+export declare function generateContentEntryFile({ settings, lookupMap, IS_DEV, IS_SERVER, isClient, }: {
+    settings: AstroSettings;
+    fs: typeof nodeFs;
+    lookupMap: ContentLookupMap;
+    IS_DEV: boolean;
+    IS_SERVER: boolean;
+    isClient: boolean;
+}): Promise<string>;
+/**
+ * Generate a map from a collection + slug to the local file path.
+ * This is used internally to resolve entry imports when using `getEntry()`.
+ * @see `templates/content/module.mjs`
+ */
+export declare function generateLookupMap({ settings, fs, }: {
+    settings: AstroSettings;
+    fs: typeof nodeFs;
+}): Promise<ContentLookupMap>;
+export {};

node_modules/astro/dist/content/vite-plugin-content-virtual-mod.js

@@ -0,0 +1,358 @@
+import nodeFs from "node:fs";
+import { extname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { dataToEsm } from "@rollup/pluginutils";
+import glob from "fast-glob";
+import pLimit from "p-limit";
+import { encodeName } from "../core/build/util.js";
+import { AstroError, AstroErrorData } from "../core/errors/index.js";
+import { appendForwardSlash, removeFileExtension } from "../core/path.js";
+import { isServerLikeOutput } from "../core/util.js";
+import { rootRelativePath } from "../core/viteUtils.js";
+import { createDefaultAstroMetadata } from "../vite-plugin-astro/metadata.js";
+import {
+  ASSET_IMPORTS_FILE,
+  ASSET_IMPORTS_RESOLVED_STUB_ID,
+  ASSET_IMPORTS_VIRTUAL_ID,
+  CONTENT_FLAG,
+  CONTENT_RENDER_FLAG,
+  DATA_FLAG,
+  DATA_STORE_VIRTUAL_ID,
+  MODULES_IMPORTS_FILE,
+  MODULES_MJS_ID,
+  MODULES_MJS_VIRTUAL_ID,
+  RESOLVED_DATA_STORE_VIRTUAL_ID,
+  RESOLVED_VIRTUAL_MODULE_ID,
+  VIRTUAL_MODULE_ID
+} from "./consts.js";
+import { getDataStoreFile } from "./content-layer.js";
+import {
+  getContentEntryIdAndSlug,
+  getContentPaths,
+  getDataEntryExts,
+  getDataEntryId,
+  getEntryCollectionName,
+  getEntryConfigByExtMap,
+  getEntrySlug,
+  getEntryType,
+  getExtGlob,
+  isDeferredModule
+} from "./utils.js";
+function astroContentVirtualModPlugin({
+  settings,
+  fs
+}) {
+  let IS_DEV = false;
+  const IS_SERVER = isServerLikeOutput(settings.config);
+  let dataStoreFile;
+  return {
+    name: "astro-content-virtual-mod-plugin",
+    enforce: "pre",
+    configResolved(config) {
+      IS_DEV = config.mode === "development";
+      dataStoreFile = getDataStoreFile(settings, IS_DEV);
+    },
+    async resolveId(id) {
+      if (id === VIRTUAL_MODULE_ID) {
+        if (!settings.config.experimental.contentCollectionCache) {
+          return RESOLVED_VIRTUAL_MODULE_ID;
+        }
+        if (IS_DEV || IS_SERVER) {
+          return RESOLVED_VIRTUAL_MODULE_ID;
+        } else {
+          return { id: RESOLVED_VIRTUAL_MODULE_ID, external: true };
+        }
+      }
+      if (id === DATA_STORE_VIRTUAL_ID) {
+        return RESOLVED_DATA_STORE_VIRTUAL_ID;
+      }
+      if (isDeferredModule(id)) {
+        const [, query] = id.split("?");
+        const params = new URLSearchParams(query);
+        const fileName = params.get("fileName");
+        let importPath = void 0;
+        if (fileName && URL.canParse(fileName, settings.config.root.toString())) {
+          importPath = fileURLToPath(new URL(fileName, settings.config.root));
+        }
+        if (importPath) {
+          return await this.resolve(`${importPath}?${CONTENT_RENDER_FLAG}`);
+        }
+      }
+      if (id === MODULES_MJS_ID) {
+        const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
+        if (fs.existsSync(modules)) {
+          return fileURLToPath(modules);
+        }
+        return MODULES_MJS_VIRTUAL_ID;
+      }
+      if (id === ASSET_IMPORTS_VIRTUAL_ID) {
+        const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
+        if (fs.existsSync(assetImportsFile)) {
+          return fileURLToPath(assetImportsFile);
+        }
+        return ASSET_IMPORTS_RESOLVED_STUB_ID;
+      }
+    },
+    async load(id, args) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
+        const lookupMap = await generateLookupMap({
+          settings,
+          fs
+        });
+        const isClient = !args?.ssr;
+        const code = await generateContentEntryFile({
+          settings,
+          fs,
+          lookupMap,
+          IS_DEV,
+          IS_SERVER,
+          isClient
+        });
+        const astro = createDefaultAstroMetadata();
+        astro.propagation = "in-tree";
+        return {
+          code,
+          meta: {
+            astro
+          }
+        };
+      }
+      if (id === RESOLVED_DATA_STORE_VIRTUAL_ID) {
+        if (!fs.existsSync(dataStoreFile)) {
+          return "export default new Map()";
+        }
+        const jsonData = await fs.promises.readFile(dataStoreFile, "utf-8");
+        try {
+          const parsed = JSON.parse(jsonData);
+          return {
+            code: dataToEsm(parsed, {
+              compact: true
+            }),
+            map: { mappings: "" }
+          };
+        } catch (err) {
+          const message = "Could not parse JSON file";
+          this.error({ message, id, cause: err });
+        }
+      }
+      if (id === ASSET_IMPORTS_RESOLVED_STUB_ID) {
+        const assetImportsFile = new URL(ASSET_IMPORTS_FILE, settings.dotAstroDir);
+        if (!fs.existsSync(assetImportsFile)) {
+          return "export default new Map()";
+        }
+        return fs.readFileSync(assetImportsFile, "utf-8");
+      }
+      if (id === MODULES_MJS_VIRTUAL_ID) {
+        const modules = new URL(MODULES_IMPORTS_FILE, settings.dotAstroDir);
+        if (!fs.existsSync(modules)) {
+          return "export default new Map()";
+        }
+        return fs.readFileSync(modules, "utf-8");
+      }
+    },
+    renderChunk(code, chunk) {
+      if (!settings.config.experimental.contentCollectionCache) {
+        return;
+      }
+      if (code.includes(RESOLVED_VIRTUAL_MODULE_ID)) {
+        const depth = chunk.fileName.split("/").length - 1;
+        const prefix = depth > 0 ? "../".repeat(depth) : "./";
+        return code.replaceAll(RESOLVED_VIRTUAL_MODULE_ID, `${prefix}content/entry.mjs`);
+      }
+    },
+    configureServer(server) {
+      const dataStorePath = fileURLToPath(dataStoreFile);
+      server.watcher.add(dataStorePath);
+      function invalidateDataStore() {
+        const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
+        if (module) {
+          server.moduleGraph.invalidateModule(module);
+        }
+        server.ws.send({
+          type: "full-reload",
+          path: "*"
+        });
+      }
+      server.watcher.on("add", (addedPath) => {
+        if (addedPath === dataStorePath) {
+          invalidateDataStore();
+        }
+      });
+      server.watcher.on("change", (changedPath) => {
+        if (changedPath === dataStorePath) {
+          invalidateDataStore();
+        }
+      });
+    }
+  };
+}
+async function generateContentEntryFile({
+  settings,
+  lookupMap,
+  IS_DEV,
+  IS_SERVER,
+  isClient
+}) {
+  const contentPaths = getContentPaths(settings.config);
+  const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
+  let contentEntryGlobResult;
+  let dataEntryGlobResult;
+  let renderEntryGlobResult;
+  if (IS_DEV || IS_SERVER || !settings.config.experimental.contentCollectionCache) {
+    const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+    const contentEntryExts = [...contentEntryConfigByExt.keys()];
+    const dataEntryExts = getDataEntryExts(settings);
+    const createGlob = (value, flag) => `import.meta.glob(${JSON.stringify(value)}, { query: { ${flag}: true } })`;
+    contentEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
+      CONTENT_FLAG
+    );
+    dataEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, dataEntryExts),
+      DATA_FLAG
+    );
+    renderEntryGlobResult = createGlob(
+      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
+      CONTENT_RENDER_FLAG
+    );
+  } else {
+    contentEntryGlobResult = getStringifiedCollectionFromLookup(
+      "content",
+      relContentDir,
+      lookupMap
+    );
+    dataEntryGlobResult = getStringifiedCollectionFromLookup("data", relContentDir, lookupMap);
+    renderEntryGlobResult = getStringifiedCollectionFromLookup("render", relContentDir, lookupMap);
+  }
+  let virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("'@@CONTENT_ENTRY_GLOB_PATH@@'", contentEntryGlobResult).replace("'@@DATA_ENTRY_GLOB_PATH@@'", dataEntryGlobResult).replace("'@@RENDER_ENTRY_GLOB_PATH@@'", renderEntryGlobResult).replace("/* @@LOOKUP_MAP_ASSIGNMENT@@ */", `lookupMap = ${JSON.stringify(lookupMap)};`) + (isClient ? `
+console.warn('astro:content is only supported running server-side. Using it in the browser will lead to bloated bundles and slow down page load. In the future it will not be supported.');` : "");
+  return virtualModContents;
+}
+function getStringifiedCollectionFromLookup(wantedType, relContentDir, lookupMap) {
+  let str = "{";
+  let normalize = (slug) => slug;
+  if (process.env.NODE_ENV === "production") {
+    const suffix = wantedType === "render" ? ".entry.mjs" : ".mjs";
+    normalize = (slug) => `${removeFileExtension(encodeName(slug)).replace(relContentDir, "./")}${suffix}`;
+  } else {
+    let suffix = "";
+    if (wantedType === "content") suffix = CONTENT_FLAG;
+    else if (wantedType === "data") suffix = DATA_FLAG;
+    else if (wantedType === "render") suffix = CONTENT_RENDER_FLAG;
+    normalize = (slug) => `${slug}?${suffix}`;
+  }
+  for (const { type, entries } of Object.values(lookupMap)) {
+    if (type === wantedType || wantedType === "render" && type === "content") {
+      for (const slug of Object.values(entries)) {
+        str += `
+  "${slug}": () => import("${normalize(slug)}"),`;
+      }
+    }
+  }
+  str += "\n}";
+  return str;
+}
+async function generateLookupMap({
+  settings,
+  fs
+}) {
+  const { root } = settings.config;
+  const contentPaths = getContentPaths(settings.config);
+  const relContentDir = rootRelativePath(root, contentPaths.contentDir, false);
+  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
+  const dataEntryExts = getDataEntryExts(settings);
+  const { contentDir } = contentPaths;
+  const contentEntryExts = [...contentEntryConfigByExt.keys()];
+  let lookupMap = {};
+  const contentGlob = await glob(
+    `${relContentDir}**/*${getExtGlob([...dataEntryExts, ...contentEntryExts])}`,
+    {
+      absolute: true,
+      cwd: fileURLToPath(root),
+      fs
+    }
+  );
+  const limit = pLimit(10);
+  const promises = [];
+  for (const filePath of contentGlob) {
+    promises.push(
+      limit(async () => {
+        const entryType = getEntryType(filePath, contentPaths, contentEntryExts, dataEntryExts);
+        if (entryType !== "content" && entryType !== "data") return;
+        const collection = getEntryCollectionName({ contentDir, entry: pathToFileURL(filePath) });
+        if (!collection) throw UnexpectedLookupMapError;
+        if (lookupMap[collection]?.type && lookupMap[collection].type !== entryType) {
+          throw new AstroError({
+            ...AstroErrorData.MixedContentDataCollectionError,
+            message: AstroErrorData.MixedContentDataCollectionError.message(collection)
+          });
+        }
+        if (entryType === "content") {
+          const contentEntryType = contentEntryConfigByExt.get(extname(filePath));
+          if (!contentEntryType) throw UnexpectedLookupMapError;
+          const { id, slug: generatedSlug } = await getContentEntryIdAndSlug({
+            entry: pathToFileURL(filePath),
+            contentDir,
+            collection
+          });
+          const slug = await getEntrySlug({
+            id,
+            collection,
+            generatedSlug,
+            fs,
+            fileUrl: pathToFileURL(filePath),
+            contentEntryType
+          });
+          if (lookupMap[collection]?.entries?.[slug]) {
+            throw new AstroError({
+              ...AstroErrorData.DuplicateContentEntrySlugError,
+              message: AstroErrorData.DuplicateContentEntrySlugError.message(
+                collection,
+                slug,
+                lookupMap[collection].entries[slug],
+                rootRelativePath(root, filePath)
+              ),
+              hint: slug !== generatedSlug ? `Check the \`slug\` frontmatter property in **${id}**.` : void 0
+            });
+          }
+          lookupMap[collection] = {
+            type: "content",
+            entries: {
+              ...lookupMap[collection]?.entries,
+              [slug]: rootRelativePath(root, filePath)
+            }
+          };
+        } else {
+          const id = getDataEntryId({ entry: pathToFileURL(filePath), contentDir, collection });
+          lookupMap[collection] = {
+            type: "data",
+            entries: {
+              ...lookupMap[collection]?.entries,
+              [id]: rootRelativePath(root, filePath)
+            }
+          };
+        }
+      })
+    );
+  }
+  await Promise.all(promises);
+  return lookupMap;
+}
+function globWithUnderscoresIgnored(relContentDir, exts) {
+  const extGlob = getExtGlob(exts);
+  const contentDir = appendForwardSlash(relContentDir);
+  return [
+    `${contentDir}**/*${extGlob}`,
+    `!${contentDir}**/_*/**/*${extGlob}`,
+    `!${contentDir}**/_*${extGlob}`
+  ];
+}
+const UnexpectedLookupMapError = new AstroError({
+  ...AstroErrorData.UnknownContentCollectionError,
+  message: `Unexpected error while parsing content entry IDs and slugs.`
+});
+export {
+  astroContentVirtualModPlugin,
+  generateContentEntryFile,
+  generateLookupMap
+};