fumadocs-core 15.2.8 → 16.0.3

package/dist/source/index.js

@@ -1,182 +1,285 @@
 import {
+  basename,
+  dirname,
+  extname,
   joinPath,
+  path_exports,
   slash,
   splitPath
-} from "../chunk-XMCPKVJQ.js";
+} from "../chunk-XZSI7AHE.js";
 import {
-  __export
-} from "../chunk-MLKGABMK.js";
+  iconPlugin
+} from "../chunk-FAEPKD7U.js";
+import {
+  normalizeUrl
+} from "../chunk-PFNP6PEB.js";
+import "../chunk-U67V476Y.js";
+
+// src/source/page-tree/transformer-fallback.ts
+function transformerFallback() {
+  const addedFiles = /* @__PURE__ */ new Set();
+  return {
+    root(root) {
+      const isolatedStorage = new FileSystem();
+      for (const file of this.storage.getFiles()) {
+        if (addedFiles.has(file)) continue;
+        const content = this.storage.read(file);
+        if (content) isolatedStorage.write(file, content);
+      }
+      if (isolatedStorage.getFiles().length === 0) return root;
+      root.fallback = this.builder.build(isolatedStorage, {
+        ...this.options,
+        id: `fallback-${root.$id ?? ""}`,
+        generateFallback: false
+      });
+      addedFiles.clear();
+      return root;
+    },
+    file(node, file) {
+      if (file) addedFiles.add(file);
+      return node;
+    },
+    folder(node, _dir, metaPath) {
+      if (metaPath) addedFiles.add(metaPath);
+      return node;
+    }
+  };
+}
 
-// src/source/page-tree-builder.ts
+// src/source/page-tree/builder.ts
 var group = /^\((?<name>.+)\)$/;
 var link = /^(?:\[(?<icon>[^\]]+)])?\[(?<name>[^\]]+)]\((?<url>[^)]+)\)$/;
-var separator = /^---(?:\[(?<icon>[^\]]+)])?(?<name>.+)---$/;
+var separator = /^---(?:\[(?<icon>[^\]]+)])?(?<name>.+)---|^---$/;
 var rest = "...";
 var restReversed = "z...a";
 var extractPrefix = "...";
 var excludePrefix = "!";
-function isPageFile(node) {
-  return "data" in node && node.format === "page";
-}
-function buildAll(nodes, ctx, skipIndex) {
-  const output = [];
+function buildAll(paths, ctx, reversed = false) {
+  const items = [];
   const folders = [];
-  for (const node of [...nodes].sort(
-    (a, b) => a.file.name.localeCompare(b.file.name)
-  )) {
-    if (isPageFile(node)) {
-      const localized = ctx.localeStorage?.read(
-        joinPath(node.file.dirname, node.file.name),
-        "page"
-      );
-      const treeNode = buildFileNode(localized ?? node, ctx);
-      if (node.file.name === "index") {
-        if (!skipIndex) output.unshift(treeNode);
-      } else {
-        output.push(treeNode);
-      }
-    }
-    if ("children" in node) {
-      folders.push(buildFolderNode(node, false, ctx));
+  const sortedPaths = paths.sort(
+    (a, b) => a.localeCompare(b) * (reversed ? -1 : 1)
+  );
+  for (const path of sortedPaths) {
+    ctx.visitedPaths.add(path);
+    const fileNode = buildFileNode(path, ctx);
+    if (fileNode) {
+      if (basename(path, extname(path)) === "index") items.unshift(fileNode);
+      else items.push(fileNode);
+      continue;
     }
+    const dirNode = buildFolderNode(path, false, ctx);
+    if (dirNode) folders.push(dirNode);
   }
-  output.push(...folders);
-  return output;
+  return [...items, ...folders];
 }
-function resolveFolderItem(folder, item, ctx, idx, addedNodePaths) {
+function resolveFolderItem(folderPath, item, ctx, idx) {
   if (item === rest || item === restReversed) return item;
+  const { resolveName } = ctx;
   let match = separator.exec(item);
   if (match?.groups) {
-    const node = {
-      $id: `${folder.file.path}#${idx}`,
+    let node = {
+      $id: `${folderPath}#${idx}`,
       type: "separator",
-      icon: ctx.options.resolveIcon?.(match.groups.icon),
+      icon: match.groups.icon,
       name: match.groups.name
     };
-    return [ctx.options.attachSeparator?.(node) ?? node];
+    for (const transformer of ctx.transformers) {
+      if (!transformer.separator) continue;
+      node = transformer.separator.call(ctx, node);
+    }
+    return [node];
   }
   match = link.exec(item);
   if (match?.groups) {
     const { icon, url, name } = match.groups;
     const isRelative = url.startsWith("/") || url.startsWith("#") || url.startsWith(".");
-    const node = {
+    let node = {
       type: "page",
-      icon: ctx.options.resolveIcon?.(icon),
+      icon,
       name,
       url,
       external: !isRelative
     };
-    return [ctx.options.attachFile?.(node) ?? node];
+    for (const transformer of ctx.transformers) {
+      if (!transformer.file) continue;
+      node = transformer.file.call(ctx, node);
+    }
+    return [node];
   }
-  const isExcept = item.startsWith(excludePrefix), isExtract = item.startsWith(extractPrefix);
+  const isExcept = item.startsWith(excludePrefix);
+  const isExtract = !isExcept && item.startsWith(extractPrefix);
   let filename = item;
   if (isExcept) {
     filename = item.slice(excludePrefix.length);
   } else if (isExtract) {
     filename = item.slice(extractPrefix.length);
   }
-  const path = joinPath(folder.file.path, filename);
-  const itemNode = ctx.storage.readDir(path) ?? ctx.localeStorage?.read(path, "page") ?? ctx.storage.read(path, "page");
-  if (!itemNode) return [];
-  addedNodePaths.add(itemNode.file.path);
+  const path = resolveName(joinPath(folderPath, filename), "page");
+  ctx.visitedPaths.add(path);
   if (isExcept) return [];
-  if ("children" in itemNode) {
-    const node = buildFolderNode(itemNode, false, ctx);
-    return isExtract ? node.children : [node];
+  const dirNode = buildFolderNode(path, false, ctx);
+  if (dirNode) {
+    return isExtract ? dirNode.children : [dirNode];
   }
-  return [buildFileNode(itemNode, ctx)];
+  const fileNode = buildFileNode(path, ctx);
+  return fileNode ? [fileNode] : [];
 }
-function buildFolderNode(folder, isGlobalRoot, ctx) {
-  const metaPath = joinPath(folder.file.path, "meta");
-  const meta = ctx.localeStorage?.read(metaPath, "meta") ?? ctx.storage.read(metaPath, "meta");
-  const indexPath = joinPath(folder.file.path, "index");
-  const indexFile = ctx.localeStorage?.read(indexPath, "page") ?? ctx.storage.read(indexPath, "page");
+function buildFolderNode(folderPath, isGlobalRoot, ctx) {
+  const { storage, options, resolveName, transformers } = ctx;
+  const files = storage.readDir(folderPath);
+  if (!files) return;
+  const metaPath = resolveName(joinPath(folderPath, "meta"), "meta");
+  const indexPath = resolveName(joinPath(folderPath, "index"), "page");
+  let meta = storage.read(metaPath);
+  if (meta?.format !== "meta") {
+    meta = void 0;
+  }
   const isRoot = meta?.data.root ?? isGlobalRoot;
-  const index = indexFile ? buildFileNode(indexFile, ctx) : void 0;
-  const addedNodePaths = /* @__PURE__ */ new Set();
+  let index;
   let children;
-  if (!meta?.data.pages) {
-    children = buildAll(folder.children, ctx, !isRoot);
+  function setIndexIfUnused() {
+    if (isRoot || ctx.visitedPaths.has(indexPath)) return;
+    ctx.visitedPaths.add(indexPath);
+    index = buildFileNode(indexPath, ctx);
+  }
+  if (meta && meta.data.pages) {
+    const resolved = meta.data.pages.flatMap((item, i) => resolveFolderItem(folderPath, item, ctx, i));
+    setIndexIfUnused();
+    for (let i = 0; i < resolved.length; i++) {
+      const item = resolved[i];
+      if (item !== rest && item !== restReversed) continue;
+      const items = buildAll(
+        files.filter((file) => !ctx.visitedPaths.has(file)),
+        ctx,
+        item === restReversed
+      );
+      resolved.splice(i, 1, ...items);
+      break;
+    }
+    children = resolved;
   } else {
-    const resolved = meta.data.pages.flatMap((item, i) => {
-      return resolveFolderItem(folder, item, ctx, i, addedNodePaths);
-    });
-    const restNodes = buildAll(
-      folder.children.filter((node2) => !addedNodePaths.has(node2.file.path)),
-      ctx,
-      !isRoot
+    setIndexIfUnused();
+    children = buildAll(
+      files.filter((file) => !ctx.visitedPaths.has(file)),
+      ctx
     );
-    const nodes = resolved?.flatMap((item) => {
-      if (item === rest) {
-        return restNodes;
-      } else if (item === restReversed) {
-        return restNodes.reverse();
-      }
-      return item;
-    });
-    children = nodes ?? restNodes;
   }
-  const node = {
+  let name = meta?.data.title ?? index?.name;
+  if (!name) {
+    const folderName = basename(folderPath);
+    name = pathToName(group.exec(folderName)?.[1] ?? folderName);
+  }
+  let node = {
     type: "folder",
-    name: meta?.data.title ?? index?.name ?? // resolve folder groups like (group_name)
-    pathToName(group.exec(folder.file.name)?.[1] ?? folder.file.name),
-    icon: ctx.options.resolveIcon?.(meta?.data.icon) ?? index?.icon,
+    name,
+    icon: meta?.data.icon ?? index?.icon,
     root: meta?.data.root,
     defaultOpen: meta?.data.defaultOpen,
     description: meta?.data.description,
-    index: isRoot || indexFile && !addedNodePaths.has(indexFile.file.path) ? index : void 0,
+    index,
     children,
-    $id: folder.file.path,
-    $ref: !ctx.options.noRef ? {
-      metaFile: meta?.file.path
+    $id: folderPath,
+    $ref: !options.noRef && meta ? {
+      metaFile: metaPath
     } : void 0
   };
-  return ctx.options.attachFolder?.(node, folder, meta) ?? node;
+  for (const transformer of transformers) {
+    if (!transformer.folder) continue;
+    node = transformer.folder.call(ctx, node, folderPath, metaPath);
+  }
+  return node;
 }
-function buildFileNode(file, ctx) {
-  const item = {
-    $id: file.file.path,
+function buildFileNode(path, ctx) {
+  const { options, getUrl, storage, locale, transformers } = ctx;
+  const page = storage.read(path);
+  if (page?.format !== "page") return;
+  const { title, description, icon } = page.data;
+  let item = {
+    $id: path,
     type: "page",
-    name: file.data.data.title ?? pathToName(file.file.name),
-    description: file.data.data.description,
-    icon: ctx.options.resolveIcon?.(file.data.data.icon),
-    url: ctx.options.getUrl(file.data.slugs, ctx.locale),
-    $ref: !ctx.options.noRef ? {
-      file: file.file.path
+    name: title ?? pathToName(basename(path, extname(path))),
+    description,
+    icon,
+    url: getUrl(page.slugs, locale),
+    $ref: !options.noRef ? {
+      file: path
     } : void 0
   };
-  return ctx.options.attachFile?.(item, file) ?? item;
+  for (const transformer of transformers) {
+    if (!transformer.file) continue;
+    item = transformer.file.call(ctx, item, path);
+  }
+  return item;
 }
-function build(ctx) {
-  const root = ctx.storage.root();
-  const folder = buildFolderNode(root, true, ctx);
-  return {
-    $id: ctx.locale ? ctx.locale : "root",
-    name: folder.name,
+function build(id, ctx) {
+  const folder = buildFolderNode("", true, ctx);
+  let root = {
+    $id: id,
+    name: folder.name || "Docs",
     children: folder.children
   };
+  for (const transformer of ctx.transformers) {
+    if (!transformer.root) continue;
+    root = transformer.root.call(ctx, root);
+  }
+  return root;
 }
-function createPageTreeBuilder() {
+function createPageTreeBuilder(getUrl, plugins) {
+  function getTransformers({
+    generateFallback = true,
+    ...options
+  }) {
+    const transformers = [];
+    if (options.transformers) {
+      transformers.push(...options.transformers);
+    }
+    for (const plugin of plugins ?? []) {
+      if (plugin.transformPageTree) transformers.push(plugin.transformPageTree);
+    }
+    if (generateFallback) {
+      transformers.push(transformerFallback());
+    }
+    return transformers;
+  }
+  function createFlattenPathResolver(storage) {
+    const map2 = /* @__PURE__ */ new Map();
+    const files = storage.getFiles();
+    for (const file of files) {
+      const content = storage.read(file);
+      const flattenPath = file.substring(0, file.length - extname(file).length);
+      map2.set(flattenPath + "." + content.format, file);
+    }
+    return (name, format) => {
+      return map2.get(name + "." + format);
+    };
+  }
   return {
-    build(options) {
-      return build({
-        options,
-        builder: this,
-        storage: options.storage
-      });
+    build(storage, options) {
+      const key = "";
+      return this.buildI18n({ [key]: storage }, options)[key];
     },
-    buildI18n({ i18n, ...options }) {
-      const entries = i18n.languages.map((lang) => {
-        const tree = build({
-          options,
+    buildI18n(storages, options = {}) {
+      const transformers = getTransformers(options);
+      const out = {};
+      for (const [locale, storage] of Object.entries(storages)) {
+        const resolve = createFlattenPathResolver(storage);
+        const branch = locale.length === 0 ? "root" : locale;
+        out[locale] = build(options.id ? `${options.id}-${branch}` : branch, {
+          transformers,
           builder: this,
-          locale: lang,
-          storage: options.storages[i18n.defaultLanguage],
-          localeStorage: options.storages[lang]
+          options,
+          getUrl,
+          locale,
+          storage,
+          storages,
+          visitedPaths: /* @__PURE__ */ new Set(),
+          resolveName(name, format) {
+            return resolve(name, format) ?? name;
+          }
         });
-        return [lang, tree];
-      });
-      return Object.fromEntries(entries);
+      }
+      return out;
     }
   };
 }
@@ -190,196 +293,226 @@ function pathToName(name) {
   return result.join("");
 }
 
-// src/source/path.ts
-function parseFilePath(path) {
-  const segments = splitPath(slash(path));
-  const dirname = segments.slice(0, -1).join("/");
-  let name = segments.at(-1) ?? "";
-  let ext = "";
-  const dotIdx = name.lastIndexOf(".");
-  if (dotIdx !== -1) {
-    ext = name.substring(dotIdx);
-    name = name.substring(0, dotIdx);
-  }
-  return {
-    dirname,
-    name,
-    path: segments.join("/"),
-    ext,
-    flattenedPath: [dirname, name].filter((p) => p.length > 0).join("/")
-  };
-}
-function parseFolderPath(path) {
-  const segments = splitPath(slash(path));
-  const base = segments.at(-1) ?? "";
-  return {
-    dirname: segments.slice(0, -1).join("/"),
-    name: base,
-    path: segments.join("/")
-  };
-}
-function normalizePath(path) {
-  const segments = splitPath(slash(path));
-  if (segments[0] === "." || segments[0] === "..")
-    throw new Error("It must not start with './' or '../'");
-  return segments.join("/");
-}
-
-// src/source/file-system.ts
-var file_system_exports = {};
-__export(file_system_exports, {
-  Storage: () => Storage
-});
-var Storage = class {
-  constructor() {
+// src/source/storage/file-system.ts
+var FileSystem = class {
+  constructor(inherit) {
     this.files = /* @__PURE__ */ new Map();
     this.folders = /* @__PURE__ */ new Map();
-    this.rootFolder = {
-      file: parseFolderPath(""),
-      children: []
-    };
-    this.folders.set("", this.rootFolder);
+    if (inherit) {
+      for (const [k, v] of inherit.folders) {
+        this.folders.set(k, v);
+      }
+      for (const [k, v] of inherit.files) {
+        this.files.set(k, v);
+      }
+    } else {
+      this.folders.set("", []);
+    }
+  }
+  read(path) {
+    return this.files.get(path);
   }
   /**
-   * @param path - flattened path
-   * @param format - file format
+   * get the direct children of folder (in virtual file path)
    */
-  read(path, format) {
-    return this.files.get(`${path}.${format}`);
-  }
   readDir(path) {
     return this.folders.get(path);
   }
-  root() {
-    return this.rootFolder;
+  write(path, file) {
+    if (!this.files.has(path)) {
+      const dir = dirname(path);
+      this.makeDir(dir);
+      this.readDir(dir)?.push(path);
+    }
+    this.files.set(path, file);
   }
-  write(path, format, data) {
-    const node = {
-      format,
-      file: parseFilePath(path),
-      data
-    };
-    this.makeDir(node.file.dirname);
-    this.readDir(node.file.dirname)?.children.push(node);
-    this.files.set(
-      joinPath(node.file.dirname, `${node.file.name}.${node.format}`),
-      node
-    );
+  /**
+   * Delete files at specified path.
+   *
+   * @param path - the target path.
+   * @param [recursive=false] - if set to `true`, it will also delete directories.
+   */
+  delete(path, recursive = false) {
+    if (this.files.delete(path)) return true;
+    if (recursive) {
+      const folder = this.folders.get(path);
+      if (!folder) return false;
+      this.folders.delete(path);
+      for (const child of folder) {
+        this.delete(child);
+      }
+      return true;
+    }
+    return false;
   }
-  list() {
-    return [...this.files.values()];
+  getFiles() {
+    return Array.from(this.files.keys());
   }
   makeDir(path) {
     const segments = splitPath(path);
     for (let i = 0; i < segments.length; i++) {
       const segment = segments.slice(0, i + 1).join("/");
       if (this.folders.has(segment)) continue;
-      const folder = {
-        file: parseFolderPath(segment),
-        children: []
-      };
-      this.folders.set(folder.file.path, folder);
-      this.readDir(folder.file.dirname)?.children.push(folder);
+      this.folders.set(segment, []);
+      this.folders.get(dirname(segment)).push(segment);
     }
   }
 };
 
-// src/source/load-files.ts
-function loadFiles(files, options) {
-  const { transformers = [] } = options;
-  const storage = new Storage();
-  for (const file of files) {
-    const parsedPath = normalizePath(file.path);
-    if (file.type === "page") {
-      const slugs = file.slugs ?? options.getSlugs(parseFilePath(parsedPath));
-      storage.write(parsedPath, file.type, {
-        slugs,
-        data: file.data
-      });
-    }
-    if (file.type === "meta") {
-      storage.write(parsedPath, file.type, file.data);
-    }
-  }
-  for (const transformer of transformers) {
-    transformer({
-      storage,
-      options
-    });
-  }
-  return storage;
+// src/source/storage/content.ts
+function isLocaleValid(locale) {
+  return locale.length > 0 && !/\d+/.test(locale);
 }
-function loadFilesI18n(files, options) {
-  const parser = options.i18n.parser === "dir" ? dirParser : dotParser;
+var parsers = {
+  dir(path) {
+    const [locale, ...segs] = path.split("/");
+    if (locale && segs.length > 0 && isLocaleValid(locale))
+      return [segs.join("/"), locale];
+    return [path];
+  },
+  dot(path) {
+    const dir = dirname(path);
+    const base = basename(path);
+    const parts = base.split(".");
+    if (parts.length < 3) return [path];
+    const [locale] = parts.splice(parts.length - 2, 1);
+    if (!isLocaleValid(locale)) return [path];
+    return [joinPath(dir, parts.join(".")), locale];
+  },
+  none(path) {
+    return [path];
+  }
+};
+function buildContentStorage(files, buildFile, plugins, i18n) {
+  const parser = parsers[i18n.parser ?? "dot"];
   const storages = {};
-  for (const lang of options.i18n.languages) {
-    storages[lang] = loadFiles(
-      files.flatMap((file) => {
-        const [path, locale] = parser(normalizePath(file.path));
-        if ((locale ?? options.i18n.defaultLanguage) === lang) {
-          return {
-            ...file,
-            path
-          };
-        }
-        return [];
-      }),
-      options
-    );
+  const normalized = files.map(
+    (file) => buildFile({
+      ...file,
+      path: normalizePath(file.path)
+    })
+  );
+  const fallbackLang = i18n.fallbackLanguage !== null ? i18n.fallbackLanguage ?? i18n.defaultLanguage : null;
+  function scan(lang) {
+    if (storages[lang]) return;
+    let storage;
+    if (fallbackLang && fallbackLang !== lang) {
+      scan(fallbackLang);
+      storage = new FileSystem(storages[fallbackLang]);
+    } else {
+      storage = new FileSystem();
+    }
+    for (const item of normalized) {
+      const [path, locale = i18n.defaultLanguage] = parser(item.path);
+      if (locale === lang) storage.write(path, item);
+    }
+    const context = {
+      storage
+    };
+    for (const plugin of plugins) {
+      plugin.transformStorage?.(context);
+    }
+    storages[lang] = storage;
   }
+  for (const lang of i18n.languages) scan(lang);
   return storages;
 }
-function dirParser(path) {
-  const parsed = path.split("/");
-  if (parsed.length >= 2) return [parsed.slice(1).join("/"), parsed[0]];
-  return [path];
+function normalizePath(path) {
+  const segments = splitPath(slash(path));
+  if (segments[0] === "." || segments[0] === "..")
+    throw new Error("It must not start with './' or '../'");
+  return segments.join("/");
 }
-function dotParser(path) {
-  const segs = path.split("/");
-  if (segs.length === 0) return [path];
-  const name = segs[segs.length - 1].split(".");
-  if (name.length >= 3) {
-    const locale = name.splice(name.length - 2, 1)[0];
-    if (locale.length > 0 && !/\d+/.test(locale)) {
-      segs[segs.length - 1] = name.join(".");
-      return [segs.join("/"), locale];
-    }
+
+// src/source/plugins/index.ts
+var priorityMap = {
+  pre: 1,
+  default: 0,
+  post: -1
+};
+function buildPlugins(plugins) {
+  const flatten = [];
+  for (const plugin of plugins) {
+    if (Array.isArray(plugin)) flatten.push(...plugin);
+    else if (plugin) flatten.push(plugin);
   }
-  return [path];
+  return flatten.sort(
+    (a, b) => priorityMap[b.enforce ?? "default"] - priorityMap[a.enforce ?? "default"]
+  );
 }
 
-// src/source/loader.ts
-function indexPages(storages, getUrl, i18n) {
-  const defaultLanguage = i18n?.defaultLanguage ?? "";
-  const map = /* @__PURE__ */ new Map();
-  const fileMapped = /* @__PURE__ */ new WeakMap();
-  for (const item of storages[defaultLanguage].list()) {
-    if (item.format === "meta") {
-      fileMapped.set(item, fileToMeta(item));
-    }
-    if (item.format === "page") {
-      const page = fileToPage(item, getUrl, defaultLanguage);
-      fileMapped.set(item, page);
-      map.set(`${defaultLanguage}.${page.slugs.join("/")}`, page);
-      if (!i18n) continue;
-      const path = joinPath(item.file.dirname, item.file.name);
-      for (const lang of i18n.languages) {
-        if (lang === defaultLanguage) continue;
-        const localizedItem = storages[lang].read(path, "page");
-        const localizedPage = fileToPage(localizedItem ?? item, getUrl, lang);
-        if (localizedItem) {
-          fileMapped.set(localizedItem, localizedPage);
+// src/source/plugins/slugs.ts
+function slugsPlugin(slugsFn) {
+  function isIndex(file) {
+    return basename(file, extname(file)) === "index";
+  }
+  return {
+    name: "fumadocs:slugs",
+    transformStorage({ storage }) {
+      const indexFiles = /* @__PURE__ */ new Set();
+      const taken = /* @__PURE__ */ new Set();
+      const autoIndex = slugsFn === void 0;
+      for (const path of storage.getFiles()) {
+        const file = storage.read(path);
+        if (!file || file.format !== "page" || file.slugs) continue;
+        if (isIndex(path) && autoIndex) {
+          indexFiles.add(path);
+          continue;
         }
-        map.set(`${lang}.${localizedPage.slugs.join("/")}`, localizedPage);
+        file.slugs = slugsFn ? slugsFn({ path }) : getSlugs(path);
+        const key = file.slugs.join("/");
+        if (taken.has(key)) throw new Error("Duplicated slugs");
+        taken.add(key);
+      }
+      for (const path of indexFiles) {
+        const file = storage.read(path);
+        if (file?.format !== "page") continue;
+        file.slugs = getSlugs(path);
+        if (taken.has(file.slugs.join("/"))) file.slugs.push("index");
       }
     }
+  };
+}
+var GroupRegex = /^\(.+\)$/;
+function getSlugs(file) {
+  const dir = dirname(file);
+  const name = basename(file, extname(file));
+  const slugs = [];
+  for (const seg of dir.split("/")) {
+    if (seg.length > 0 && !GroupRegex.test(seg)) slugs.push(encodeURI(seg));
   }
-  return {
-    pages: map,
-    getResultFromFile(file) {
-      return fileMapped.get(file);
-    }
+  if (GroupRegex.test(name))
+    throw new Error(`Cannot use folder group in file names: ${file}`);
+  if (name !== "index") {
+    slugs.push(encodeURI(name));
+  }
+  return slugs;
+}
+
+// src/source/loader.ts
+function indexPages(storages, getUrl) {
+  const result = {
+    // (locale.slugs -> page)
+    pages: /* @__PURE__ */ new Map(),
+    // (locale.path -> page)
+    pathToMeta: /* @__PURE__ */ new Map(),
+    // (locale.path -> meta)
+    pathToPage: /* @__PURE__ */ new Map()
   };
+  for (const [lang, storage] of Object.entries(storages)) {
+    for (const filePath of storage.getFiles()) {
+      const item = storage.read(filePath);
+      const path = `${lang}.${filePath}`;
+      if (item.format === "meta") {
+        result.pathToMeta.set(path, fileToMeta(item));
+        continue;
+      }
+      const page = fileToPage(item, getUrl, lang);
+      result.pathToPage.set(path, page);
+      result.pages.set(`${lang}.${page.slugs.join("/")}`, page);
+    }
+  }
+  return result;
 }
 function createGetUrl(baseUrl, i18n) {
   const baseSlugs = baseUrl.split("/");
@@ -396,95 +529,108 @@ function createGetUrl(baseUrl, i18n) {
     return `/${paths.filter((v) => v.length > 0).join("/")}`;
   };
 }
-function getSlugs(info) {
-  return [...info.dirname.split("/"), info.name].filter(
-    // filter empty folder names and file groups like (group_name)
-    (v, i, arr) => {
-      if (v.length === 0) return false;
-      return i === arr.length - 1 ? v !== "index" : !/^\(.+\)$/.test(v);
-    }
-  );
+function loader(...args) {
+  const resolved = args.length === 2 ? resolveConfig(args[0], args[1]) : resolveConfig(args[0].source, args[0]);
+  return createOutput(resolved);
 }
-function loader(options) {
-  return createOutput(options);
-}
-function createOutput(options) {
-  if (!options.url && !options.baseUrl) {
-    console.warn("`loader()` now requires a `baseUrl` option to be defined.");
+function resolveConfig(source, { slugs, icon, plugins = [], baseUrl, url, ...base }) {
+  const getUrl = url ? (...args) => normalizeUrl(url(...args)) : createGetUrl(baseUrl, base.i18n);
+  let config = {
+    ...base,
+    url: getUrl,
+    source,
+    plugins: buildPlugins([
+      slugsPlugin(slugs),
+      icon && iconPlugin(icon),
+      ...plugins
+    ])
+  };
+  for (const plugin of config.plugins ?? []) {
+    const result = plugin.config?.(config);
+    if (result) config = result;
   }
-  const { source, slugs: slugsFn = getSlugs } = options;
-  const getUrl = options.url ?? createGetUrl(options.baseUrl ?? "/", options.i18n);
-  const files = typeof source.files === "function" ? source.files() : source.files;
-  const storages = options.i18n ? loadFilesI18n(files, {
-    i18n: {
-      ...options.i18n,
-      parser: options.i18n.parser ?? "dot"
+  return config;
+}
+function createOutput({
+  source: { files },
+  url: getUrl,
+  i18n,
+  plugins = [],
+  pageTree: pageTreeConfig
+}) {
+  const defaultLanguage = i18n?.defaultLanguage ?? "";
+  const storages = buildContentStorage(
+    files,
+    (file) => {
+      if (file.type === "page") {
+        return {
+          format: "page",
+          path: file.path,
+          slugs: file.slugs,
+          data: file.data,
+          absolutePath: file.absolutePath ?? ""
+        };
+      }
+      return {
+        format: "meta",
+        path: file.path,
+        absolutePath: file.absolutePath ?? "",
+        data: file.data
+      };
     },
-    transformers: options.transformers,
-    getSlugs: slugsFn
-  }) : {
-    "": loadFiles(files, {
-      transformers: options.transformers,
-      getSlugs: slugsFn
-    })
-  };
-  const walker = indexPages(storages, getUrl, options.i18n);
-  const builder = createPageTreeBuilder();
+    plugins,
+    i18n ?? {
+      defaultLanguage,
+      parser: "none",
+      languages: [defaultLanguage]
+    }
+  );
+  const walker = indexPages(storages, getUrl);
+  const builder = createPageTreeBuilder(getUrl, plugins);
   let pageTree;
   return {
-    _i18n: options.i18n,
+    _i18n: i18n,
     get pageTree() {
-      if (options.i18n) {
-        pageTree ??= builder.buildI18n({
-          storages,
-          resolveIcon: options.icon,
-          getUrl,
-          i18n: options.i18n,
-          ...options.pageTree
-        });
-      } else {
-        pageTree ??= builder.build({
-          storage: storages[""],
-          resolveIcon: options.icon,
-          getUrl,
-          ...options.pageTree
-        });
-      }
-      return pageTree;
+      pageTree ??= builder.buildI18n(storages, pageTreeConfig);
+      return i18n ? pageTree : pageTree[defaultLanguage];
     },
     set pageTree(v) {
-      pageTree = v;
+      if (i18n) {
+        pageTree = v;
+      } else {
+        pageTree = {
+          [defaultLanguage]: v
+        };
+      }
     },
-    getPageByHref(href, { dir = "" } = {}) {
-      const pages = Array.from(walker.pages.values());
+    getPageByHref(href, { dir = "", language = defaultLanguage } = {}) {
       const [value, hash] = href.split("#", 2);
+      let target;
       if (value.startsWith(".") && (value.endsWith(".md") || value.endsWith(".mdx"))) {
-        const hrefPath = joinPath(dir, value);
-        const target2 = pages.find((item) => item.file.path === hrefPath);
-        if (target2)
-          return {
-            page: target2,
-            hash
-          };
+        const path = joinPath(dir, value);
+        target = walker.pathToPage.get(`${language}.${path}`);
+      } else {
+        target = this.getPages(language).find((item) => item.url === value);
       }
-      const target = pages.find((item) => item.url === value);
       if (target)
         return {
           page: target,
           hash
         };
     },
-    getPages(language = options.i18n?.defaultLanguage ?? "") {
+    getPages(language) {
       const pages = [];
-      for (const key of walker.pages.keys()) {
-        if (key.startsWith(`${language}.`)) pages.push(walker.pages.get(key));
+      for (const [key, value] of walker.pages.entries()) {
+        if (language === void 0 || key.startsWith(`${language}.`)) {
+          pages.push(value);
+        }
       }
       return pages;
     },
     getLanguages() {
       const list = [];
-      if (!options.i18n) return list;
-      for (const language of options.i18n.languages) {
+      if (!i18n) return list;
+      for (const language of i18n.languages) {
         list.push({
           language,
           pages: this.getPages(language)
@@ -492,30 +638,28 @@ function createOutput(options) {
       }
       return list;
     },
-    getPage(slugs = [], language = options.i18n?.defaultLanguage ?? "") {
+    getPage(slugs = [], language = defaultLanguage) {
       return walker.pages.get(`${language}.${slugs.join("/")}`);
     },
-    getNodeMeta(node, language = options.i18n?.defaultLanguage ?? "") {
+    getNodeMeta(node, language = defaultLanguage) {
       const ref = node.$ref?.metaFile;
       if (!ref) return;
-      const file = storages[language].list().find((v) => v.format === "meta" && v.file.path === ref);
-      if (file) return walker.getResultFromFile(file);
+      return walker.pathToMeta.get(`${language}.${ref}`);
     },
-    getNodePage(node, language = options.i18n?.defaultLanguage ?? "") {
+    getNodePage(node, language = defaultLanguage) {
       const ref = node.$ref?.file;
       if (!ref) return;
-      const file = storages[language].list().find((v) => v.format === "page" && v.file.path === ref);
-      if (file) return walker.getResultFromFile(file);
+      return walker.pathToPage.get(`${language}.${ref}`);
     },
     getPageTree(locale) {
-      if (options.i18n) {
-        return this.pageTree[locale ?? options.i18n.defaultLanguage];
+      if (i18n) {
+        return this.pageTree[locale ?? defaultLanguage];
       }
       return this.pageTree;
     },
     // @ts-expect-error -- ignore this
     generateParams(slug, lang) {
-      if (options.i18n) {
+      if (i18n) {
         return this.getLanguages().flatMap(
           (entry) => entry.pages.map((page) => ({
             [slug ?? "slug"]: page.slugs,
@@ -531,26 +675,61 @@ function createOutput(options) {
 }
 function fileToMeta(file) {
   return {
-    file: file.file,
+    path: file.path,
+    absolutePath: file.absolutePath,
     data: file.data
   };
 }
 function fileToPage(file, getUrl, locale) {
   return {
-    file: file.file,
-    url: getUrl(file.data.slugs, locale),
-    slugs: file.data.slugs,
-    data: file.data.data,
+    absolutePath: file.absolutePath,
+    path: file.path,
+    url: getUrl(file.slugs, locale),
+    slugs: file.slugs,
+    data: file.data,
     locale
   };
 }
+function multiple(sources) {
+  const out = { files: [] };
+  for (const [type, source] of Object.entries(sources)) {
+    for (const file of source.files) {
+      out.files.push({
+        ...file,
+        data: {
+          ...file.data,
+          type
+        }
+      });
+    }
+  }
+  return out;
+}
+function map(source) {
+  return {
+    page(fn) {
+      return {
+        files: source.files.map(
+          (file) => file.type === "page" ? fn(file) : file
+        )
+      };
+    },
+    meta(fn) {
+      return {
+        files: source.files.map(
+          (file) => file.type === "meta" ? fn(file) : file
+        )
+      };
+    }
+  };
+}
 export {
-  file_system_exports as FileSystem,
+  FileSystem,
+  path_exports as PathUtils,
   createGetUrl,
   createPageTreeBuilder,
   getSlugs,
-  loadFiles,
   loader,
-  parseFilePath,
-  parseFolderPath
+  map,
+  multiple
 };