fumadocs-mdx 11.6.0 → 13.0.1

package/dist/core-B6j6Fxse.d.cts

@@ -0,0 +1,218 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import * as plugins from 'fumadocs-core/mdx-plugins';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Pluggable } from 'unified';
+import { z } from 'zod';
+import { FSWatcher } from 'chokidar';
+
+interface ExtractedReference {
+    href: string;
+}
+interface PostprocessOptions {
+    _format: 'md' | 'mdx';
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    /**
+     * stringify MDAST and export via `_markdown`.
+     */
+    includeProcessedMarkdown?: boolean;
+    /**
+     * store MDAST and export via `_mdast`.
+     */
+    includeMDAST?: boolean | {
+        removePosition?: boolean;
+    };
+}
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkStructureOptions?: plugins.StructureOptions | false;
+    remarkHeadingOptions?: plugins.RemarkHeadingOptions;
+    remarkImageOptions?: plugins.RemarkImageOptions | false;
+    remarkCodeTabOptions?: plugins.RemarkCodeTabOptions | false;
+    remarkNpmOptions?: plugins.RemarkNpmOptions | false;
+    rehypeCodeOptions?: plugins.RehypeCodeOptions | false;
+    _withoutBundler?: boolean;
+};
+declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, remarkCodeTabOptions, remarkNpmOptions, _withoutBundler, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
+
+/**
+ * Zod 4 schema
+ */
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodBoolean>;
+    defaultOpen: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod 4 schema
+ */
+declare const frontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    _openapi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+
+type CollectionSchema<Schema extends StandardSchemaV1, Context> = Schema | ((ctx: Context) => Schema);
+type AnyCollection = DocsCollection | DocCollection | MetaCollection;
+interface BaseCollection {
+    /**
+     * Directories to scan
+     */
+    dir: string | string[];
+    /**
+     * what files to include/exclude (glob patterns)
+     *
+     * Include all files if not specified
+     */
+    files?: string[];
+}
+interface MetaCollection<Schema extends StandardSchemaV1 = StandardSchemaV1> extends BaseCollection {
+    type: 'meta';
+    schema?: CollectionSchema<Schema, {
+        path: string;
+        source: string;
+    }>;
+}
+interface DocCollection<Schema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> extends BaseCollection {
+    type: 'doc';
+    postprocess?: Partial<PostprocessOptions>;
+    mdxOptions?: ProcessorOptions;
+    /**
+     * Load files with async
+     */
+    async?: Async;
+    schema?: CollectionSchema<Schema, {
+        path: string;
+        source: string;
+    }>;
+}
+interface DocsCollection<DocSchema extends StandardSchemaV1 = StandardSchemaV1, MetaSchema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> {
+    type: 'docs';
+    dir: string;
+    docs: DocCollection<DocSchema, Async>;
+    meta: MetaCollection<MetaSchema>;
+}
+type GlobalConfigMDXOptions = ({
+    preset?: 'fumadocs';
+} & DefaultMDXOptions) | ({
+    preset: 'minimal';
+} & ProcessorOptions);
+interface GlobalConfig {
+    plugins?: PluginOption[];
+    /**
+     * Configure global MDX options
+     */
+    mdxOptions?: GlobalConfigMDXOptions | (() => Promise<GlobalConfigMDXOptions>);
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+    /**
+     * specify a directory to access & store cache (disabled during development mode).
+     *
+     * The cache will never be updated, delete the cache folder to clean.
+     */
+    experimentalBuildCache?: string;
+}
+declare function defineCollections<Schema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = false>(options: DocCollection<Schema, Async>): DocCollection<Schema, Async>;
+declare function defineCollections<Schema extends StandardSchemaV1 = StandardSchemaV1>(options: MetaCollection<Schema>): MetaCollection<Schema>;
+declare function defineDocs<DocSchema extends StandardSchemaV1 = typeof frontmatterSchema, MetaSchema extends StandardSchemaV1 = typeof metaSchema, Async extends boolean = false>(options: {
+    /**
+     * The content directory to scan files
+     *
+     *  @defaultValue 'content/docs'
+     */
+    dir?: string;
+    docs?: Omit<DocCollection<DocSchema, Async>, 'dir' | 'type'>;
+    meta?: Omit<MetaCollection<MetaSchema>, 'dir' | 'type'>;
+}): DocsCollection<DocSchema, MetaSchema, Async>;
+declare function defineConfig(config?: GlobalConfig): GlobalConfig;
+
+interface ConfigLoader {
+    getConfig: () => LoadedConfig | Promise<LoadedConfig>;
+}
+interface LoadedConfig {
+    collections: Map<string, DocCollection | MetaCollection | DocsCollection>;
+    global: GlobalConfig;
+    getDefaultMDXOptions(mode?: 'default' | 'remote'): Promise<ProcessorOptions>;
+}
+
+type Awaitable<T> = T | Promise<T>;
+interface EmitEntry {
+    /**
+     * path relative to output directory
+     */
+    path: string;
+    content: string;
+}
+interface PluginContext extends CoreOptions {
+    core: Core;
+}
+interface Plugin {
+    name?: string;
+    /**
+     * on config loaded/updated
+     */
+    config?: (this: PluginContext, config: LoadedConfig) => Awaitable<void | LoadedConfig>;
+    /**
+     * Generate files (e.g. types, index file, or JSON schemas)
+     */
+    emit?: (this: PluginContext) => Awaitable<EmitEntry[]>;
+    /**
+     * Configure Fumadocs dev server
+     */
+    configureServer?: (this: PluginContext, server: ServerContext) => Awaitable<void>;
+}
+type PluginOption = Awaitable<Plugin | Plugin[] | false>;
+interface ServerContext {
+    /**
+     * the file watcher, by default all content files are watched, along with other files.
+     *
+     * make sure to filter when listening to events
+     */
+    watcher?: FSWatcher;
+}
+interface CoreOptions {
+    environment: string;
+    configPath: string;
+    outDir: string;
+}
+interface EmitOptions {
+    /**
+     * filter the plugins to run emit
+     */
+    filterPlugin?: (plugin: Plugin) => boolean;
+}
+declare function createCore(options: CoreOptions, defaultPlugins?: PluginOption[]): {
+    _options: CoreOptions;
+    getPluginContext(): PluginContext;
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: Map<string, unknown>;
+    init({ config: newConfig }: {
+        config: Awaitable<LoadedConfig>;
+    }): Promise</*elided*/ any>;
+    getConfig(): LoadedConfig;
+    creatConfigLoader(): ConfigLoader;
+    initServer(server: ServerContext): Promise<void>;
+    emitAndWrite({ filterPlugin, }?: EmitOptions): Promise<void>;
+};
+type Core = ReturnType<typeof createCore>;
+
+export { type AnyCollection as A, type BaseCollection as B, type CoreOptions as C, type DefaultMDXOptions as D, type ExtractedReference as E, type GlobalConfig as G, type LoadedConfig as L, type MetaCollection as M, type PostprocessOptions as P, type ServerContext as S, type CollectionSchema as a, type DocCollection as b, type DocsCollection as c, defineCollections as d, defineDocs as e, defineConfig as f, getDefaultMDXOptions as g, frontmatterSchema as h, type Plugin as i, type EmitEntry as j, type PluginContext as k, type PluginOption as l, metaSchema as m, type EmitOptions as n, createCore as o, type Core as p };

package/dist/core-B6j6Fxse.d.ts

@@ -0,0 +1,218 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import * as plugins from 'fumadocs-core/mdx-plugins';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Pluggable } from 'unified';
+import { z } from 'zod';
+import { FSWatcher } from 'chokidar';
+
+interface ExtractedReference {
+    href: string;
+}
+interface PostprocessOptions {
+    _format: 'md' | 'mdx';
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    /**
+     * stringify MDAST and export via `_markdown`.
+     */
+    includeProcessedMarkdown?: boolean;
+    /**
+     * store MDAST and export via `_mdast`.
+     */
+    includeMDAST?: boolean | {
+        removePosition?: boolean;
+    };
+}
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkStructureOptions?: plugins.StructureOptions | false;
+    remarkHeadingOptions?: plugins.RemarkHeadingOptions;
+    remarkImageOptions?: plugins.RemarkImageOptions | false;
+    remarkCodeTabOptions?: plugins.RemarkCodeTabOptions | false;
+    remarkNpmOptions?: plugins.RemarkNpmOptions | false;
+    rehypeCodeOptions?: plugins.RehypeCodeOptions | false;
+    _withoutBundler?: boolean;
+};
+declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, remarkCodeTabOptions, remarkNpmOptions, _withoutBundler, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
+
+/**
+ * Zod 4 schema
+ */
+declare const metaSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    pages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    description: z.ZodOptional<z.ZodString>;
+    root: z.ZodOptional<z.ZodBoolean>;
+    defaultOpen: z.ZodOptional<z.ZodBoolean>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Zod 4 schema
+ */
+declare const frontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+    _openapi: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+}, z.core.$strip>;
+
+type CollectionSchema<Schema extends StandardSchemaV1, Context> = Schema | ((ctx: Context) => Schema);
+type AnyCollection = DocsCollection | DocCollection | MetaCollection;
+interface BaseCollection {
+    /**
+     * Directories to scan
+     */
+    dir: string | string[];
+    /**
+     * what files to include/exclude (glob patterns)
+     *
+     * Include all files if not specified
+     */
+    files?: string[];
+}
+interface MetaCollection<Schema extends StandardSchemaV1 = StandardSchemaV1> extends BaseCollection {
+    type: 'meta';
+    schema?: CollectionSchema<Schema, {
+        path: string;
+        source: string;
+    }>;
+}
+interface DocCollection<Schema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> extends BaseCollection {
+    type: 'doc';
+    postprocess?: Partial<PostprocessOptions>;
+    mdxOptions?: ProcessorOptions;
+    /**
+     * Load files with async
+     */
+    async?: Async;
+    schema?: CollectionSchema<Schema, {
+        path: string;
+        source: string;
+    }>;
+}
+interface DocsCollection<DocSchema extends StandardSchemaV1 = StandardSchemaV1, MetaSchema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = boolean> {
+    type: 'docs';
+    dir: string;
+    docs: DocCollection<DocSchema, Async>;
+    meta: MetaCollection<MetaSchema>;
+}
+type GlobalConfigMDXOptions = ({
+    preset?: 'fumadocs';
+} & DefaultMDXOptions) | ({
+    preset: 'minimal';
+} & ProcessorOptions);
+interface GlobalConfig {
+    plugins?: PluginOption[];
+    /**
+     * Configure global MDX options
+     */
+    mdxOptions?: GlobalConfigMDXOptions | (() => Promise<GlobalConfigMDXOptions>);
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+    /**
+     * specify a directory to access & store cache (disabled during development mode).
+     *
+     * The cache will never be updated, delete the cache folder to clean.
+     */
+    experimentalBuildCache?: string;
+}
+declare function defineCollections<Schema extends StandardSchemaV1 = StandardSchemaV1, Async extends boolean = false>(options: DocCollection<Schema, Async>): DocCollection<Schema, Async>;
+declare function defineCollections<Schema extends StandardSchemaV1 = StandardSchemaV1>(options: MetaCollection<Schema>): MetaCollection<Schema>;
+declare function defineDocs<DocSchema extends StandardSchemaV1 = typeof frontmatterSchema, MetaSchema extends StandardSchemaV1 = typeof metaSchema, Async extends boolean = false>(options: {
+    /**
+     * The content directory to scan files
+     *
+     *  @defaultValue 'content/docs'
+     */
+    dir?: string;
+    docs?: Omit<DocCollection<DocSchema, Async>, 'dir' | 'type'>;
+    meta?: Omit<MetaCollection<MetaSchema>, 'dir' | 'type'>;
+}): DocsCollection<DocSchema, MetaSchema, Async>;
+declare function defineConfig(config?: GlobalConfig): GlobalConfig;
+
+interface ConfigLoader {
+    getConfig: () => LoadedConfig | Promise<LoadedConfig>;
+}
+interface LoadedConfig {
+    collections: Map<string, DocCollection | MetaCollection | DocsCollection>;
+    global: GlobalConfig;
+    getDefaultMDXOptions(mode?: 'default' | 'remote'): Promise<ProcessorOptions>;
+}
+
+type Awaitable<T> = T | Promise<T>;
+interface EmitEntry {
+    /**
+     * path relative to output directory
+     */
+    path: string;
+    content: string;
+}
+interface PluginContext extends CoreOptions {
+    core: Core;
+}
+interface Plugin {
+    name?: string;
+    /**
+     * on config loaded/updated
+     */
+    config?: (this: PluginContext, config: LoadedConfig) => Awaitable<void | LoadedConfig>;
+    /**
+     * Generate files (e.g. types, index file, or JSON schemas)
+     */
+    emit?: (this: PluginContext) => Awaitable<EmitEntry[]>;
+    /**
+     * Configure Fumadocs dev server
+     */
+    configureServer?: (this: PluginContext, server: ServerContext) => Awaitable<void>;
+}
+type PluginOption = Awaitable<Plugin | Plugin[] | false>;
+interface ServerContext {
+    /**
+     * the file watcher, by default all content files are watched, along with other files.
+     *
+     * make sure to filter when listening to events
+     */
+    watcher?: FSWatcher;
+}
+interface CoreOptions {
+    environment: string;
+    configPath: string;
+    outDir: string;
+}
+interface EmitOptions {
+    /**
+     * filter the plugins to run emit
+     */
+    filterPlugin?: (plugin: Plugin) => boolean;
+}
+declare function createCore(options: CoreOptions, defaultPlugins?: PluginOption[]): {
+    _options: CoreOptions;
+    getPluginContext(): PluginContext;
+    /**
+     * Convenient cache store, reset when config changes
+     */
+    cache: Map<string, unknown>;
+    init({ config: newConfig }: {
+        config: Awaitable<LoadedConfig>;
+    }): Promise</*elided*/ any>;
+    getConfig(): LoadedConfig;
+    creatConfigLoader(): ConfigLoader;
+    initServer(server: ServerContext): Promise<void>;
+    emitAndWrite({ filterPlugin, }?: EmitOptions): Promise<void>;
+};
+type Core = ReturnType<typeof createCore>;
+
+export { type AnyCollection as A, type BaseCollection as B, type CoreOptions as C, type DefaultMDXOptions as D, type ExtractedReference as E, type GlobalConfig as G, type LoadedConfig as L, type MetaCollection as M, type PostprocessOptions as P, type ServerContext as S, type CollectionSchema as a, type DocCollection as b, type DocsCollection as c, defineCollections as d, defineDocs as e, defineConfig as f, getDefaultMDXOptions as g, frontmatterSchema as h, type Plugin as i, type EmitEntry as j, type PluginContext as k, type PluginOption as l, metaSchema as m, type EmitOptions as n, createCore as o, type Core as p };

package/dist/index.cjs

@@ -3,10 +3,6 @@ var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -19,76 +15,4 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 
 // src/index.ts
 var index_exports = {};
-__export(index_exports, {
-  _runtime: () => _runtime,
-  createMDXSource: () => createMDXSource,
-  resolveFiles: () => resolveFiles
-});
 module.exports = __toCommonJS(index_exports);
-
-// src/runtime/index.ts
-var _runtime = {
-  doc(files) {
-    return files.map((file) => {
-      const { default: body, frontmatter, ...exports2 } = file.data;
-      return {
-        body,
-        ...exports2,
-        ...frontmatter,
-        _exports: file.data,
-        _file: file.info
-      };
-    });
-  },
-  meta(files) {
-    return files.map((file) => {
-      return {
-        ...file.data,
-        _file: file.info
-      };
-    });
-  },
-  docs(docs, metas) {
-    const parsedDocs = this.doc(docs);
-    const parsedMetas = this.meta(metas);
-    return {
-      docs: parsedDocs,
-      meta: parsedMetas,
-      toFumadocsSource() {
-        return createMDXSource(parsedDocs, parsedMetas);
-      }
-    };
-  }
-};
-function createMDXSource(docs, meta = []) {
-  return {
-    files: () => resolveFiles({
-      docs,
-      meta
-    })
-  };
-}
-function resolveFiles({ docs, meta }) {
-  const outputs = [];
-  for (const entry of docs) {
-    outputs.push({
-      type: "page",
-      path: entry._file.path,
-      data: entry
-    });
-  }
-  for (const entry of meta) {
-    outputs.push({
-      type: "meta",
-      path: entry._file.path,
-      data: entry
-    });
-  }
-  return outputs;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  _runtime,
-  createMDXSource,
-  resolveFiles
-});

package/dist/index.d.cts

@@ -1,26 +1,79 @@
-import { PageData, MetaData, Source, VirtualFile } from 'fumadocs-core/source';
-import { B as BaseCollectionEntry } from './define-BaW0PQDJ.cjs';
-import { R as Runtime } from './types-BNrQHCj5.cjs';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TOCItemType } from 'fumadocs-core/toc';
+import { MDXContent } from 'mdx/types';
+import { E as ExtractedReference } from './core-B6j6Fxse.cjs';
+export { p as Core, C as CoreOptions, j as EmitEntry, n as EmitOptions, i as Plugin, k as PluginContext, l as PluginOption, S as ServerContext, o as createCore } from './core-B6j6Fxse.cjs';
+import { Root } from 'mdast';
+import { C as CompiledMDXProperties } from './build-mdx-D-r3_eQL.cjs';
+import '@standard-schema/spec';
 import '@mdx-js/mdx';
-import 'mdx/types';
-import 'fumadocs-core/mdx-plugins';
-import 'fumadocs-core/server';
 import 'unified';
-import 'react';
 import 'zod';
-import '@standard-schema/spec';
-import '@fumadocs/mdx-remote';
+import 'chokidar';
+import 'react';
 
-declare const _runtime: Runtime;
-declare function createMDXSource<Doc extends PageData & BaseCollectionEntry, Meta extends MetaData & BaseCollectionEntry>(docs: Doc[], meta?: Meta[]): Source<{
-    pageData: Doc;
-    metaData: Meta;
-}>;
-interface ResolveOptions {
-    docs: BaseCollectionEntry[];
-    meta: BaseCollectionEntry[];
-    rootDir?: string;
+interface FileInfo {
+    /**
+     * virtualized path for Source API
+     */
+    path: string;
+    /**
+     * the file path in file system
+     */
+    fullPath: string;
+}
+interface DocData {
+    /**
+     * Compiled MDX content (as component)
+     */
+    body: MDXContent;
+    /**
+     * table of contents generated from content.
+     */
+    toc: TOCItemType[];
+    /**
+     * structured data for document search indexing.
+     */
+    structuredData: StructuredData;
+    /**
+     * Raw exports from the compiled MDX file.
+     */
+    _exports: Record<string, unknown>;
+    /**
+     * Last modified date of document file, obtained from version control.
+     *
+     * Only available when `lastModifiedTime` is enabled on global config.
+     */
+    lastModified?: Date;
+    /**
+     * extracted references (e.g. hrefs, paths), useful for analyzing relationships between pages.
+     */
+    extractedReferences?: ExtractedReference[];
+}
+interface DocMethods {
+    /**
+     * file info
+     */
+    info: FileInfo;
+    /**
+     * get document as text.
+     *
+     * - `type: raw` - read the original content from file system.
+     * - `type: processed` - get the processed Markdown content, only available when `includeProcessedMarkdown` is enabled on collection config.
+     */
+    getText: (type: 'raw' | 'processed') => Promise<string>;
+    getMDAST: () => Promise<Root>;
 }
-declare function resolveFiles({ docs, meta }: ResolveOptions): VirtualFile[];
+type MetaCollectionEntry<Data> = Data & {
+    /**
+     * file info
+     */
+    info: FileInfo;
+};
+type DocCollectionEntry<Frontmatter> = DocData & DocMethods & Frontmatter;
+type AsyncDocCollectionEntry<Frontmatter> = DocMethods & {
+    load: () => Promise<DocData>;
+} & Frontmatter;
+declare function createDocMethods(info: FileInfo, load: () => Promise<CompiledMDXProperties<any>>): DocMethods;
 
-export { _runtime, createMDXSource, resolveFiles };
+export { type AsyncDocCollectionEntry, type DocCollectionEntry, type DocData, type DocMethods, ExtractedReference, type FileInfo, type MetaCollectionEntry, createDocMethods };