fumadocs-mdx 8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Fuma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-P26LYDRL.mjs

@@ -0,0 +1,58 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __async
+};

package/dist/config.d.mts

@@ -0,0 +1,138 @@
+import * as next_dist_shared_lib_image_config from 'next/dist/shared/lib/image-config';
+import * as next_dist_lib_load_custom_routes from 'next/dist/lib/load-custom-routes';
+import * as next_dist_server_config_shared from 'next/dist/server/config-shared';
+import { NextConfig } from 'next';
+import { RemarkImageOptions, RehypeCodeOptions } from 'fumadocs-core/mdx-plugins';
+import { PluggableList } from 'unified';
+import { Configuration } from 'webpack';
+import { Options } from './loader-mdx.mjs';
+import '@mdx-js/mdx';
+
+type MDXOptions = Omit<NonNullable<Options>, 'rehypePlugins' | 'remarkPlugins'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkImageOptions?: RemarkImageOptions;
+    rehypeCodeOptions?: RehypeCodeOptions;
+};
+type ResolvePlugins = PluggableList | ((v: PluggableList) => PluggableList);
+interface NextDocsMDXOptions {
+    cwd?: string;
+    mdxOptions?: MDXOptions;
+    /**
+     * Where the root map.ts should be, relative to cwd
+     *
+     * @defaultValue `'./.map.ts'`
+     */
+    rootMapPath?: string;
+    /**
+     * Where the content directory should be, relative to cwd
+     *
+     * @defaultValue `'./content'`
+     */
+    rootContentPath?: string;
+}
+declare const createNextDocs: ({ mdxOptions, cwd, rootMapPath, rootContentPath, }?: NextDocsMDXOptions) => (nextConfig?: NextConfig) => {
+    webpack: (config: Configuration, options: next_dist_server_config_shared.WebpackConfigContext) => any;
+    exportPathMap?: ((defaultMap: next_dist_server_config_shared.ExportPathMap, ctx: {
+        dev: boolean;
+        dir: string;
+        outDir: string | null;
+        distDir: string;
+        buildId: string;
+    }) => next_dist_server_config_shared.ExportPathMap | Promise<next_dist_server_config_shared.ExportPathMap>) | undefined;
+    i18n?: next_dist_server_config_shared.I18NConfig | null | undefined;
+    eslint?: next_dist_server_config_shared.ESLintConfig | undefined;
+    typescript?: next_dist_server_config_shared.TypeScriptConfig | undefined;
+    headers?: (() => Promise<next_dist_lib_load_custom_routes.Header[]>) | undefined;
+    rewrites?: (() => Promise<next_dist_lib_load_custom_routes.Rewrite[] | {
+        beforeFiles: next_dist_lib_load_custom_routes.Rewrite[];
+        afterFiles: next_dist_lib_load_custom_routes.Rewrite[];
+        fallback: next_dist_lib_load_custom_routes.Rewrite[];
+    }>) | undefined;
+    redirects?: (() => Promise<next_dist_lib_load_custom_routes.Redirect[]>) | undefined;
+    excludeDefaultMomentLocales?: boolean | undefined;
+    trailingSlash?: boolean | undefined;
+    env?: Record<string, string | undefined> | undefined;
+    distDir?: string | undefined;
+    cleanDistDir?: boolean | undefined;
+    assetPrefix?: string | undefined;
+    cacheHandler?: string | undefined;
+    cacheMaxMemorySize?: number | undefined;
+    useFileSystemPublicRoutes?: boolean | undefined;
+    generateBuildId?: (() => string | Promise<string | null> | null) | undefined;
+    generateEtags?: boolean | undefined;
+    pageExtensions?: string[] | undefined;
+    compress?: boolean | undefined;
+    analyticsId?: string | undefined;
+    poweredByHeader?: boolean | undefined;
+    images?: Partial<next_dist_shared_lib_image_config.ImageConfigComplete> | undefined;
+    devIndicators?: {
+        buildActivity?: boolean | undefined;
+        buildActivityPosition?: "bottom-right" | "bottom-left" | "top-right" | "top-left" | undefined;
+    } | undefined;
+    onDemandEntries?: {
+        maxInactiveAge?: number | undefined;
+        pagesBufferLength?: number | undefined;
+    } | undefined;
+    amp?: {
+        canonicalBase?: string | undefined;
+    } | undefined;
+    basePath?: string | undefined;
+    sassOptions?: {
+        [key: string]: any;
+    } | undefined;
+    productionBrowserSourceMaps?: boolean | undefined;
+    optimizeFonts?: boolean | undefined;
+    reactProductionProfiling?: boolean | undefined;
+    reactStrictMode?: boolean | null | undefined;
+    publicRuntimeConfig?: {
+        [key: string]: any;
+    } | undefined;
+    serverRuntimeConfig?: {
+        [key: string]: any;
+    } | undefined;
+    httpAgentOptions?: {
+        keepAlive?: boolean | undefined;
+    } | undefined;
+    outputFileTracing?: boolean | undefined;
+    staticPageGenerationTimeout?: number | undefined;
+    crossOrigin?: false | "anonymous" | "use-credentials" | undefined;
+    swcMinify?: boolean | undefined;
+    compiler?: {
+        reactRemoveProperties?: boolean | {
+            properties?: string[] | undefined;
+        } | undefined;
+        relay?: {
+            src: string;
+            artifactDirectory?: string | undefined;
+            language?: "typescript" | "javascript" | "flow" | undefined;
+            eagerEsModules?: boolean | undefined;
+        } | undefined;
+        removeConsole?: boolean | {
+            exclude?: string[] | undefined;
+        } | undefined;
+        styledComponents?: boolean | next_dist_server_config_shared.StyledComponentsConfig | undefined;
+        emotion?: boolean | next_dist_server_config_shared.EmotionConfig | undefined;
+    } | undefined;
+    output?: "standalone" | "export" | undefined;
+    transpilePackages?: string[] | undefined;
+    skipMiddlewareUrlNormalize?: boolean | undefined;
+    skipTrailingSlashRedirect?: boolean | undefined;
+    modularizeImports?: Record<string, {
+        transform: string | Record<string, string>;
+        preventFullImport?: boolean | undefined;
+        skipDefaultConversion?: boolean | undefined;
+    }> | undefined;
+    logging?: {
+        fetches?: {
+            fullUrl?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    experimental?: next_dist_server_config_shared.ExperimentalConfig | undefined;
+};
+
+export { createNextDocs as default };

package/dist/config.mjs

@@ -0,0 +1,176 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-P26LYDRL.mjs";
+
+// src/config.ts
+import path from "path";
+import {
+  rehypeCode,
+  remarkGfm,
+  remarkStructure,
+  remarkHeading,
+  remarkImage
+} from "fumadocs-core/mdx-plugins";
+
+// src/webpack-plugins/next-docs.ts
+import fs from "fs";
+var firstLoad = true;
+var content = `
+/** Auto-generated **/
+declare const map: Record<string, unknown>
+
+export { map }
+`.trim();
+var NextDocsWebpackPlugin = class _NextDocsWebpackPlugin {
+  constructor(options) {
+    this.options = options;
+  }
+  apply(compiler) {
+    const logger = compiler.getInfrastructureLogger(_NextDocsWebpackPlugin.name);
+    compiler.hooks.beforeCompile.tap(_NextDocsWebpackPlugin.name, () => {
+      if (firstLoad && !fs.existsSync(this.options.rootMapFile)) {
+        fs.writeFileSync(this.options.rootMapFile, content);
+        logger.info("Created map.ts file for you automatically");
+        firstLoad = false;
+      }
+    });
+  }
+};
+
+// src/mdx-plugins/utils.ts
+import { valueToEstree } from "estree-util-value-to-estree";
+function getMdastExport(name, value) {
+  return {
+    type: "mdxjsEsm",
+    value: "",
+    data: {
+      estree: {
+        type: "Program",
+        sourceType: "module",
+        body: [
+          {
+            type: "ExportNamedDeclaration",
+            specifiers: [],
+            source: null,
+            declaration: {
+              type: "VariableDeclaration",
+              kind: "const",
+              declarations: [
+                {
+                  type: "VariableDeclarator",
+                  id: {
+                    type: "Identifier",
+                    name
+                  },
+                  init: valueToEstree(value)
+                }
+              ]
+            }
+          }
+        ]
+      }
+    }
+  };
+}
+
+// src/mdx-plugins/remark-exports.ts
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data))
+        return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
+
+// src/config.ts
+function pluginOption(def, options = []) {
+  const list = def(Array.isArray(options) ? options : []);
+  if (typeof options === "function") {
+    return options(list);
+  }
+  return list;
+}
+var createNextDocs = ({
+  mdxOptions = {},
+  cwd = process.cwd(),
+  rootMapPath = "./.map.ts",
+  rootContentPath = "./content"
+} = {}) => (nextConfig = {}) => {
+  var _a;
+  const valueToExport = [
+    "structuredData",
+    "toc",
+    "frontmatter",
+    "lastModified",
+    ...(_a = mdxOptions.valueToExport) != null ? _a : []
+  ];
+  const _mapPath = path.resolve(cwd, rootMapPath);
+  const remarkPlugins = pluginOption(
+    (v) => [
+      remarkGfm,
+      remarkHeading,
+      [remarkImage, mdxOptions.remarkImageOptions],
+      ...v,
+      remarkStructure,
+      [remarkMdxExport, { values: valueToExport }]
+    ],
+    mdxOptions.remarkPlugins
+  );
+  const rehypePlugins = pluginOption(
+    (v) => [[rehypeCode, mdxOptions.rehypeCodeOptions], ...v],
+    mdxOptions.rehypePlugins
+  );
+  return __spreadValues(__spreadValues({}, nextConfig), {
+    webpack: (config, options) => {
+      var _a2, _b, _c;
+      config.resolve || (config.resolve = {});
+      const alias = config.resolve.alias;
+      alias["next-mdx-import-source-file"] = [
+        "private-next-root-dir/src/mdx-components",
+        "private-next-root-dir/mdx-components",
+        "@mdx-js/react"
+      ];
+      config.module || (config.module = {});
+      (_a2 = config.module).rules || (_a2.rules = []);
+      config.module.rules.push(
+        {
+          test: /\.mdx?$/,
+          use: [
+            options.defaultLoaders.babel,
+            {
+              loader: "fumadocs-mdx/loader-mdx",
+              options: __spreadProps(__spreadValues({
+                providerImportSource: "next-mdx-import-source-file"
+              }, mdxOptions), {
+                remarkPlugins,
+                rehypePlugins
+              })
+            }
+          ]
+        },
+        {
+          test: _mapPath,
+          use: {
+            loader: "fumadocs-mdx/loader",
+            options: {
+              cwd,
+              rootContentPath,
+              mapPath: _mapPath
+            }
+          }
+        }
+      );
+      config.plugins || (config.plugins = []);
+      config.plugins.push(
+        new NextDocsWebpackPlugin({ rootMapFile: _mapPath })
+      );
+      return (_c = (_b = nextConfig.webpack) == null ? void 0 : _b.call(nextConfig, config, options)) != null ? _c : config;
+    }
+  });
+};
+export {
+  createNextDocs as default
+};

package/dist/index.d.mts

@@ -0,0 +1,79 @@
+import { MetaData, PageData, Source } from 'fumadocs-core/source';
+import { z } from 'zod';
+import { MDXProps } from 'mdx/types';
+import { StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TableOfContents } from 'fumadocs-core/server';
+
+declare const defaultSchemas: {
+    frontmatter: z.ZodObject<{
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+    }, {
+        title: string;
+        description?: string | undefined;
+        icon?: string | undefined;
+    }>;
+    meta: z.ZodObject<{
+        title: z.ZodOptional<z.ZodString>;
+        pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        root: z.ZodOptional<z.ZodBoolean>;
+        icon: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        title?: string | undefined;
+        pages?: string[] | undefined;
+        root?: boolean | undefined;
+        icon?: string | undefined;
+    }, {
+        title?: string | undefined;
+        pages?: string[] | undefined;
+        root?: boolean | undefined;
+        icon?: string | undefined;
+    }>;
+};
+
+type SourceFile<Meta extends MetaData, Fronmatter extends PageData> = {
+    type: 'meta';
+    path: string;
+    data: Meta;
+} | {
+    type: 'page';
+    path: string;
+    data: MDXPageData<Fronmatter>;
+};
+/**
+ * Defalt MDX properties
+ */
+interface MDXExport<Frontmatter = PageData> {
+    default: (props: MDXProps) => JSX.Element;
+    frontmatter: Frontmatter;
+    lastModified: number | undefined;
+    toc: TableOfContents;
+    structuredData: StructuredData;
+}
+type MDXPageData<Frontmatter extends PageData = PageData> = Omit<Frontmatter, 'exports'> & {
+    exports: Omit<MDXExport<Frontmatter>, 'frontmatter'>;
+};
+
+interface SourceOptions<Frontmatter, Meta> {
+    schema?: {
+        frontmatter?: Frontmatter;
+        meta?: Meta;
+    };
+}
+interface LoadOptions<Frontmatter, Meta> extends SourceOptions<Frontmatter, Meta> {
+    rootDir?: string;
+}
+type DefaultFrontmatter = (typeof defaultSchemas)['frontmatter'];
+type DefaultMeta = (typeof defaultSchemas)['meta'];
+declare function createMDXSource<Frontmatter extends DefaultFrontmatter = DefaultFrontmatter, Meta extends DefaultMeta = DefaultMeta>(map: Record<string, unknown>, options?: SourceOptions<Frontmatter, Meta>): Source<{
+    metaData: z.infer<Meta>;
+    pageData: MDXPageData<z.infer<Frontmatter>>;
+}>;
+declare function loadMDXSource<Frontmatter extends DefaultFrontmatter = DefaultFrontmatter, Meta extends DefaultMeta = DefaultMeta>(map: Record<string, unknown>, options?: LoadOptions<Frontmatter, Meta>): SourceFile<z.infer<Meta>, z.infer<Frontmatter>>[];
+
+export { type MDXExport, type MDXPageData, type SourceFile, createMDXSource, defaultSchemas, loadMDXSource };

package/dist/index.mjs

@@ -0,0 +1,93 @@
+import {
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-P26LYDRL.mjs";
+
+// src/resolve-files.ts
+import path from "path";
+
+// src/utils/schema.ts
+import { z } from "zod";
+var metaSchema = z.object({
+  title: z.string().optional(),
+  pages: z.array(z.string()).optional(),
+  root: z.boolean().optional(),
+  icon: z.string().optional()
+});
+var frontmatterSchema = z.object({
+  title: z.string(),
+  description: z.string().optional(),
+  icon: z.string().optional()
+});
+var defaultSchemas = {
+  frontmatter: frontmatterSchema,
+  meta: metaSchema
+};
+
+// src/resolve-files.ts
+var pageTypes = [".md", ".mdx"];
+var metaTypes = [".json"];
+function parse(schema, object, errorName) {
+  const result = schema.safeParse(object);
+  if (!result.success) {
+    throw new Error(`Invalid ${errorName}: ${result.error.toString()}`);
+  }
+  return result.data;
+}
+function resolveFiles({
+  map,
+  rootDir = "",
+  schema = {}
+}) {
+  var _a, _c;
+  const outputs = [];
+  for (const [file, value] of Object.entries(map)) {
+    if (!file.startsWith(rootDir))
+      continue;
+    const parsed = path.parse(file);
+    if (metaTypes.includes(parsed.ext)) {
+      outputs.push({
+        type: "meta",
+        path: file,
+        data: parse((_a = schema.meta) != null ? _a : defaultSchemas.meta, value, file)
+      });
+      continue;
+    }
+    if (pageTypes.includes(parsed.ext)) {
+      const _b = value, { frontmatter } = _b, data = __objRest(_b, ["frontmatter"]);
+      const parsedFrontmatter = parse(
+        (_c = schema.frontmatter) != null ? _c : defaultSchemas.frontmatter,
+        frontmatter,
+        file
+      );
+      outputs.push({
+        type: "page",
+        path: file,
+        data: __spreadProps(__spreadValues({}, parsedFrontmatter), {
+          exports: data
+        })
+      });
+      continue;
+    }
+    console.warn("Unknown Type:", parsed.ext);
+  }
+  return outputs;
+}
+
+// src/create.ts
+function createMDXSource(map, options) {
+  return {
+    files: (rootDir) => loadMDXSource(map, __spreadProps(__spreadValues({}, options), { rootDir }))
+  };
+}
+function loadMDXSource(map, options) {
+  return resolveFiles(__spreadValues({
+    map
+  }, options));
+}
+export {
+  createMDXSource,
+  defaultSchemas,
+  loadMDXSource
+};

package/dist/loader-mdx.d.mts

@@ -0,0 +1,27 @@
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { LoaderContext } from 'webpack';
+
+interface Options extends ProcessorOptions {
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+}
+interface NextDocsBuildInfo {
+    __next_docs?: {
+        path: string;
+        /**
+         * `vfile.data` parsed from file
+         */
+        data: unknown;
+    };
+}
+/**
+ * Load MDX/markdown files
+ *
+ * it supports frontmatter by parsing and injecting the data in `vfile.data.frontmatter`
+ */
+declare function loader(this: LoaderContext<Options>, source: string, callback: LoaderContext<Options>['callback']): Promise<void>;
+
+export { type NextDocsBuildInfo, type Options, loader as default };

package/dist/loader-mdx.mjs

@@ -0,0 +1,93 @@
+import {
+  __async,
+  __objRest,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-P26LYDRL.mjs";
+
+// src/loader-mdx.ts
+import path2 from "path";
+import { createProcessor } from "@mdx-js/mdx";
+import grayMatter from "gray-matter";
+
+// src/utils/git-timestamp.ts
+import path from "path";
+import fs from "fs";
+import { spawn } from "cross-spawn";
+var cache = /* @__PURE__ */ new Map();
+function getGitTimestamp(file) {
+  const cachedTimestamp = cache.get(file);
+  if (cachedTimestamp)
+    return Promise.resolve(cachedTimestamp);
+  return new Promise((resolve, reject) => {
+    const cwd = path.dirname(file);
+    if (!fs.existsSync(cwd)) {
+      resolve(void 0);
+      return;
+    }
+    const fileName = path.basename(file);
+    const child = spawn("git", ["log", "-1", '--pretty="%ai"', fileName], {
+      cwd
+    });
+    let output;
+    child.stdout.on("data", (d) => output = new Date(String(d)));
+    child.on("close", () => {
+      if (output)
+        cache.set(file, output);
+      resolve(output);
+    });
+    child.on("error", reject);
+  });
+}
+
+// src/loader-mdx.ts
+var cache2 = /* @__PURE__ */ new Map();
+function loader(source, callback) {
+  return __async(this, null, function* () {
+    var _b, _c;
+    this.cacheable(true);
+    const context = this.context;
+    const filePath = this.resourcePath;
+    const _a = this.getOptions(), { lastModifiedTime } = _a, options = __objRest(_a, ["lastModifiedTime"]);
+    const { content, data: frontmatter } = grayMatter(source);
+    const detectedFormat = filePath.endsWith(".mdx") ? "mdx" : "md";
+    const format = (_b = options.format) != null ? _b : detectedFormat;
+    let timestamp;
+    let processor = cache2.get(format);
+    if (processor === void 0) {
+      processor = createProcessor(__spreadProps(__spreadValues({}, options), {
+        development: this.mode === "development",
+        format
+      }));
+      cache2.set(format, processor);
+    }
+    if (lastModifiedTime === "git")
+      timestamp = (_c = yield getGitTimestamp(filePath)) == null ? void 0 : _c.getTime();
+    processor.process({
+      value: content,
+      path: filePath,
+      data: {
+        lastModified: timestamp,
+        frontmatter
+      }
+    }).then(
+      (file) => {
+        var _a2;
+        const info = (_a2 = this._module) == null ? void 0 : _a2.buildInfo;
+        info.__next_docs = {
+          path: filePath,
+          data: file.data
+        };
+        callback(void 0, String(file.value), file.map || void 0);
+      },
+      (error) => {
+        const fpath = path2.relative(context, filePath);
+        error.message = `${fpath}:${error.name}: ${error.message}`;
+        callback(error);
+      }
+    );
+  });
+}
+export {
+  loader as default
+};

package/dist/loader.d.mts

@@ -0,0 +1,13 @@
+import { LoaderContext } from 'webpack';
+
+interface LoaderOptions {
+    rootContentPath: string;
+    mapPath: string;
+    cwd: string;
+}
+/**
+ * Load the root `.map.ts` file
+ */
+declare function loader(this: LoaderContext<LoaderOptions>, _source: string, callback: LoaderContext<LoaderOptions>['callback']): void;
+
+export { type LoaderOptions, loader as default };

package/dist/loader.mjs

@@ -0,0 +1,31 @@
+import "./chunk-P26LYDRL.mjs";
+
+// src/loader.ts
+import path from "path";
+import fg from "fast-glob";
+function loader(_source, callback) {
+  const options = this.getOptions();
+  this.cacheable(true);
+  this.addContextDependency(path.resolve(options.cwd, options.rootContentPath));
+  callback(null, buildMap(options));
+}
+function buildMap({ cwd, rootContentPath, mapPath }) {
+  const mapDir = path.dirname(mapPath);
+  const absoluteContentPath = path.resolve(cwd, rootContentPath);
+  const files = fg.sync("./**/*.{md,mdx,json}", {
+    cwd: absoluteContentPath
+  });
+  const entries = files.map((file) => {
+    let importPath = path.relative(mapDir, path.join(absoluteContentPath, file)).replace(path.sep, "/");
+    if (!importPath.startsWith(".")) {
+      importPath = `./${importPath}`;
+    }
+    return `${JSON.stringify(file)}: await import(${JSON.stringify(
+      importPath
+    )})`;
+  });
+  return `export const map = {${entries.join(",")}}`;
+}
+export {
+  loader as default
+};

package/loader-mdx.js

@@ -0,0 +1,8 @@
+/* eslint-env node -- Node.js env */
+
+module.exports = function loader(code) {
+  const callback = this.async();
+  import('./dist/loader-mdx.mjs').then((mod) =>
+    mod.default.call(this, code, callback),
+  );
+};

package/loader.js

@@ -0,0 +1,8 @@
+/* eslint-env node -- Node.js env */
+
+module.exports = function loader(code) {
+  const callback = this.async();
+  import('./dist/loader.mjs').then((mod) =>
+    mod.default.call(this, code, callback),
+  );
+};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "fumadocs-mdx",
+  "version": "8.0.0",
+  "description": "The built-in source for Fumadocs",
+  "keywords": [
+    "NextJs",
+    "Docs"
+  ],
+  "homepage": "https://fumadocs.vercel.app",
+  "repository": "github:fuma-nama/next-docs",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "exports": {
+    "./loader": "./loader.js",
+    "./loader-mdx": "./loader-mdx.js",
+    "./config": {
+      "import": "./dist/config.mjs",
+      "types": "./dist/config.d.mts"
+    },
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.mts"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.mts",
+  "typesVersions": {
+    "*": {
+      "config": [
+        "./dist/config.d.mts"
+      ]
+    }
+  },
+  "files": [
+    "dist/*",
+    "loader-mdx.js",
+    "loader.js"
+  ],
+  "dependencies": {
+    "@mdx-js/mdx": "^3.0.0",
+    "cross-spawn": "^7.0.3",
+    "estree-util-value-to-estree": "^3.0.1",
+    "fast-glob": "^3.3.1",
+    "gray-matter": "^4.0.3",
+    "zod": "^3.22.4",
+    "fumadocs-core": "8.0.0"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.4",
+    "@types/mdast": "^4.0.3",
+    "@types/mdx": "^2.0.8",
+    "@types/react": "18.2.0",
+    "next": "14.1.0",
+    "unified": "^11.0.4",
+    "webpack": "^5.89.0",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "peerDependencies": {
+    "next": ">= 13.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "lint": "eslint .",
+    "types:check": "tsc --noEmit"
+  }
+}