@hanzo/docs-core 16.4.3 → 16.5.3

package/dist/source/index.js

@@ -1,14 +1,14 @@
-import { t as normalizeUrl } from "../normalize-url-DP9-1I-S.js";
-import { c as visit } from "../utils-DUvi2WkD.js";
-import { a as path_exports, i as joinPath, n as dirname, o as slash, r as extname, s as splitPath, t as basename } from "../path-DHIjrDBP.js";
+import { t as normalizeUrl } from "../normalize-url-DUHbcuVM.js";
+import { c as visit } from "../utils-Bc53B3CJ.js";
+import { a as path_exports, i as joinPath, n as dirname, o as slash, r as extname, s as splitPath, t as basename } from "../path-D0Bwm6Fs.js";
 import { getSlugs, slugsPlugin } from "./plugins/slugs.js";
-import { t as iconPlugin } from "../icon-BWwSDabM.js";
+import { t as iconPlugin } from "../icon-OtPFhyk1.js";
 import path from "node:path";
 
 //#region src/source/source.ts
 function multiple(sources) {
 	const out = { files: [] };
-	for (const [type, source$1] of Object.entries(sources)) for (const file of source$1.files) out.files.push({
+	for (const [type, source] of Object.entries(sources)) for (const file of source.files) out.files.push({
 		...file,
 		data: {
 			...file.data,
@@ -23,28 +23,28 @@ function source(config) {
 /**
 * update a source object in-place.
 */
-function update(source$1) {
+function update(source) {
 	return {
 		files(fn) {
-			source$1.files = fn(source$1.files);
+			source.files = fn(source.files);
 			return this;
 		},
 		page(fn) {
-			for (let i = 0; i < source$1.files.length; i++) {
-				const file = source$1.files[i];
-				if (file.type === "page") source$1.files[i] = fn(file);
+			for (let i = 0; i < source.files.length; i++) {
+				const file = source.files[i];
+				if (file.type === "page") source.files[i] = fn(file);
 			}
 			return this;
 		},
 		meta(fn) {
-			for (let i = 0; i < source$1.files.length; i++) {
-				const file = source$1.files[i];
-				if (file.type === "meta") source$1.files[i] = fn(file);
+			for (let i = 0; i < source.files.length; i++) {
+				const file = source.files[i];
+				if (file.type === "meta") source.files[i] = fn(file);
 			}
 			return this;
 		},
 		build() {
-			return source$1;
+			return source;
 		}
 	};
 }
@@ -63,22 +63,22 @@ var FileSystem = class {
 			for (const [k, v] of inherit.files) this.files.set(k, v);
 		} else this.folders.set("", []);
 	}
-	read(path$1) {
-		return this.files.get(path$1);
+	read(path) {
+		return this.files.get(path);
 	}
 	/**
 	* get the direct children of folder (in virtual file path)
 	*/
-	readDir(path$1) {
-		return this.folders.get(path$1);
+	readDir(path) {
+		return this.folders.get(path);
 	}
-	write(path$1, file) {
-		if (!this.files.has(path$1)) {
-			const dir = dirname(path$1);
+	write(path, file) {
+		if (!this.files.has(path)) {
+			const dir = dirname(path);
 			this.makeDir(dir);
-			this.readDir(dir)?.push(path$1);
+			this.readDir(dir)?.push(path);
 		}
-		this.files.set(path$1, file);
+		this.files.set(path, file);
 	}
 	/**
 	* Delete files at specified path.
@@ -86,12 +86,12 @@ var FileSystem = class {
 	* @param path - the target path.
 	* @param [recursive=false] - if set to `true`, it will also delete directories.
 	*/
-	delete(path$1, recursive = false) {
-		if (this.files.delete(path$1)) return true;
+	delete(path, recursive = false) {
+		if (this.files.delete(path)) return true;
 		if (recursive) {
-			const folder = this.folders.get(path$1);
+			const folder = this.folders.get(path);
 			if (!folder) return false;
-			this.folders.delete(path$1);
+			this.folders.delete(path);
 			for (const child of folder) this.delete(child);
 			return true;
 		}
@@ -100,8 +100,8 @@ var FileSystem = class {
 	getFiles() {
 		return Array.from(this.files.keys());
 	}
-	makeDir(path$1) {
-		const segments = splitPath(path$1);
+	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;
@@ -117,39 +117,34 @@ function isLocaleValid(locale) {
 	return locale.length > 0 && !/\d+/.test(locale);
 }
 const parsers = {
-	dir(path$1) {
-		const [locale, ...segs] = path$1.split("/");
+	dir(path) {
+		const [locale, ...segs] = path.split("/");
 		if (locale && segs.length > 0 && isLocaleValid(locale)) return [segs.join("/"), locale];
-		return [path$1];
+		return [path];
 	},
-	dot(path$1) {
-		const dir = dirname(path$1);
-		const parts = basename(path$1).split(".");
-		if (parts.length < 3) return [path$1];
+	dot(path) {
+		const dir = dirname(path);
+		const parts = basename(path).split(".");
+		if (parts.length < 3) return [path];
 		const [locale] = parts.splice(parts.length - 2, 1);
-		if (!isLocaleValid(locale)) return [path$1];
+		if (!isLocaleValid(locale)) return [path];
 		return [joinPath(dir, parts.join(".")), locale];
 	},
-	none(path$1) {
-		return [path$1];
+	none(path) {
+		return [path];
 	}
 };
+const EmptyLang = Symbol();
 /**
-* @param defaultLanguage - language to use when i18n is not configured.
-* @returns a map of locale and its content storage.
+* convert input files into virtual file system.
 *
 * in the storage, locale codes are removed from file paths, hence the same file will have same file paths in every storage.
 */
-function buildContentStorage(loaderConfig, defaultLanguage) {
-	const { source: source$1, plugins = [], i18n = {
-		defaultLanguage,
-		parser: "none",
-		languages: [defaultLanguage]
-	} } = loaderConfig;
-	const parser = parsers[i18n.parser ?? "dot"];
-	const storages = {};
+function createContentStorageBuilder(loaderConfig) {
+	const { source, plugins = [], i18n } = loaderConfig;
+	const parser = i18n ? parsers[i18n.parser ?? "dot"] : parsers.none;
 	const normalized = /* @__PURE__ */ new Map();
-	for (const inputFile of source$1.files) {
+	for (const inputFile of source.files) {
 		let file;
 		if (inputFile.type === "page") file = {
 			format: "page",
@@ -164,7 +159,7 @@ function buildContentStorage(loaderConfig, defaultLanguage) {
 			absolutePath: inputFile.absolutePath,
 			data: inputFile.data
 		};
-		const [pathWithoutLocale, locale = i18n.defaultLanguage] = parser(file.path);
+		const [pathWithoutLocale, locale = i18n ? i18n.defaultLanguage : EmptyLang] = parser(file.path);
 		const list = normalized.get(locale) ?? [];
 		list.push({
 			pathWithoutLocale,
@@ -172,29 +167,37 @@ function buildContentStorage(loaderConfig, defaultLanguage) {
 		});
 		normalized.set(locale, list);
 	}
-	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 { pathWithoutLocale, file } of normalized.get(lang) ?? []) storage.write(pathWithoutLocale, file);
+	function makeStorage(locale, inherit) {
+		const storage = new FileSystem(inherit);
+		for (const { pathWithoutLocale, file } of normalized.get(locale) ?? []) storage.write(pathWithoutLocale, file);
 		const context = { storage };
 		for (const plugin of plugins) plugin.transformStorage?.(context);
-		storages[lang] = storage;
+		return storage;
 	}
-	for (const lang of i18n.languages) scan(lang);
-	return storages;
+	return {
+		i18n() {
+			const storages = {};
+			if (!i18n) return storages;
+			const fallbackLang = i18n.fallbackLanguage !== null ? i18n.fallbackLanguage ?? i18n.defaultLanguage : null;
+			function scan(lang) {
+				if (storages[lang]) return storages[lang];
+				return storages[lang] = makeStorage(lang, fallbackLang && fallbackLang !== lang ? scan(fallbackLang) : void 0);
+			}
+			for (const lang of i18n.languages) scan(lang);
+			return storages;
+		},
+		single() {
+			return makeStorage(EmptyLang);
+		}
+	};
 }
 /**
 * @param path - Relative path
 * @returns Normalized path, with no trailing/leading slashes
 * @throws Throws error if path starts with `./` or `../`
 */
-function normalizePath(path$1) {
-	const segments = splitPath(slash(path$1));
+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("/");
 }
@@ -203,28 +206,39 @@ function normalizePath(path$1) {
 //#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;
-				const content = this.storage.read(file);
-				if (content) isolatedStorage.write(file, content);
+				isolatedStorage.write(file, this.storage.read(file));
 			}
-			if (isolatedStorage.getFiles().length === 0) return root;
-			root.fallback = this.builder.build(isolatedStorage, {
-				...this.options,
-				id: `fallback-${root.$id ?? ""}`,
-				generateFallback: false
-			});
+			root.fallback = new PageTreeBuilder(isolatedStorage, {
+				idPrefix: this.idPrefix ? `fallback:${this.idPrefix}` : "fallback",
+				url: this.getUrl,
+				noRef: this.noRef,
+				transformers: this.transformers,
+				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;
 		}
@@ -240,211 +254,262 @@ const rest = "...";
 const restReversed = "z...a";
 const extractPrefix = "...";
 const excludePrefix = "!";
-function createPageTreeBuilder(loaderConfig) {
-	const { plugins = [], url, pageTree: defaultOptions = {} } = loaderConfig;
-	return {
-		build(storage, options = defaultOptions) {
-			const key = "";
-			return this.buildI18n({ [key]: storage }, options)[key];
-		},
-		buildI18n(storages, options = defaultOptions) {
-			let nextId = 0;
-			const out = {};
-			const transformers = [];
-			if (options.transformers) transformers.push(...options.transformers);
-			for (const plugin of plugins) if (plugin.transformPageTree) transformers.push(plugin.transformPageTree);
-			if (options.generateFallback ?? true) transformers.push(transformerFallback());
-			for (const [locale, storage] of Object.entries(storages)) {
-				let rootId = locale.length === 0 ? "root" : locale;
-				if (options.id) rootId = `${options.id}-${rootId}`;
-				out[locale] = createPageTreeBuilderUtils({
-					rootId,
-					transformers,
-					builder: this,
-					options,
-					getUrl: url,
-					locale,
-					storage,
-					storages,
-					generateNodeId() {
-						return "_" + nextId++;
-					}
-				}).root();
-			}
-			return out;
+var PageTreeBuilder = class {
+	constructor(input, options) {
+		this.flattenPathToFullPath = /* @__PURE__ */ new Map();
+		this.transformers = [];
+		this.pathToNode = /* @__PURE__ */ new Map();
+		this.unfinished = /* @__PURE__ */ new WeakSet();
+		this.ownerMap = /* @__PURE__ */ new Map();
+		this._nextId = 0;
+		const { transformers, url, context, generateFallback = true, idPrefix = "", noRef = false } = options;
+		if (transformers) this.transformers.push(...transformers);
+		if (generateFallback) this.transformers.push(transformerFallback());
+		this.ctx = {
+			builder: this,
+			idPrefix,
+			getUrl: url,
+			storage: void 0,
+			noRef,
+			transformers: this.transformers,
+			custom: context
+		};
+		if (Array.isArray(input)) {
+			const [locale, storages] = input;
+			this.ctx.storage = this.storage = storages[locale];
+			this.ctx.locale = locale;
+			this.ctx.storages = storages;
+		} else this.ctx.storage = this.storage = input;
+		for (const file of this.storage.getFiles()) {
+			const content = this.storage.read(file);
+			const flattenPath = file.substring(0, file.length - extname(file).length);
+			this.flattenPathToFullPath.set(flattenPath + "." + content.format, file);
 		}
-	};
-}
-function createFlattenPathResolver(storage) {
-	const map = /* @__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);
-		map.set(flattenPath + "." + content.format, file);
 	}
-	return (name, format) => {
-		return map.get(name + "." + format) ?? name;
-	};
-}
-function createPageTreeBuilderUtils(ctx) {
-	const resolveFlattenPath = createFlattenPathResolver(ctx.storage);
-	const visitedPaths = /* @__PURE__ */ new Set();
-	function nextNodeId(localId = ctx.generateNodeId()) {
-		return `${ctx.rootId}:${localId}`;
+	resolveFlattenPath(name, format) {
+		return this.flattenPathToFullPath.get(name + "." + format) ?? name;
 	}
-	return {
-		buildPaths(paths, reversed = false) {
-			const items = [];
-			const folders = [];
-			const sortedPaths = paths.sort((a, b) => a.localeCompare(b) * (reversed ? -1 : 1));
-			for (const path$1 of sortedPaths) {
-				const fileNode = this.file(path$1);
-				if (fileNode) {
-					if (basename(path$1, extname(path$1)) === "index") items.unshift(fileNode);
-					else items.push(fileNode);
-					continue;
-				}
-				const dirNode = this.folder(path$1, false);
-				if (dirNode) folders.push(dirNode);
-			}
-			items.push(...folders);
-			return items;
-		},
-		resolveFolderItem(folderPath, item) {
-			if (item === rest || item === restReversed) return item;
-			let match = separator.exec(item);
-			if (match?.groups) {
-				let node = {
-					$id: nextNodeId(),
-					type: "separator",
-					icon: match.groups.icon,
-					name: match.groups.name
-				};
-				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, external } = match.groups;
-				let node = {
-					$id: nextNodeId(),
-					type: "page",
-					icon,
-					name,
-					url,
-					external: external ? true : void 0
-				};
-				for (const transformer of ctx.transformers) {
-					if (!transformer.file) continue;
-					node = transformer.file.call(ctx, node);
-				}
-				return [node];
-			}
-			const isExcept = item.startsWith(excludePrefix);
-			const isExtract = !isExcept && item.startsWith(extractPrefix);
-			let filename = item;
-			if (isExcept) filename = item.slice(1);
-			else if (isExtract) filename = item.slice(3);
-			const path$1 = resolveFlattenPath(joinPath(folderPath, filename), "page");
-			if (isExcept) {
-				visitedPaths.add(path$1);
-				return [];
-			}
-			const dirNode = this.folder(path$1, false);
-			if (dirNode) return isExtract ? dirNode.children : [dirNode];
-			const fileNode = this.file(path$1);
-			return fileNode ? [fileNode] : [];
-		},
-		folder(folderPath, isGlobalRoot) {
-			const { storage, options, transformers } = ctx;
-			const files = storage.readDir(folderPath);
-			if (!files) return;
-			const metaPath = resolveFlattenPath(joinPath(folderPath, "meta"), "meta");
-			const indexPath = resolveFlattenPath(joinPath(folderPath, "index"), "page");
-			let meta = storage.read(metaPath);
-			if (meta && meta.format !== "meta") meta = void 0;
-			const metadata = meta?.data ?? {};
-			const { root = isGlobalRoot, pages } = metadata;
-			let index;
-			let children;
-			if (pages) {
-				const resolved = pages.flatMap((item) => this.resolveFolderItem(folderPath, item));
-				if (!root && !visitedPaths.has(indexPath)) index = this.file(indexPath);
-				for (let i = 0; i < resolved.length; i++) {
-					const item = resolved[i];
-					if (item !== rest && item !== restReversed) continue;
-					const items = this.buildPaths(files.filter((file) => !visitedPaths.has(file)), item === restReversed);
-					resolved.splice(i, 1, ...items);
-					break;
-				}
-				children = resolved;
-			} else {
-				if (!root && !visitedPaths.has(indexPath)) index = this.file(indexPath);
-				children = this.buildPaths(files.filter((file) => !visitedPaths.has(file)));
+	/**
+	* 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.
+	*/
+	own(ownerPath, node, priority) {
+		if (this.unfinished.has(node)) return false;
+		const existing = this.ownerMap.get(node);
+		if (!existing) {
+			this.ownerMap.set(node, {
+				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 = this.pathToNode.get(existing.owner);
+		if (folder && folder.type === "folder") if (folder.index === node) delete folder.index;
+		else {
+			const idx = folder.children.indexOf(node);
+			if (idx !== -1) folder.children.splice(idx, 1);
+		}
+		existing.owner = ownerPath;
+		existing.priority = priority;
+		return true;
+	}
+	transferOwner(ownerPath, node) {
+		const existing = this.ownerMap.get(node);
+		if (existing) existing.owner = ownerPath;
+	}
+	generateId(localId = `_${this._nextId++}`) {
+		let id = localId;
+		if (this.ctx.locale) id = `${this.ctx.locale}:${id}`;
+		if (this.ctx.idPrefix) id = `${this.ctx.idPrefix}:${id}`;
+		return id;
+	}
+	buildPaths(paths, filter, reversed = false) {
+		const items = [];
+		const folders = [];
+		const sortedPaths = paths.sort((a, b) => reversed ? b.localeCompare(a) : a.localeCompare(b));
+		for (const path of sortedPaths) {
+			if (filter && !filter(path)) continue;
+			const fileNode = this.file(path);
+			if (fileNode) {
+				if (basename(path, extname(path)) === "index") items.unshift(fileNode);
+				else items.push(fileNode);
+				continue;
 			}
+			const dirNode = this.folder(path);
+			if (dirNode) folders.push(dirNode);
+		}
+		items.push(...folders);
+		return items;
+	}
+	resolveFolderItem(folderPath, item, outputArray, excludedPaths) {
+		if (item === rest || item === restReversed) {
+			outputArray.push(item);
+			return;
+		}
+		let match = separator.exec(item);
+		if (match?.groups) {
 			let node = {
-				type: "folder",
-				name: metadata.title ?? index?.name ?? (() => {
-					const folderName = basename(folderPath);
-					return pathToName(group.exec(folderName)?.[1] ?? folderName);
-				})(),
-				icon: metadata.icon ?? index?.icon,
-				root: metadata.root,
-				defaultOpen: metadata.defaultOpen,
-				description: metadata.description,
-				collapsible: metadata.collapsible,
-				index,
-				children,
-				$id: nextNodeId(folderPath),
-				$ref: !options.noRef && meta ? { metaFile: metaPath } : void 0
+				$id: this.generateId(),
+				type: "separator",
+				icon: match.groups.icon,
+				name: match.groups.name
 			};
-			visitedPaths.add(folderPath);
-			for (const transformer of transformers) {
-				if (!transformer.folder) continue;
-				node = transformer.folder.call(ctx, node, folderPath, metaPath);
+			for (const transformer of this.transformers) {
+				if (!transformer.separator) continue;
+				node = transformer.separator.call(this.ctx, node);
 			}
-			return node;
-		},
-		file(path$1) {
-			const { options, getUrl, storage, locale, transformers } = ctx;
-			const page = storage.read(path$1);
-			if (page?.format !== "page") return;
-			const { title, description, icon } = page.data;
-			let item = {
-				$id: nextNodeId(path$1),
+			outputArray.push(node);
+			return;
+		}
+		match = link.exec(item);
+		if (match?.groups) {
+			const { icon, url, name, external } = match.groups;
+			let node = {
+				$id: this.generateId(),
 				type: "page",
-				name: title ?? pathToName(basename(path$1, extname(path$1))),
-				description,
 				icon,
-				url: getUrl(page.slugs, locale),
-				$ref: !options.noRef ? { file: path$1 } : void 0
+				name,
+				url
 			};
-			visitedPaths.add(path$1);
-			for (const transformer of transformers) {
+			if (external) node.external = true;
+			for (const transformer of this.transformers) {
 				if (!transformer.file) continue;
-				item = transformer.file.call(ctx, item, path$1);
+				node = transformer.file.call(this.ctx, node);
 			}
-			return item;
-		},
-		root() {
-			const folder = this.folder("", true);
-			let root = {
-				$id: ctx.rootId,
-				name: folder.name || "Docs",
-				children: folder.children
-			};
-			for (const transformer of ctx.transformers) {
-				if (!transformer.root) continue;
-				root = transformer.root.call(ctx, root);
+			outputArray.push(node);
+			return;
+		}
+		if (item.startsWith(excludePrefix)) {
+			const path = joinPath(folderPath, item.slice(1));
+			excludedPaths.add(path);
+			excludedPaths.add(this.resolveFlattenPath(path, "page"));
+			return;
+		}
+		if (item.startsWith(extractPrefix)) {
+			const path = joinPath(folderPath, item.slice(3));
+			const node = this.folder(path);
+			if (!node) return;
+			const children = node.index ? [node.index, ...node.children] : node.children;
+			if (this.own(folderPath, node, 2)) {
+				for (const child of children) {
+					this.transferOwner(folderPath, child);
+					outputArray.push(child);
+				}
+				excludedPaths.add(path);
+			} else for (const child of children) if (this.own(folderPath, child, 2)) outputArray.push(child);
+			return;
+		}
+		let path = joinPath(folderPath, item);
+		let node = this.folder(path);
+		if (!node) {
+			path = this.resolveFlattenPath(path, "page");
+			node = this.file(path);
+		}
+		if (!node || !this.own(folderPath, node, 2)) return;
+		outputArray.push(node);
+		excludedPaths.add(path);
+	}
+	folder(folderPath) {
+		const cached = this.pathToNode.get(folderPath);
+		if (cached) return cached;
+		const files = this.storage.readDir(folderPath);
+		if (!files) return;
+		const isGlobalRoot = folderPath === "";
+		const metaPath = this.resolveFlattenPath(joinPath(folderPath, "meta"), "meta");
+		const indexPath = this.resolveFlattenPath(joinPath(folderPath, "index"), "page");
+		let meta = this.storage.read(metaPath);
+		if (meta && meta.format !== "meta") meta = void 0;
+		const metadata = meta?.data ?? {};
+		let node = {
+			type: "folder",
+			name: null,
+			root: metadata.root,
+			defaultOpen: metadata.defaultOpen,
+			description: metadata.description,
+			collapsible: metadata.collapsible,
+			children: [],
+			$id: this.generateId(folderPath),
+			$ref: !this.ctx.noRef && meta ? { metaFile: metaPath } : void 0
+		};
+		this.pathToNode.set(folderPath, node);
+		this.unfinished.add(node);
+		if (!(metadata.root ?? isGlobalRoot)) {
+			const file = this.file(indexPath);
+			if (file && this.own(folderPath, file, 0)) node.index = file;
+		}
+		if (metadata.pages) {
+			const outputArray = [];
+			const excludedPaths = /* @__PURE__ */ new Set();
+			for (const item of metadata.pages) this.resolveFolderItem(folderPath, item, outputArray, excludedPaths);
+			if (excludedPaths.has(indexPath)) delete node.index;
+			else if (node.index) excludedPaths.add(indexPath);
+			for (const item of outputArray) {
+				if (item !== rest && item !== restReversed) {
+					node.children.push(item);
+					continue;
+				}
+				const resolvedItem = this.buildPaths(files, (file) => !excludedPaths.has(file), item === restReversed);
+				for (const child of resolvedItem) if (this.own(folderPath, child, 0)) node.children.push(child);
 			}
-			return root;
+		} else for (const item of this.buildPaths(files, node.index ? (file) => file !== indexPath : void 0)) if (this.own(folderPath, item, 0)) node.children.push(item);
+		node.icon = metadata.icon ?? node.index?.icon;
+		node.name = metadata.title ?? node.index?.name;
+		this.unfinished.delete(node);
+		if (!node.name) {
+			const folderName = basename(folderPath);
+			node.name = pathToName(group.exec(folderName)?.[1] ?? folderName);
 		}
-	};
-}
+		for (const transformer of this.transformers) {
+			if (!transformer.folder) continue;
+			node = transformer.folder.call(this.ctx, node, folderPath, meta ? metaPath : void 0);
+		}
+		this.pathToNode.set(folderPath, node);
+		return node;
+	}
+	file(path) {
+		const cached = this.pathToNode.get(path);
+		if (cached) return cached;
+		const page = this.storage.read(path);
+		if (!page || page.format !== "page") return;
+		const { title, description, icon } = page.data;
+		let item = {
+			$id: this.generateId(path),
+			type: "page",
+			name: title ?? pathToName(basename(path, extname(path))),
+			description,
+			icon,
+			url: this.ctx.getUrl(page.slugs, this.ctx.locale),
+			$ref: !this.ctx.noRef ? { file: path } : void 0
+		};
+		for (const transformer of this.transformers) {
+			if (!transformer.file) continue;
+			item = transformer.file.call(this.ctx, item, path);
+		}
+		this.pathToNode.set(path, item);
+		return item;
+	}
+	root(id = "root", path = "") {
+		const folder = this.folder(path);
+		let root = {
+			$id: this.generateId(id),
+			name: folder?.name || "Docs",
+			children: folder ? folder.children : []
+		};
+		for (const transformer of this.transformers) {
+			if (!transformer.root) continue;
+			root = transformer.root.call(this.ctx, root);
+		}
+		return root;
+	}
+};
 /**
 * Get item name from file name
 *
@@ -460,35 +525,54 @@ function pathToName(name) {
 
 //#endregion
 //#region src/source/loader.ts
-function indexPages(storages, { url }) {
-	const result = {
-		pages: /* @__PURE__ */ new Map(),
-		pathToMeta: /* @__PURE__ */ new Map(),
-		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$1 = `${lang}.${filePath}`;
-		if (item.format === "meta") {
-			result.pathToMeta.set(path$1, {
-				path: item.path,
-				absolutePath: item.absolutePath,
-				data: item.data
-			});
-			continue;
+function createPageIndexer({ url }) {
+	const pages = /* @__PURE__ */ new Map();
+	const pathToMeta = /* @__PURE__ */ new Map();
+	const pathToPage = /* @__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;
+				if (item.format === "meta") {
+					pathToMeta.set(path, {
+						path: item.path,
+						absolutePath: item.absolutePath,
+						data: item.data
+					});
+					continue;
+				}
+				const page = {
+					absolutePath: item.absolutePath,
+					path: item.path,
+					url: url(item.slugs, lang),
+					slugs: item.slugs,
+					data: item.data,
+					locale: lang
+				};
+				pathToPage.set(path, page);
+				pages.set(prefix + page.slugs.join("/"), page);
+			}
+		},
+		getPage(path, lang = "") {
+			return pathToPage.get(`${lang}.${path}`);
+		},
+		getMeta(path, lang = "") {
+			return pathToMeta.get(`${lang}.${path}`);
+		},
+		getPageBySlugs(slugs, lang = "") {
+			let page = pages.get(`${lang}.${slugs.join("/")}`);
+			if (page) return page;
+			page = pages.get(`${lang}.${slugs.map(decodeURI).join("/")}`);
+			if (page) return page;
+		},
+		getPages(lang) {
+			const out = [];
+			for (const [key, value] of pages.entries()) if (lang === void 0 || key.startsWith(`${lang}.`)) out.push(value);
+			return out;
 		}
-		const page = {
-			absolutePath: item.absolutePath,
-			path: item.path,
-			url: url(item.slugs, lang),
-			slugs: item.slugs,
-			data: item.data,
-			locale: lang
-		};
-		result.pathToPage.set(path$1, page);
-		result.pages.set(`${lang}.${page.slugs.join("/")}`, page);
-	}
-	return result;
+	};
 }
 function createGetUrl(baseUrl, i18n) {
 	const baseSlugs = baseUrl.split("/");
@@ -505,33 +589,43 @@ function createGetUrl(baseUrl, i18n) {
 function loader(...args) {
 	const loaderConfig = args.length === 2 ? resolveConfig(args[0], args[1]) : resolveConfig(args[0].source, args[0]);
 	const { i18n } = loaderConfig;
-	const defaultLanguage = i18n?.defaultLanguage ?? "";
-	const storages = buildContentStorage(loaderConfig, defaultLanguage);
-	const walker = indexPages(storages, loaderConfig);
-	const builder = createPageTreeBuilder(loaderConfig);
+	const storage = i18n ? createContentStorageBuilder(loaderConfig).i18n() : createContentStorageBuilder(loaderConfig).single();
+	const indexer = createPageIndexer(loaderConfig);
+	if (storage instanceof FileSystem) indexer.scan(storage);
+	else for (const locale in storage) indexer.scan(storage[locale], locale);
 	let pageTrees;
 	function getPageTrees() {
-		return pageTrees ??= builder.buildI18n(storages);
+		if (pageTrees) return pageTrees;
+		const { plugins = [], url, pageTree: pageTreeConfig } = loaderConfig;
+		const transformers = [];
+		if (pageTreeConfig?.transformers) transformers.push(...pageTreeConfig.transformers);
+		for (const plugin of plugins) if (plugin.transformPageTree) transformers.push(plugin.transformPageTree);
+		const options = {
+			url,
+			...pageTreeConfig,
+			transformers
+		};
+		if (storage instanceof FileSystem) return pageTrees = new PageTreeBuilder(storage, options).root();
+		else {
+			const out = {};
+			for (const locale in storage) out[locale] = new PageTreeBuilder([locale, storage], options).root();
+			return pageTrees = out;
+		}
 	}
 	return {
 		_i18n: i18n,
 		get pageTree() {
-			const trees = getPageTrees();
-			return i18n ? trees : trees[defaultLanguage];
+			return getPageTrees();
 		},
 		set pageTree(v) {
-			if (i18n) pageTrees = v;
-			else {
-				pageTrees ??= {};
-				pageTrees[defaultLanguage] = v;
-			}
+			pageTrees = v;
 		},
-		getPageByHref(href, { dir = "", language = defaultLanguage } = {}) {
+		getPageByHref(href, { dir = "", language = i18n?.defaultLanguage } = {}) {
 			const [value, hash] = href.split("#", 2);
 			let target;
 			if (value.startsWith("./")) {
-				const path$1 = joinPath(dir, value);
-				target = walker.pathToPage.get(`${language}.${path$1}`);
+				const path = joinPath(dir, value);
+				target = indexer.getPage(path, language);
 			} else target = this.getPages(language).find((item) => item.url === value);
 			if (target) return {
 				page: target,
@@ -549,9 +643,7 @@ function loader(...args) {
 			return href;
 		},
 		getPages(language) {
-			const pages = [];
-			for (const [key, value] of walker.pages.entries()) if (language === void 0 || key.startsWith(`${language}.`)) pages.push(value);
-			return pages;
+			return indexer.getPages(language);
 		},
 		getLanguages() {
 			const list = [];
@@ -562,25 +654,26 @@ function loader(...args) {
 			});
 			return list;
 		},
-		getPage(slugs = [], language = defaultLanguage) {
-			let page = walker.pages.get(`${language}.${slugs.join("/")}`);
-			if (page) return page;
-			page = walker.pages.get(`${language}.${slugs.map(decodeURI).join("/")}`);
-			if (page) return page;
+		getPage(slugs = [], language = i18n?.defaultLanguage) {
+			return indexer.getPageBySlugs(slugs, language);
 		},
-		getNodeMeta(node, language = defaultLanguage) {
+		getNodeMeta(node, language = i18n?.defaultLanguage) {
 			const ref = node.$ref?.metaFile;
 			if (!ref) return;
-			return walker.pathToMeta.get(`${language}.${ref}`);
+			return indexer.getMeta(ref, language);
 		},
-		getNodePage(node, language = defaultLanguage) {
+		getNodePage(node, language = i18n?.defaultLanguage) {
 			const ref = node.$ref?.file;
 			if (!ref) return;
-			return walker.pathToPage.get(`${language}.${ref}`);
+			return indexer.getPage(ref, language);
 		},
-		getPageTree(locale = defaultLanguage) {
-			const trees = getPageTrees();
-			return trees[locale] ?? trees[defaultLanguage];
+		getPageTree(locale) {
+			if (i18n) {
+				const trees = getPageTrees();
+				if (locale && trees[locale]) return trees[locale];
+				return trees[i18n.defaultLanguage];
+			}
+			return getPageTrees();
 		},
 		generateParams(slug, lang) {
 			if (i18n) return this.getLanguages().flatMap((entry) => entry.pages.map((page) => ({
@@ -591,21 +684,24 @@ function loader(...args) {
 		},
 		async serializePageTree(tree) {
 			const { renderToString } = await import("react-dom/server.edge");
-			return visit(tree, (node) => {
-				node = { ...node };
-				if ("icon" in node && node.icon) node.icon = renderToString(node.icon);
-				if (node.name) node.name = renderToString(node.name);
-				if ("children" in node) node.children = [...node.children];
-				return node;
-			});
+			return {
+				$hanzo_docs_loader: "page-tree",
+				data: visit(tree, (node) => {
+					node = { ...node };
+					if ("icon" in node && node.icon) node.icon = renderToString(node.icon);
+					if (node.name) node.name = renderToString(node.name);
+					if ("children" in node) node.children = [...node.children];
+					return node;
+				})
+			};
 		}
 	};
 }
-function resolveConfig(source$1, { slugs, icon, plugins = [], baseUrl, url, ...base }) {
+function resolveConfig(source, { slugs, icon, plugins = [], baseUrl, url, ...base }) {
 	let config = {
 		...base,
 		url: url ? (...args) => normalizeUrl(url(...args)) : createGetUrl(baseUrl, base.i18n),
-		source: source$1,
+		source,
 		plugins: buildPlugins([
 			icon && iconPlugin(icon),
 			...typeof plugins === "function" ? plugins({ typedPlugin: (plugin) => plugin }) : plugins,
@@ -632,5 +728,4 @@ function buildPlugins(plugins, sort = true) {
 }
 
 //#endregion
-export { FileSystem, path_exports as PathUtils, createGetUrl, getSlugs, loader, multiple, source, update };
-//# sourceMappingURL=index.js.map
+export { FileSystem, path_exports as PathUtils, createGetUrl, getSlugs, loader, multiple, source, update };