fumadocs-core 16.17.1 → 16.17.3

package/dist/{dynamic-Ce3F5rPi.js → dynamic-CsxXgQ9d.js}

@@ -11,12 +11,10 @@ import { cache } from "react";
 */
 var FileSystem = class {
 	constructor(inherit) {
-		this.files = /* @__PURE__ */ new Map();
 		this.folders = /* @__PURE__ */ new Map();
-		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("", []);
+		this.files = new Map(inherit?.files);
+		if (inherit) for (const [k, v] of inherit.folders) this.folders.set(k, [...v]);
+		else this.folders.set("", []);
 	}
 	read(path) {
 		return this.files.get(path);
@@ -56,6 +54,7 @@ var FileSystem = class {
 		return Array.from(this.files.keys());
 	}
 	makeDir(path) {
+		if (this.folders.has(path)) return;
 		const cur = [];
 		let parentPath = "";
 		for (const seg of path.split("/")) {
@@ -129,29 +128,26 @@ const EmptyLang = Symbol();
 */
 function createContentStorageBuilder(loaderConfig) {
 	const { input, plugins, i18n } = loaderConfig;
-	let parser;
-	if (!i18n) parser = (path) => [path];
-	else if (i18n.parser === "dir") {
+	let parser = (path) => [path];
+	if (i18n) {
 		const langSet = new Set(i18n.languages);
 		parser = (path) => {
-			const [locale, ...segs] = path.split("/");
-			if (!locale || segs.length === 0) return [path];
-			if (langSet.has(locale)) return [segs.join("/"), locale];
-			if (locale === "$") return [segs.join("/"), i18n.languages];
-			return [path];
-		};
-	} else {
-		const langSet = new Set(i18n.languages);
-		parser = (path) => {
-			const segs = path.split("/");
-			const base = segs.pop();
-			if (!base) return [path];
-			const parts = base.split(".");
-			if (parts.length < 3) return [path];
-			const [locale] = parts.splice(parts.length - 2, 1);
-			segs.push(parts.join("."));
-			if (langSet.has(locale)) return [segs.join("/"), locale];
-			if (locale === "$") return [segs.join("/"), i18n.languages];
+			let locale;
+			let rest;
+			if (i18n.parser === "dir") {
+				const slash = path.indexOf("/");
+				if (slash <= 0) return [path];
+				locale = path.slice(0, slash);
+				rest = path.slice(slash + 1);
+			} else {
+				const ext = path.lastIndexOf(".");
+				const dot = path.lastIndexOf(".", ext - 1);
+				if (dot === -1 || dot < path.lastIndexOf("/")) return [path];
+				locale = path.slice(dot + 1, ext);
+				rest = path.slice(0, dot) + path.slice(ext);
+			}
+			if (langSet.has(locale)) return [rest, locale];
+			if (locale === "$") return [rest, i18n.languages];
 			return [path];
 		};
 	}
@@ -216,371 +212,266 @@ function pushMapList(map, k, v) {
 	list.push(v);
 }
 //#endregion
-//#region src/source/page-tree/transformer-fallback.ts
-function transformerFallback() {
-	const addedFiles = /* @__PURE__ */ new Set();
-	function shouldIgnore(context) {
-		return context.custom?._fallback === true;
-	}
-	return {
-		root(root) {
-			if (shouldIgnore(this)) return root;
-			const isolatedStorage = new FileSystem();
-			if (addedFiles.size === this.storage.files.size) return root;
-			for (const file of this.storage.getFiles()) {
-				if (addedFiles.has(file)) continue;
-				isolatedStorage.write(file, this.storage.read(file));
-			}
-			root.fallback = createPageTreeBuilder(isolatedStorage, {
-				...this.options,
-				idPrefix: this.options.idPrefix ? `fallback:${this.options.idPrefix}` : "fallback",
-				generateFallback: false,
-				context: {
-					...this.custom,
-					_fallback: true
-				}
-			}).root();
-			addedFiles.clear();
-			return root;
-		},
-		file(node, file) {
-			if (shouldIgnore(this)) return node;
-			if (file) addedFiles.add(file);
-			return node;
-		},
-		folder(node, _dir, metaPath) {
-			if (shouldIgnore(this)) return node;
-			if (metaPath) addedFiles.add(metaPath);
-			return node;
-		}
-	};
-}
-//#endregion
 //#region src/source/page-tree/builder.ts
 const group = /^\((?<name>.+)\)$/;
 const link = /^(?<external>external:)?(?:\[(?<icon>[^\]]+)])?\[(?<name>[^\]]+)]\((?<url>[^)]+)\)$/;
 const separator = /^---(?:\[(?<icon>[^\]]+)])?(?<name>.+)---|^---$/;
-const rest = "...";
-const restReversed = "z...a";
-const extractPrefix = "...";
-const excludePrefix = "!";
-const SymbolUnfinished = Symbol("unfinished");
-const SymbolName = Symbol("name");
-const SymbolOwner = Symbol("owner");
-function createPageTreeBuilder(input, options) {
-	const flattenPathToFullPath = /* @__PURE__ */ new Map();
-	const transformers = [];
-	/** virtual file path -> output page tree node (if cached) */
-	const pathToNode = /* @__PURE__ */ new Map();
-	let _nextId = 0;
-	const { noRef = false, idPrefix, url: getUrl, generateFallback = true, sort: { by: sortBy = "path", locales: sortLocales, options: sortOptions } = {} } = options;
-	/** passed as additional information to transformers */
-	let ctx;
-	if (options.transformers) transformers.push(...options.transformers);
-	if (generateFallback) transformers.push(transformerFallback());
-	if (Array.isArray(input)) {
-		const [locale, storages] = input;
-		ctx = {
-			get builder() {
-				return builder;
-			},
-			storage: storages[locale],
-			storages,
-			locale,
-			transformers,
-			custom: options.context,
-			options
-		};
-	} else ctx = {
-		get builder() {
-			return builder;
-		},
-		storage: input,
+function createPageTreeBuilder(storage, options, locale, storages) {
+	const { idPrefix, transformers = [], sort = {} } = options;
+	const byName = sort.by === "name";
+	const compare = sort.locales || sort.options ? new Intl.Collator(sort.locales, sort.options).compare : (a, b) => a.localeCompare(b);
+	/** file or folder path -> entry */
+	const entries = /* @__PURE__ */ new Map();
+	const entryOf = /* @__PURE__ */ new Map();
+	const metaPaths = /* @__PURE__ */ new Set();
+	/** format -> file path without extension -> file path */
+	const flattenPaths = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	let usedPages = 0;
+	for (const [path, file] of storage.files) {
+		let paths = flattenPaths.get(file.format);
+		if (!paths) flattenPaths.set(file.format, paths = /* @__PURE__ */ new Map());
+		paths.set(path.slice(0, path.length - extname(path).length), path);
+	}
+	const builder = {
+		resolveFlattenPath,
+		root
+	};
+	const ctx = {
 		transformers,
+		builder,
+		storage,
+		storages,
+		locale,
 		custom: options.context,
 		options
 	};
-	const { storage, locale } = ctx;
-	for (const file of storage.getFiles()) {
-		const content = storage.read(file);
-		const flattenPath = file.substring(0, file.length - extname(file).length);
-		flattenPathToFullPath.set(flattenPath + "." + content.format, file);
-	}
 	function resolveFlattenPath(name, format) {
-		return flattenPathToFullPath.get(name + "." + format) ?? name;
+		return flattenPaths.get(format)?.get(name) ?? name;
+	}
+	function createId(localId = `_${nextId++}`) {
+		if (locale) localId = `${locale}:${localId}`;
+		return idPrefix ? `${idPrefix}:${localId}` : localId;
 	}
 	/**
-	* try to register as the owner of `node`.
-	*
-	* when a node is referenced by multiple folders, this determines which folder they should belong to.
-	*
-	* @returns whether the owner owns the node.
+	* claim a node for `folder`, a node referenced by multiple folders belongs to the highest priority:
+	* `pagesIndex` (3) > path & extract (2) > rest & default index (0), the first one wins a tie.
 	*/
-	function own(ownerPath, node, priority) {
-		if (node[SymbolUnfinished]) return false;
-		const existing = node[SymbolOwner];
-		if (!existing) {
-			node[SymbolOwner] = {
-				owner: ownerPath,
-				priority
-			};
-			return true;
-		}
-		if (existing.owner === ownerPath) {
-			existing.priority = Math.max(existing.priority, priority);
-			return true;
-		}
-		if (existing.priority >= priority) return false;
-		const folder = pathToNode.get(existing.owner);
-		if (folder && folder.type === "folder") {
-			if (folder.index === node) delete folder.index;
+	function own(folder, entry, priority) {
+		if (!entry.done) return false;
+		const prev = entry.owner;
+		if (prev && prev !== folder) {
+			if (entry.priority >= priority) return false;
+			if (prev.node.index === entry.node) delete prev.node.index;
 			else {
-				const idx = folder.children.indexOf(node);
-				if (idx !== -1) folder.children.splice(idx, 1);
+				const idx = prev.node.children.indexOf(entry.node);
+				if (idx !== -1) prev.node.children.splice(idx, 1);
 			}
 		}
-		existing.owner = ownerPath;
-		existing.priority = priority;
+		entry.owner = folder;
+		entry.priority = Math.max(entry.priority, priority);
 		return true;
 	}
-	function transferOwner(ownerPath, node) {
-		const existing = node[SymbolOwner];
-		if (existing) existing.owner = ownerPath;
-	}
-	function generateId(localId = `_${_nextId++}`) {
-		let id = localId;
-		if (locale) id = `${locale}:${id}`;
-		if (idPrefix) id = `${idPrefix}:${id}`;
-		return id;
-	}
-	function buildPaths(paths, filter, reversed = false) {
-		const nodes = [];
-		let indexNode;
-		for (const path of paths) {
-			if (filter && !filter(path)) continue;
-			const fileNode = buildFile(path);
-			if (fileNode) {
-				nodes.push(fileNode);
-				if (!indexNode && basename(path, extname(path)) === "index") indexNode = fileNode;
-				continue;
-			}
-			const dirNode = buildFolder(path);
-			if (dirNode) nodes.push(dirNode);
-		}
-		const factor = reversed ? -1 : 1;
-		const useName = sortBy === "name";
-		return nodes.sort((a, b) => {
-			if (a === indexNode) return -100;
-			if (b === indexNode) return 100;
-			const aT = useName && a[SymbolName] || (a.type === "folder" ? a.$ref.folder : a.$ref);
-			const bT = useName && b[SymbolName] || (b.type === "folder" ? b.$ref.folder : b.$ref);
-			const aK = a.type === "folder" ? 10 : 0;
-			const bK = b.type === "folder" ? 10 : 0;
-			return factor * (aT.localeCompare(bT, sortLocales, sortOptions) + (aK - bK));
-		});
-	}
-	function resolveLink(item) {
-		const match = link.exec(item);
-		if (!match?.groups) return;
-		const { icon, url, name, external } = match.groups;
+	function buildFile(path) {
+		const cached = entries.get(path);
+		if (cached) return cached;
+		const file = storage.read(path);
+		if (file?.format !== "page") return;
+		const { title, description, icon } = file.data;
 		let node = {
-			$id: generateId(),
+			$id: createId(path),
 			type: "page",
+			name: title ?? pathToName(basename(path, extname(path))),
+			description,
 			icon,
-			name,
-			url,
-			external: external ? true : void 0
+			url: options.url(file.slugs, locale),
+			$ref: path
 		};
-		for (const transformer of transformers) {
-			if (!transformer.file) continue;
-			node = transformer.file.call(ctx, node);
-		}
-		return node;
-	}
-	function resolveSeparator(item) {
-		const match = separator.exec(item);
-		if (!match?.groups) return;
-		let node = {
-			$id: generateId(),
-			type: "separator",
-			icon: match.groups.icon,
-			name: match.groups.name
+		for (const t of transformers) if (t.file) node = t.file.call(ctx, node, path);
+		const entry = {
+			node,
+			path,
+			title,
+			priority: 0,
+			done: true
 		};
-		for (const transformer of transformers) {
-			if (!transformer.separator) continue;
-			node = transformer.separator.call(ctx, node);
-		}
-		return node;
+		entries.set(path, entry);
+		entryOf.set(node, entry);
+		usedPages++;
+		return entry;
 	}
-	function resolveFolderItem(folderPath, item, outputArray, excludedPaths) {
-		if (item === rest || item === restReversed) {
-			outputArray.push(item);
-			return;
-		}
-		const separator = resolveSeparator(item);
-		if (separator) {
-			outputArray.push(separator);
-			return;
-		}
-		const link = resolveLink(item);
-		if (link) {
-			outputArray.push(link);
-			return;
-		}
-		if (item.startsWith(excludePrefix)) {
-			const path = joinPath(folderPath, item.slice(1));
-			excludedPaths.add(path);
-			excludedPaths.add(resolveFlattenPath(path, "page"));
-			return;
-		}
-		if (item.startsWith(extractPrefix)) {
-			const path = joinPath(folderPath, item.slice(3));
-			const node = buildFolder(path);
-			if (!node) return;
-			const children = node.index ? [node.index, ...node.children] : node.children;
-			if (own(folderPath, node, 2)) {
-				for (const child of children) {
-					transferOwner(folderPath, child);
-					outputArray.push(child);
-				}
-				excludedPaths.add(path);
-			} else for (const child of children) if (own(folderPath, child, 2)) outputArray.push(child);
-			return;
-		}
-		let path = joinPath(folderPath, item);
-		let node = buildFolder(path);
-		if (!node) {
-			path = resolveFlattenPath(path, "page");
-			node = buildFile(path);
-		}
-		if (!node || !own(folderPath, node, 2)) return;
-		outputArray.push(node);
-		excludedPaths.add(path);
-	}
-	function buildFolder(folderPath, isGlobalRoot = false) {
-		const cached = pathToNode.get(folderPath);
+	function buildFolder(path, isGlobalRoot = false) {
+		const cached = entries.get(path);
 		if (cached) return cached;
-		const files = storage.readDir(folderPath);
+		const files = storage.readDir(path);
 		if (!files) return;
-		let metaPath = resolveFlattenPath(joinPath(folderPath, "meta"), "meta");
-		let meta = storage.read(metaPath);
-		if (!meta || meta.format !== "meta") {
-			meta = void 0;
-			metaPath = void 0;
-		}
-		const metadata = meta?.data ?? {};
-		const isRoot = metadata.root ?? isGlobalRoot;
-		let node = {
+		let metaPath = resolveFlattenPath(joinPath(path, "meta"), "meta");
+		const metaFile = storage.read(metaPath);
+		let meta = {};
+		if (metaFile?.format === "meta") {
+			meta = metaFile.data;
+			metaPaths.add(metaPath);
+		} else metaPath = void 0;
+		const node = {
 			type: "folder",
 			name: null,
-			root: metadata.root,
-			defaultOpen: metadata.defaultOpen,
-			description: metadata.description,
-			collapsible: metadata.collapsible,
+			root: meta.root,
+			defaultOpen: meta.defaultOpen,
+			description: meta.description,
+			collapsible: meta.collapsible,
 			children: [],
-			$id: generateId(folderPath),
+			$id: createId(path),
 			$ref: {
-				folder: folderPath,
+				folder: path,
 				meta: metaPath
-			},
-			[SymbolUnfinished]: true
+			}
+		};
+		const self = {
+			node,
+			path,
+			priority: 0,
+			done: false
 		};
-		pathToNode.set(folderPath, node);
+		entries.set(path, self);
+		const indexName = meta.pagesIndex || (meta.root ?? isGlobalRoot ? void 0 : "index");
+		const indexPage = indexName && buildFile(resolveFlattenPath(joinPath(path, indexName), "page"));
 		let indexPath;
-		if (metadata.pagesIndex) {
-			const resolvedPath = resolveFlattenPath(joinPath(folderPath, metadata.pagesIndex), "page");
-			const page = buildFile(resolvedPath);
-			if (page && own(folderPath, page, 3)) {
-				indexPath = resolvedPath;
-				node.index = page;
-			} else node.index = resolveLink(metadata.pagesIndex);
-		} else if (!isRoot) {
-			const defaultPath = resolveFlattenPath(joinPath(folderPath, "index"), "page");
-			const page = buildFile(defaultPath);
-			if (page && own(folderPath, page, 0)) {
-				indexPath = defaultPath;
-				node.index = page;
+		if (indexPage && own(self, indexPage, meta.pagesIndex ? 3 : 0)) {
+			node.index = indexPage.node;
+			indexPath = indexPage.path;
+		} else if (meta.pagesIndex) node.index = resolveLink(meta.pagesIndex);
+		const items = [];
+		const excluded = /* @__PURE__ */ new Set();
+		for (const item of meta.pages ?? ["..."]) {
+			if (item === "..." || item === "z...a") {
+				items.push(item);
+				continue;
 			}
-		}
-		if (metadata.pages) {
-			const outputArray = [];
-			const excludedPaths = /* @__PURE__ */ new Set();
-			for (const item of metadata.pages) resolveFolderItem(folderPath, item, outputArray, excludedPaths);
-			if (indexPath) {
-				if (excludedPaths.has(indexPath)) delete node.index;
-				else excludedPaths.add(indexPath);
+			const inline = resolveSeparator(item) ?? resolveLink(item);
+			if (inline) {
+				items.push(inline);
+				continue;
 			}
-			for (const item of outputArray) {
-				if (item !== rest && item !== restReversed) {
-					node.children.push(item);
-					continue;
+			if (item.startsWith("!")) {
+				const target = joinPath(path, item.slice(1));
+				excluded.add(target).add(resolveFlattenPath(target, "page"));
+				continue;
+			}
+			if (item.startsWith("...")) {
+				const folder = buildFolder(joinPath(path, item.slice(3)));
+				if (!folder) continue;
+				const { index, children } = folder.node;
+				const owned = own(self, folder, 2);
+				if (owned) excluded.add(folder.path);
+				for (const child of index ? [index, ...children] : children) {
+					const entry = entryOf.get(child);
+					if (entry && owned) entry.owner = self;
+					else if (entry && !own(self, entry, 2)) continue;
+					items.push(child);
 				}
-				const resolvedItem = buildPaths(files, (file) => !excludedPaths.has(file), item === restReversed);
-				for (const child of resolvedItem) if (own(folderPath, child, 0)) node.children.push(child);
+				continue;
+			}
+			const target = joinPath(path, item);
+			const entry = buildFolder(target) ?? buildFile(resolveFlattenPath(target, "page"));
+			if (entry && own(self, entry, 2)) {
+				items.push(entry.node);
+				excluded.add(entry.path);
+			}
+		}
+		if (indexPath) {
+			if (excluded.has(indexPath)) delete node.index;
+			else excluded.add(indexPath);
+		}
+		for (const item of items) {
+			if (item === "..." || item === "z...a") {
+				for (const entry of buildRest(files, excluded, item === "z...a")) if (own(self, entry, 0)) node.children.push(entry.node);
+				continue;
 			}
-		} else for (const item of buildPaths(files, indexPath ? (file) => file !== indexPath : void 0)) if (own(folderPath, item, 0)) node.children.push(item);
-		node.icon = metadata.icon ?? node.index?.icon;
-		node.name = metadata.title ?? node.index?.name;
-		node[SymbolName] = metadata.title ?? node.index?.[SymbolName];
+			const entry = entryOf.get(item);
+			if (!entry || entry.owner === self) node.children.push(item);
+		}
+		node.icon = meta.icon ?? node.index?.icon;
+		node.name = meta.title ?? node.index?.name;
+		self.title = meta.title ?? (node.index && entryOf.get(node.index)?.title);
 		if (!node.name) {
-			const folderName = basename(folderPath);
-			node.name = pathToName(group.exec(folderName)?.[1] ?? folderName);
+			const name = basename(path);
+			node.name = pathToName(group.exec(name)?.[1] ?? name);
 		}
-		for (const transformer of transformers) {
-			if (!transformer.folder) continue;
-			node = transformer.folder.call(ctx, node, folderPath, metaPath);
+		let result = node;
+		for (const t of transformers) if (t.folder) result = t.folder.call(ctx, result, path, metaPath);
+		self.node = result;
+		self.done = true;
+		entryOf.set(result, self);
+		return self;
+	}
+	/** build the remaining items of a folder for `...` */
+	function buildRest(paths, excluded, reversed) {
+		const out = [];
+		let index;
+		for (const path of paths) {
+			if (excluded.has(path)) continue;
+			const file = buildFile(path);
+			if (file && !index && basename(path, extname(path)) === "index") index = file;
+			const entry = file ?? buildFolder(path);
+			if (entry) out.push(entry);
 		}
-		pathToNode.set(folderPath, node);
-		delete node[SymbolUnfinished];
-		return node;
+		const factor = reversed ? -1 : 1;
+		return out.sort((a, b) => {
+			if (a === index) return -1;
+			if (b === index) return 1;
+			const type = Number(a.node.type === "folder") - Number(b.node.type === "folder");
+			return factor * (type || compare(byName && a.title || a.path, byName && b.title || b.path));
+		});
 	}
-	function buildFile(path) {
-		const cached = pathToNode.get(path);
-		if (cached) return cached;
-		const page = storage.read(path);
-		if (!page || page.format !== "page") return;
-		const { title, description, icon } = page.data;
-		let item = {
-			$id: generateId(path),
+	function resolveLink(item) {
+		const match = link.exec(item)?.groups;
+		if (!match) return;
+		let node = {
+			$id: createId(),
 			type: "page",
-			name: title ?? pathToName(basename(path, extname(path))),
-			description,
-			icon,
-			url: getUrl(page.slugs, ctx.locale),
-			$ref: path,
-			[SymbolName]: title
+			icon: match.icon,
+			name: match.name,
+			url: match.url,
+			external: match.external ? true : void 0
 		};
-		for (const transformer of transformers) {
-			if (!transformer.file) continue;
-			item = transformer.file.call(ctx, item, path);
-		}
-		pathToNode.set(path, item);
-		return item;
+		for (const t of transformers) if (t.file) node = t.file.call(ctx, node);
+		return node;
 	}
-	const builder = {
-		resolveFlattenPath,
-		root(id = "root", path = "") {
-			const folder = buildFolder(path, true);
-			for (const node of pathToNode.values()) {
-				delete node[SymbolName];
-				delete node[SymbolOwner];
-				if (noRef && "$ref" in node) delete node.$ref;
-			}
-			let root = {
-				type: "root",
-				$ref: folder?.$ref,
-				$id: generateId(id),
-				name: folder?.name || "Docs",
-				description: folder?.description,
-				children: folder ? folder.children : []
-			};
-			for (const transformer of transformers) {
-				if (!transformer.root) continue;
-				root = transformer.root.call(ctx, root);
-			}
-			return root;
+	function resolveSeparator(item) {
+		const match = separator.exec(item)?.groups;
+		if (!match) return;
+		let node = {
+			$id: createId(),
+			type: "separator",
+			icon: match.icon,
+			name: match.name
+		};
+		for (const t of transformers) if (t.separator) node = t.separator.call(ctx, node);
+		return node;
+	}
+	function root(id = "root", path = "") {
+		const folder = buildFolder(path, true)?.node;
+		if (options.noRef) for (const { node } of entries.values()) delete node.$ref;
+		let out = {
+			type: "root",
+			$ref: folder?.$ref,
+			$id: createId(id),
+			name: folder?.name || "Docs",
+			description: folder?.description,
+			children: folder ? folder.children : []
+		};
+		for (const t of transformers) if (t.root) out = t.root.call(ctx, out);
+		if ((options.generateFallback ?? true) && usedPages + metaPaths.size < storage.files.size) {
+			const unused = new FileSystem();
+			for (const [path, file] of storage.files) if (!entries.has(path) && !metaPaths.has(path)) unused.write(path, file);
+			out.fallback = createPageTreeBuilder(unused, {
+				...options,
+				idPrefix: idPrefix ? `fallback:${idPrefix}` : "fallback",
+				generateFallback: false
+			}, locale, storages).root();
 		}
-	};
+		return out;
+	}
 	return builder;
 }
 /**
@@ -589,17 +480,15 @@ function createPageTreeBuilder(input, options) {
 * @param name - file name
 */
 function pathToName(name) {
-	const result = [];
-	for (const c of name) if (result.length === 0) result.push(c.toLocaleUpperCase());
-	else if (c === "-") result.push(" ");
-	else result.push(c);
-	return result.join("");
+	const [first = "", ...rest] = name;
+	return first.toLocaleUpperCase() + rest.join("").replaceAll("-", " ");
 }
 //#endregion
 //#region src/source/loader.ts
 /** decoded, generated slugs are URI encoded but some routers pass them decoded */
 function slugsKey(slugs) {
 	const key = slugs.join("/");
+	if (!key.includes("%")) return key;
 	try {
 		return decodeURI(key);
 	} catch {
@@ -607,18 +496,20 @@ function slugsKey(slugs) {
 	}
 }
 function createPageIndexer({ url }) {
-	const pages = /* @__PURE__ */ new Map();
-	const pathToMeta = /* @__PURE__ */ new Map();
-	const pathToPage = /* @__PURE__ */ new Map();
-	const urlToPage = /* @__PURE__ */ new Map();
+	/** locale (empty without i18n) -> index */
+	const indexes = /* @__PURE__ */ new Map();
 	return {
 		scan(storage, lang) {
-			for (const filePath of storage.getFiles()) {
-				const item = storage.read(filePath);
-				const prefix = lang ? `${lang}.` : ".";
-				const path = prefix + filePath;
+			const index = {
+				pages: /* @__PURE__ */ new Map(),
+				pathToPage: /* @__PURE__ */ new Map(),
+				pathToMeta: /* @__PURE__ */ new Map(),
+				urlToPage: /* @__PURE__ */ new Map()
+			};
+			indexes.set(lang ?? "", index);
+			for (const [path, item] of storage.files) {
 				if (item.format === "meta") {
-					pathToMeta.set(path, {
+					index.pathToMeta.set(path, {
 						type: item.type,
 						path: item.path,
 						absolutePath: item.absolutePath,
@@ -635,41 +526,43 @@ function createPageIndexer({ url }) {
 					data: item.data,
 					locale: lang
 				};
-				pathToPage.set(path, page);
-				pages.set(prefix + slugsKey(page.slugs), page);
-				urlToPage.set(prefix + page.url, page);
+				index.pathToPage.set(path, page);
+				index.pages.set(slugsKey(page.slugs), page);
+				index.urlToPage.set(page.url, page);
 			}
 		},
 		getPage(path, lang = "") {
-			return pathToPage.get(`${lang}.${path}`);
+			return indexes.get(lang)?.pathToPage.get(path);
 		},
 		getPageByUrl(url, lang = "") {
-			return urlToPage.get(`${lang}.${url}`);
+			return indexes.get(lang)?.urlToPage.get(url);
 		},
 		getMeta(path, lang = "") {
-			return pathToMeta.get(`${lang}.${path}`);
+			return indexes.get(lang)?.pathToMeta.get(path);
 		},
 		getPageBySlugs(slugs, lang = "") {
-			return pages.get(`${lang}.${slugsKey(slugs)}`);
+			return indexes.get(lang)?.pages.get(slugsKey(slugs));
 		},
 		/** do not filter by language if `lang` is not specified */
 		getPages(lang) {
 			const out = [];
-			for (const [key, value] of pages.entries()) if (lang === void 0 || key.startsWith(`${lang}.`)) out.push(value);
+			for (const [key, index] of indexes) {
+				if (lang !== void 0 && key !== lang) continue;
+				for (const page of index.pages.values()) out.push(page);
+			}
 			return out;
 		}
 	};
 }
 function createGetUrl(baseUrl, i18n) {
-	const baseSlugs = baseUrl.split("/");
+	const hideLocale = i18n?.hideLocale ?? "never";
+	let base = "";
+	for (const seg of baseUrl.split("/")) if (seg.length > 0) base += `/${seg}`;
 	return (slugs, locale) => {
-		const hideLocale = i18n?.hideLocale ?? "never";
-		let urlLocale;
-		if (hideLocale === "never") urlLocale = locale;
-		else if (hideLocale === "default-locale" && locale !== i18n?.defaultLanguage) urlLocale = locale;
-		const paths = [...baseSlugs, ...slugs];
-		if (urlLocale) paths.unshift(urlLocale);
-		return `/${paths.filter((v) => v.length > 0).join("/")}`;
+		const showLocale = hideLocale === "never" || hideLocale === "default-locale" && locale !== i18n?.defaultLanguage;
+		let url = locale && showLocale ? `/${locale}${base}` : base;
+		for (const slug of slugs) if (slug.length > 0) url += `/${slug}`;
+		return url || "/";
 	};
 }
 function loader(...args) {
@@ -692,11 +585,9 @@ function loader(...args) {
 			transformers
 		};
 		if (storage instanceof FileSystem) return pageTrees = createPageTreeBuilder(storage, options).root();
-		else {
-			const out = {};
-			for (const locale in storage) out[locale] = createPageTreeBuilder([locale, storage], options).root();
-			return pageTrees = out;
-		}
+		const out = {};
+		for (const locale in storage) out[locale] = createPageTreeBuilder(storage[locale], options, locale, storage).root();
+		return pageTrees = out;
 	}
 	const out = {
 		_i18n: i18n,
@@ -772,12 +663,17 @@ function loader(...args) {
 			}
 			return getPageTrees();
 		},
-		generateParams(slug, lang) {
-			if (i18n) return this.getLanguages().flatMap((entry) => entry.pages.map((page) => ({
-				[slug ?? "slug"]: page.slugs,
-				[lang ?? "lang"]: entry.language
-			})));
-			return this.getPages().map((page) => ({ [slug ?? "slug"]: page.slugs }));
+		generateParams(slug = "slug", lang = "lang") {
+			const params = [];
+			if (!i18n) {
+				for (const page of this.getPages()) params.push({ [slug]: page.slugs });
+				return params;
+			}
+			for (const entry of this.getLanguages()) for (const page of entry.pages) params.push({
+				[slug]: page.slugs,
+				[lang]: entry.language
+			});
+			return params;
 		},
 		async serializePageTree(tree) {
 			const { renderToString } = await import("react-dom/server.edge");

package/dist/source/dynamic.js

@@ -1,2 +1,2 @@
-import { t as dynamicLoader } from "../dynamic-Ce3F5rPi.js";
+import { t as dynamicLoader } from "../dynamic-CsxXgQ9d.js";
 export { dynamicLoader };

package/dist/source/index.js

@@ -1,5 +1,5 @@
 import { o as path_exports } from "../path-m9Srg2Jq.js";
-import { a as update, i as multiple, n as createGetUrl, o as FileSystem, r as loader, t as dynamicLoader } from "../dynamic-Ce3F5rPi.js";
+import { a as update, i as multiple, n as createGetUrl, o as FileSystem, r as loader, t as dynamicLoader } from "../dynamic-CsxXgQ9d.js";
 import { getSlugs } from "./plugins/slugs.js";
 import { llms } from "./llms.js";
 export { FileSystem, path_exports as PathUtils, createGetUrl, dynamicLoader, getSlugs, llms, loader, multiple, update };

package/dist/source/plugins/slugs.js

@@ -16,9 +16,8 @@ function slugsPlugin(optsOrFn = {}) {
 		transformStorage({ storage }) {
 			const indexFiles = [];
 			const taken = /* @__PURE__ */ new Set();
-			for (const path of storage.getFiles()) {
-				const file = storage.read(path);
-				if (!file || file.format !== "page") continue;
+			for (const [path, file] of storage.files) {
+				if (file.format !== "page") continue;
 				if (file.slugs) {
 					if (baseSlugs.length > 0 && !prepended.has(file)) {
 						file.slugs = [...baseSlugs, ...file.slugs];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-core",
-  "version": "16.17.1",
+  "version": "16.17.3",
   "description": "The React.js library for building a documentation website",
   "keywords": [
     "Docs",