@vezham/docs-core 1.0.1

package/dist/icon-BILaoXeg.js

@@ -0,0 +1,17 @@
+//#region src/source/plugins/icon.ts
+function iconPlugin(resolveIcon) {
+	function replaceIcon(node) {
+		if (node.icon === void 0 || typeof node.icon === "string") node.icon = resolveIcon(node.icon);
+		return node;
+	}
+	return {
+		name: "fumadocs:icon",
+		transformPageTree: {
+			file: replaceIcon,
+			folder: replaceIcon,
+			separator: replaceIcon
+		}
+	};
+}
+//#endregion
+export { iconPlugin as t };

package/dist/index-B-0R0VbS.d.ts

@@ -0,0 +1,18 @@
+import { i as Root } from "./definitions-CFOhwE1k.js";
+import "./index-E8Qh_yQs.js";
+//#region src/source/client/index.d.ts
+interface SerializedPageTree {
+  $fumadocs_loader: 'page-tree';
+  data: object;
+}
+type Serialized<Data> = { [K in keyof Data]: Data[K] extends SerializedPageTree ? Root : Data[K]; };
+declare function deserializePageTree(serialized: SerializedPageTree): Root;
+/**
+ * Deserialize loader data that is serialized by the server-side Fumadocs `loader()`, supported:
+ * - Page Tree
+ *
+ * other unrelated properties are kept in the output.
+ */
+declare function useFumadocsLoader<V>(serialized: V): Serialized<V>;
+//#endregion
+export { useFumadocsLoader as i, SerializedPageTree as n, deserializePageTree as r, Serialized as t };

package/dist/index-BM36H-xw.d.ts

@@ -0,0 +1,36 @@
+import { ReactNode } from "react";
+//#region src/search/index.d.ts
+interface SortedResult<Content = string> {
+  id: string;
+  url: string;
+  type: 'page' | 'heading' | 'text';
+  content: Content;
+  /**
+   * breadcrumbs to be displayed on UI
+   */
+  breadcrumbs?: Content[];
+  /**
+   * @deprecated it is now included in `content` as Markdown using `<mark />`.
+   */
+  contentWithHighlights?: HighlightedText<Content>[];
+}
+type ReactSortedResult = SortedResult<ReactNode>;
+interface HighlightedText<Content = string> {
+  type: 'text';
+  content: Content;
+  styles?: {
+    highlight?: boolean;
+  };
+}
+declare function createContentHighlighter(query: string | RegExp): {
+  /**
+   * @deprecated use `highlightMarkdown()` instead.
+   */
+  highlight(content: string): HighlightedText[];
+  /**
+   * @param content - Markdown, it assumes the content is already sanitized & safe, no escape is performed.
+   */
+  highlightMarkdown(content: string): string;
+};
+//#endregion
+export { createContentHighlighter as i, ReactSortedResult as n, SortedResult as r, HighlightedText as t };

package/dist/index-BMEUQz-F.d.ts

@@ -0,0 +1,21 @@
+import { t as Awaitable } from "./types-D89QoQR-.js";
+import { Root } from "hast";
+import { BundledLanguage, BundledTheme, CodeOptionsMeta, CodeOptionsThemes, CodeToHastOptionsCommon, HighlighterCore } from "shiki";
+//#region src/highlight/shiki/index.d.ts
+interface InitOptions {
+  langAlias?: Record<string, string>;
+}
+/**
+ * A factory for Fumadocs to manage Shiki instances.
+ */
+interface ShikiFactory {
+  init: (options?: InitOptions) => Awaitable<HighlighterCore>;
+  getOrInit: () => Awaitable<HighlighterCore>;
+}
+declare function createShikiFactory(config: Pick<ShikiFactory, 'init'>): ShikiFactory;
+type HighlightHastOptions = CodeToHastOptionsCommon<BundledLanguage> & CodeOptionsMeta & CodeOptionsThemes<BundledTheme> & {
+  fallbackLanguage?: BundledLanguage | (string & {});
+};
+declare function highlightHast(highlighter: HighlighterCore, code: string, options: HighlightHastOptions): Promise<Root>;
+//#endregion
+export { highlightHast as i, ShikiFactory as n, createShikiFactory as r, HighlightHastOptions as t };

package/dist/index-DAYtLGbx.d.ts

@@ -0,0 +1,16 @@
+import "./remark-gfm-DpVfAX1x.js";
+import "./rehype-code-D-RFJb9W.js";
+import "./remark-image-BI2S9LOb.js";
+import "./remark-structure-CnHwvNZr.js";
+import "./remark-heading-DEIzTkU5.js";
+import "./remark-admonition-BwTcmI_S.js";
+import "./remark-directive-admonition-BLiJ5l43.js";
+import "./rehype-toc-K51AGb5U.js";
+import "./remark-code-tab-DE_4bdnu.js";
+import "./remark-steps-DqVEo0iq.js";
+import "./remark-npm-BbpvkJaT.js";
+import "./codeblock-utils-CyP8qsYv.js";
+import "./remark-mdx-files-Buvxc-sa.js";
+import "./remark-mdx-mermaid-C1bCHHc6.js";
+import "./remark-feedback-block-BxtINXN-.js";
+import "./remark-llms-bD3WvU2V.js";

package/dist/index-DIwKCYOz.d.ts

@@ -0,0 +1,513 @@
+import { a as Separator, i as Root, n as Item, r as Node, t as Folder } from "./definitions-CFOhwE1k.js";
+import { t as Awaitable } from "./types-D89QoQR-.js";
+import { i as StructuredData } from "./remark-structure-CnHwvNZr.js";
+import "./index-DAYtLGbx.js";
+import { n as I18nConfig } from "./index-DydiXvgS.js";
+import "./index-E8Qh_yQs.js";
+import { n as SerializedPageTree } from "./index-B-0R0VbS.js";
+import { ReactNode } from "react";
+//#region src/source/storage/file-system.d.ts
+/**
+ * In memory file system.
+ */
+declare class FileSystem<File> {
+  files: Map<string, File>;
+  folders: Map<string, string[]>;
+  constructor(inherit?: FileSystem<File>);
+  read(path: string): File | undefined;
+  /**
+   * get the direct children of folder (in virtual file path)
+   */
+  readDir(path: string): string[] | undefined;
+  write(path: string, file: File): void;
+  /**
+   * Delete files at specified path.
+   *
+   * @param path - the target path.
+   * @param [recursive=false] - if set to `true`, it will also delete directories.
+   */
+  delete(path: string, recursive?: boolean): boolean;
+  getFiles(): string[];
+  makeDir(path: string): void;
+}
+//#endregion
+//#region src/source/storage/content.d.ts
+type ContentStorage<P extends ContentStoragePageFile = ContentStoragePageFile, M extends ContentStorageMetaFile = ContentStorageMetaFile> = FileSystem<P | M> & {
+  /** always `undefined`, for inferring types only */
+  $inferPage: P;
+  /** always `undefined`, for inferring types only */
+  $inferMeta: M;
+};
+/** @internal */
+interface ContentStorageMetaFile<Type extends string | undefined = string | undefined, Data extends MetaData = MetaData> {
+  type: Type;
+  path: string;
+  absolutePath?: string;
+  format: 'meta';
+  data: Data;
+}
+/** @internal */
+interface ContentStoragePageFile<Type extends string | undefined = string | undefined, Data extends PageData = PageData> {
+  type: Type;
+  path: string;
+  absolutePath?: string;
+  format: 'page';
+  slugs: string[];
+  data: Data;
+}
+//#endregion
+//#region src/source/page-tree/builder.d.ts
+interface PageTreeBuilderContext<S extends ContentStorage = ContentStorage> {
+  transformers: PageTreeTransformer<S>[];
+  builder: PageTreeBuilder;
+  storage: S;
+  storages?: Record<string, S>;
+  locale?: string;
+  custom?: Record<string, unknown>;
+  options: PageTreeOptions<S>;
+}
+interface PageTreeTransformer<S extends ContentStorage = ContentStorage> {
+  file?: (this: PageTreeBuilderContext<S>, node: Item, filePath?: string) => Item;
+  folder?: (this: PageTreeBuilderContext<S>, node: Folder, folderPath: string, metaPath?: string) => Folder;
+  separator?: (this: PageTreeBuilderContext<S>, node: Separator) => Separator;
+  root?: (this: PageTreeBuilderContext<S>, node: Root) => Root;
+}
+interface PageTreeOptions<S extends ContentStorage = ContentStorage> {
+  /** generate URL from page */
+  url: ResolvedLoaderConfig['url'];
+  idPrefix?: string;
+  /**
+   * Remove references to the file path of original nodes (`$ref`)
+   *
+   * @defaultValue false
+   */
+  noRef?: boolean;
+  /**
+   * generate fallback page tree
+   *
+   * @defaultValue true
+   */
+  generateFallback?: boolean;
+  /**
+   * Additional page tree transformers to apply
+   */
+  transformers?: PageTreeTransformer<S>[];
+  /** custom context */
+  context?: Record<string, unknown>;
+  /** customize the default sorting behaviour (`localeCompare`) */
+  sort?: {
+    /** @default 'path' */
+    by?: 'name' | 'path';
+    locales?: Intl.LocalesArgument;
+    options?: Intl.CollatorOptions;
+  };
+}
+interface PageTreeBuilder {
+  resolveFlattenPath(name: string, format: string): string;
+  root(id?: string, path?: string): Root;
+}
+//#endregion
+//#region src/source/plugins/slugs.d.ts
+/**
+ * a function to generate slugs, return `undefined` to generate default slugs.
+ *
+ * conflicting cases like `dir/index.mdx` vs `dir.mdx` are resolved after the function returns.
+ *
+ * @param next - generate the default slugs from file path (before conflict resolution).
+ */
+type SlugFn<S extends ContentStorage = ContentStorage> = (file: S['$inferPage'], next: () => string[]) => string[] | undefined;
+interface SlugsPluginOptions<S extends ContentStorage = ContentStorage> {
+  /** Slugs to prepend to every page. */
+  baseSlugs?: string[];
+  /** generate default slugs for pages */
+  slugs?: SlugFn<S>;
+}
+/**
+ * Generate slugs for pages if missing.
+ */
+declare function slugsPlugin(optsOrFn?: SlugsPluginOptions | SlugFn): LoaderPlugin;
+/**
+ * Generate slugs from file data (e.g. frontmatter).
+ *
+ * @param key - the property name in file data to generate slugs, default to `slug`.
+ */
+declare function slugsFromData(key?: string): SlugFn;
+/**
+ * Convert file path into slugs, also encode non-ASCII characters, so they can work in pathname
+ */
+declare function getSlugs(file: string): string[];
+//#endregion
+//#region src/source/plugins/icon.d.ts
+type IconResolver = (icon: string | undefined) => ReactNode;
+declare namespace types_d_exports {
+  export { AnyInput, GenerateMeta, GenerateMetaFile, GeneratePage, GeneratePageFile, GenerateStorage };
+}
+type AnyInput = SourceUnion | Record<string, SourceUnion>;
+type GeneratePage<T extends AnyInput> = T extends Record<infer K extends string, SourceUnion> ? { [k in K]: T[k] extends SourceUnion<infer D> ? Page<k, D['pageData']> : never; }[K] : T extends SourceUnion<infer D> ? Page<undefined, D['pageData']> : never;
+type GenerateMeta<T extends AnyInput> = T extends Record<infer K extends string, SourceUnion> ? { [k in K]: T[k] extends SourceUnion<infer D> ? Meta<k, D['metaData']> : never; }[K] : T extends SourceUnion<infer D> ? Meta<undefined, D['metaData']> : never;
+type GeneratePageFile<T extends AnyInput> = T extends Record<infer K extends string, SourceUnion> ? { [k in K]: T[k] extends SourceUnion<infer D> ? ContentStoragePageFile<k, D['pageData']> : never; }[K] : T extends SourceUnion<infer D> ? ContentStoragePageFile<undefined, D['pageData']> : never;
+type GenerateMetaFile<T extends AnyInput> = T extends Record<infer K extends string, SourceUnion> ? { [k in K]: T[k] extends SourceUnion<infer D> ? ContentStorageMetaFile<k, D['metaData']> : never; }[K] : T extends SourceUnion<infer D> ? ContentStorageMetaFile<undefined, D['metaData']> : never;
+type GenerateStorage<T extends AnyInput> = ContentStorage<GeneratePageFile<T>, GenerateMetaFile<T>>;
+//#endregion
+//#region src/source/loader.d.ts
+type ResolvedInput = StaticSource | Record<string, StaticSource>;
+interface LoaderConfig {
+  page: Page;
+  meta: Meta;
+  i18n: I18nConfig | undefined;
+}
+interface LoaderOptions<S extends ContentStorage = ContentStorage, I18n extends I18nConfig | undefined = I18nConfig | undefined> extends SlugsPluginOptions<S> {
+  baseUrl: string;
+  i18n?: I18n;
+  url?: (slugs: string[], locale?: string) => string;
+  /**
+   * Additional options for page tree builder
+   */
+  pageTree?: Partial<PageTreeOptions<S>>;
+  plugins?: LoaderPluginOption[] | ((context: {
+    typedPlugin: (plugin: LoaderPlugin<S>) => LoaderPlugin;
+  }) => LoaderPluginOption[]);
+  icon?: IconResolver;
+}
+interface ResolvedLoaderConfig {
+  input: ResolvedInput;
+  url: (slugs: string[], locale?: string) => string;
+  plugins: LoaderPlugin[];
+  pageTree?: Partial<PageTreeOptions>;
+  i18n?: I18nConfig | undefined;
+}
+interface SharedFileInfo {
+  /**
+   * Virtualized file path (relative to content directory)
+   *
+   * @example `docs/page.mdx`
+   */
+  path: string;
+  /**
+   * Absolute path of the file
+   */
+  absolutePath?: string;
+}
+interface Page<Type extends string | undefined = string | undefined, Data extends PageData = PageData> extends SharedFileInfo {
+  type: Type;
+  slugs: string[];
+  url: string;
+  data: Data;
+  locale?: string | undefined;
+}
+interface Meta<Type extends string | undefined = string | undefined, Data extends MetaData = MetaData> extends SharedFileInfo {
+  type: Type;
+  data: Data;
+}
+interface LoaderOutput<Config extends LoaderConfig = LoaderConfig> {
+  readonly $inferPage: Config['page'];
+  readonly $inferMeta: Config['meta'];
+  readonly $infer: Config;
+  pageTree: Config['i18n'] extends I18nConfig ? Record<string, Root> : Root;
+  getPageTree: (locale?: string) => Root;
+  /**
+   * get referenced page from href, supported:
+   *
+   * - relative file paths, like `./my/page.mdx`.
+   * - generated page pathname, like `/docs/my/page`.
+   */
+  getPageByHref: (href: string, options?: {
+    language?: string;
+    /**
+     * resolve relative file paths in `href` from specified dirname, must be a virtual path.
+     */
+    dir?: string;
+  }) => {
+    page: Config['page'];
+    hash?: string;
+  } | undefined;
+  /**
+   * resolve special hrefs in a page, including:
+   *
+   * - relative file paths, like `./my/page.mdx`.
+   */
+  resolveHref: (href: string, parent: Config['page']) => string;
+  /**
+   * @internal
+   */
+  _i18n?: I18nConfig;
+  /**
+   * Get a list of pages from specified language
+   *
+   * @param language - If unspecified, list pages from all languages.
+   */
+  getPages: (language?: string) => Config['page'][];
+  /**
+   * get each language and its pages, empty if i18n is not enabled.
+   */
+  getLanguages: () => {
+    language: string;
+    pages: Config['page'][];
+  }[];
+  /**
+   * Get page with slugs, the slugs can also be URI encoded.
+   *
+   * @param language - If unspecified, the default language will be used.
+   */
+  getPage: (slugs: string[] | undefined, language?: string) => Config['page'] | undefined;
+  getNodePage: (node: Item, language?: string) => Config['page'] | undefined;
+  getNodeMeta: (node: Folder | Root, language?: string) => Config['meta'] | undefined;
+  /**
+   * generate static params for Next.js SSG
+   *
+   * @param slug - customize parameter name for slugs
+   * @param lang - customize parameter name for lang
+   */
+  generateParams: <TSlug extends string = 'slug', TLang extends string = 'lang'>(slug?: TSlug, lang?: TLang) => (Record<TSlug, string[]> & Record<TLang, string>)[];
+  /**
+   * serialize page tree for non-RSC environments
+   */
+  serializePageTree: (tree: Root) => Promise<SerializedPageTree>;
+}
+declare function createGetUrl(baseUrl: string, i18n?: I18nConfig): ResolvedLoaderConfig['url'];
+/** content loader API for static content sources */
+declare function loader<I extends ResolvedInput, I18n extends I18nConfig | undefined = undefined>(source: I, options: LoaderOptions<NoInfer<GenerateStorage<I>>, I18n>): LoaderOutput<{
+  meta: GenerateMeta<I>;
+  page: GeneratePage<I>;
+  i18n: I18n;
+}>;
+/** content loader API for static content sources */
+declare function loader<I extends ResolvedInput, I18n extends I18nConfig | undefined = undefined>(options: LoaderOptions<NoInfer<GenerateStorage<I>>, I18n> & {
+  source: I;
+}): LoaderOutput<{
+  meta: GenerateMeta<I>;
+  page: GeneratePage<I>;
+  i18n: I18n;
+}>;
+interface LoaderPlugin<S extends ContentStorage = ContentStorage> {
+  name?: string;
+  /**
+   * Change the order of plugin:
+   * - `pre`: before normal plugins
+   * - `post`: after normal plugins
+   */
+  enforce?: 'pre' | 'post';
+  /**
+   * receive & replace loader options
+   */
+  config?: (config: ResolvedLoaderConfig) => ResolvedLoaderConfig | void | undefined;
+  /**
+   * transform the storage after loading
+   */
+  transformStorage?: (context: {
+    storage: S;
+  }) => void;
+  /**
+   * transform the generated page tree
+   */
+  transformPageTree?: PageTreeTransformer<S>;
+}
+type LoaderPluginOption<S extends ContentStorage = ContentStorage> = LoaderPlugin<S> | LoaderPluginOption<S>[] | undefined;
+type InferPageType<Utils extends LoaderOutput<any>> = Utils['$inferPage'];
+type InferMetaType<Utils extends LoaderOutput<any>> = Utils['$inferMeta'];
+//#endregion
+//#region src/source/dynamic.d.ts
+interface DynamicLoaderConfig extends LoaderConfig {
+  source: string | undefined;
+}
+interface DynamicLoader<Config extends DynamicLoaderConfig = DynamicLoaderConfig> {
+  get: () => Promise<LoaderOutput<Config>>;
+  /** invalidate & re-compute dynamic sources immediately */
+  revalidate: (source?: Config['source']) => Promise<void>;
+  /** remove computed cache of dynamic sources */
+  invalidate: (source?: Config['source']) => void;
+  get $inferPage(): Config['page'];
+  get $inferMeta(): Config['meta'];
+}
+/** content loader API for static & dynamic content sources, with in-memory cache. */
+declare function dynamicLoader<I extends SourceUnion | Record<string, SourceUnion>, I18n extends I18nConfig | undefined = undefined>(input: I, options: LoaderOptions<NoInfer<GenerateStorage<I>>, I18n>): DynamicLoader<{
+  i18n: I18n;
+  meta: NoInfer<GenerateMeta<I>>;
+  page: NoInfer<GeneratePage<I>>;
+  source: I extends Record<infer K, SourceUnion> ? K : undefined;
+}>;
+//#endregion
+//#region src/source/source.d.ts
+type SourceUnion<Config extends SourceConfig = SourceConfig> = StaticSource<Config> | DynamicSource<Config>;
+/**
+ * @deprecated use `StaticSource<Config>` instead
+ */
+type Source<Config extends SourceConfig = SourceConfig> = StaticSource<Config>;
+interface GenericSourceOptions {
+  /** the base directory for generated virtual files */
+  baseDir?: string;
+  /**
+   * when the source is attached to a new static loader, before loader output is accessible.
+   *
+   * can be called multiple times when attached to a dynamic loader.
+   **/
+  configureStatic?: (opts: {
+    loader: LoaderOutput;
+    source?: string;
+  }) => void;
+  /**
+   * when the source is attached to a dynamic loader.
+   *
+   * called at most once for each source object.
+   **/
+  configureDynamic?: (opts: {
+    loader: DynamicLoader;
+    source?: string;
+  }) => void;
+}
+interface StaticSource<Config extends SourceConfig = SourceConfig> extends GenericSourceOptions {
+  files: VirtualFile<Config>[];
+}
+/** one dynamic source object can only be used by one dynamic loader */
+type DynamicSource<Config extends SourceConfig = SourceConfig> = GenericSourceOptions & {
+  /**
+   * - `memory`: the dynamic loader's in-memory cache handles caching.
+   * - `custom`: the source handles caching itself. When the newer result of `files()` is (shallowly) different from the previous result, the source is considered revalidated, and all associated properties will be re-computed.
+   *
+   * @default 'memory'
+   **/
+  cache?: 'memory' | 'custom';
+  files: () => Awaitable<VirtualFile<Config>[]>;
+  /** @deprecated use `configureDynamic` instead */
+  configure?: (loader: DynamicLoader, opts: {
+    source?: string;
+  }) => void;
+  /** when the source is invalidated */
+  invalidate?: () => void;
+} & ({
+  cache?: 'memory';
+  /** enable time-based revalidation, the previous result will be stale after the specified duration (ms) */
+  staleTime?: number;
+} | {
+  cache: 'custom';
+});
+type SourceConfig = {
+  pageData: PageData;
+  metaData: MetaData;
+};
+interface MetaData {
+  icon?: string | undefined;
+  title?: string | undefined;
+  root?: boolean | string | undefined;
+  pages?: string[] | undefined;
+  pagesIndex?: string | undefined;
+  defaultOpen?: boolean | undefined;
+  collapsible?: boolean | undefined;
+  description?: string | undefined;
+}
+interface PageData {
+  icon?: string | undefined;
+  title?: string | undefined;
+  description?: string | undefined;
+  structuredData?: StructuredData | (() => Awaitable<StructuredData>) | undefined;
+}
+type VirtualFile<Config extends SourceConfig = SourceConfig> = VirtualPage<Config['pageData']> | VirtualMeta<Config['metaData']>;
+interface BaseVirtualFile {
+  /**
+   * Virtualized path (relative to content directory)
+   *
+   * @example `docs/page.mdx`
+   */
+  path: string;
+  /**
+   * Absolute path of the file
+   */
+  absolutePath?: string;
+}
+interface VirtualPage<Data extends PageData> extends BaseVirtualFile {
+  type: 'page';
+  /**
+   * Specified Slugs for page
+   */
+  slugs?: string[];
+  data: Data;
+}
+interface VirtualMeta<Data extends MetaData> extends BaseVirtualFile {
+  type: 'meta';
+  data: Data;
+}
+/**
+ * @deprecated you can directly pass a record of source objects to `loader()`.
+ */
+declare function multiple<T extends Record<string, StaticSource>>(sources: T): T extends Record<infer K extends string, StaticSource> ? { [k in K]: T[k] extends StaticSource<infer C> ? StaticSource<{
+  metaData: C['metaData'] & {
+    type: k;
+  };
+  pageData: C['pageData'] & {
+    type: k;
+  };
+}> : never; } : never;
+interface SourceUpdater<Config extends SourceConfig> {
+  files: <Page extends PageData, Meta extends MetaData>(fn: (files: VirtualFile<Config>[]) => (VirtualPage<Page> | VirtualMeta<Meta>)[]) => SourceUpdater<{
+    pageData: Page;
+    metaData: Meta;
+  }>;
+  page: <V extends PageData>(fn: (page: VirtualPage<Config['pageData']>) => VirtualPage<V>) => SourceUpdater<{
+    pageData: V;
+    metaData: Config['metaData'];
+  }>;
+  meta: <V extends MetaData>(fn: (meta: VirtualMeta<Config['metaData']>) => VirtualMeta<V>) => SourceUpdater<{
+    pageData: Config['pageData'];
+    metaData: V;
+  }>;
+  build: () => StaticSource<Config>;
+}
+/**
+ * update a **static** source object in-place.
+ */
+declare function update<Config extends SourceConfig>(source: StaticSource<Config>): SourceUpdater<Config>;
+declare namespace path_d_exports {
+  export { basename, dirname, extname, joinPath, normalize, slash, splitPath };
+}
+declare function basename(path: string, ext?: string): string;
+declare function extname(path: string): string;
+declare function dirname(path: string): string;
+/**
+ * Split path into segments, trailing/leading slashes are removed
+ */
+declare function splitPath(path: string): string[];
+/**
+ * Resolve paths, slashes within the path will be ignored
+ * @param paths - Paths to join
+ * @example
+ * ```
+ * ['a','b'] // 'a/b'
+ * ['/a'] // 'a'
+ * ['a', '/b'] // 'a/b'
+ * ['a', '../b/c'] // 'b/c'
+ * ```
+ */
+declare function joinPath(...paths: string[]): string;
+declare function slash(path: string): string;
+/**
+ * Convert (relative) file path to virtual file path.
+ *
+ * @param path - Relative path
+ * @returns Normalized path, with no trailing/leading slashes
+ * @throws Throws error if path starts with `./` or `../`
+ */
+declare function normalize(path: string): string;
+//#endregion
+//#region src/source/llms.d.ts
+interface Context {
+  lang?: string;
+}
+interface LLMsConfig {
+  TAB?: string;
+  renderName?: (item: Node | Root, ctx: Context) => string;
+  renderDescription?: (item: Root | Item | Folder, ctx: Context) => string;
+}
+declare function llms<C extends LoaderConfig = LoaderConfig>(loader: LoaderOutput<C>, config?: LLMsConfig): {
+  /**
+   * generate `llms.txt` content in Markdown format.
+   *
+   * use `indexNode(node)` instead for more control (e.g. add extra sections to output).
+   */
+  index: (lang?: string) => string;
+  /**
+   * generate `llms.txt` content for a single page tree node.
+   */
+  indexNode(node: Node, lang?: string): string;
+};
+//#endregion
+export { SlugsPluginOptions as A, ContentStoragePageFile as B, Meta as C, loader as D, createGetUrl as E, PageTreeBuilderContext as F, PageTreeOptions as I, PageTreeTransformer as L, slugsFromData as M, slugsPlugin as N, types_d_exports as O, PageTreeBuilder as P, ContentStorage as R, LoaderPluginOption as S, ResolvedLoaderConfig as T, FileSystem as V, InferPageType as _, MetaData as a, LoaderOutput as b, SourceUnion as c, multiple as d, update as f, InferMetaType as g, dynamicLoader as h, DynamicSource as i, getSlugs as j, SlugFn as k, StaticSource as l, DynamicLoaderConfig as m, llms as n, PageData as o, DynamicLoader as p, path_d_exports as r, Source as s, LLMsConfig as t, VirtualFile as u, LoaderConfig as v, Page as w, LoaderPlugin as x, LoaderOptions as y, ContentStorageMetaFile as z };