@acmekit/docs-bundler 2.13.41

package/dist/index.js

@@ -0,0 +1,751 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  build: () => build,
+  develop: () => develop,
+  serve: () => serve
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/commands/develop.ts
+var import_express = __toESM(require("express"));
+var import_fs2 = __toESM(require("fs"));
+var import_path4 = __toESM(require("path"));
+
+// src/utils/config.ts
+var import_docs_shared = require("@acmekit/docs-shared");
+var import_path3 = __toESM(require("path"));
+
+// src/plugins/inject-tailwindcss.ts
+var import_path = __toESM(require("path"));
+function injectTailwindCSS(options) {
+  return {
+    name: "acmekit:docs-tailwind",
+    config: async () => {
+      const docsUiPath = import_path.default.dirname(
+        require.resolve("@acmekit/docs-ui/package.json")
+      );
+      const docsAppPath = import_path.default.dirname(
+        require.resolve("@acmekit/docs-app/package.json")
+      );
+      const sourceExtensions = (options.sources || []).map(
+        (source) => `${source}/src/docs/**/*.{js,jsx,ts,tsx,mdx,md}`
+      );
+      const pluginExtensions = (options.plugins || []).map(
+        (plugin) => `${plugin}/**/*.{js,jsx,ts,tsx,mdx,md}`
+      );
+      return {
+        css: {
+          postcss: {
+            plugins: [
+              require("tailwindcss")({
+                presets: [require("@acmekit/docs-tailwind").default],
+                content: [
+                  `${options.entry}/**/*.{js,jsx,ts,tsx}`,
+                  `${docsAppPath}/src/**/*.{js,jsx,ts,tsx}`,
+                  `${docsUiPath}/src/**/*.{js,jsx,ts,tsx}`,
+                  ...sourceExtensions,
+                  ...pluginExtensions
+                ],
+                darkMode: ["class", `[data-theme="dark"]`]
+              })
+            ]
+          }
+        }
+      };
+    }
+  };
+}
+
+// ../../../node_modules/unist-util-is/lib/index.js
+var convert = (
+  // Note: overloads in JSDoc can’t yet use different `@template`s.
+  /**
+   * @type {(
+   *   (<Condition extends string>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & {type: Condition}) &
+   *   (<Condition extends Props>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Condition) &
+   *   (<Condition extends TestFunction>(test: Condition) => (node: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node & Predicate<Condition, Node>) &
+   *   ((test?: null | undefined) => (node?: unknown, index?: number | null | undefined, parent?: Parent | null | undefined, context?: unknown) => node is Node) &
+   *   ((test?: Test) => Check)
+   * )}
+   */
+  /**
+   * @param {Test} [test]
+   * @returns {Check}
+   */
+  (function(test) {
+    if (test === null || test === void 0) {
+      return ok;
+    }
+    if (typeof test === "function") {
+      return castFactory(test);
+    }
+    if (typeof test === "object") {
+      return Array.isArray(test) ? anyFactory(test) : (
+        // Cast because `ReadonlyArray` goes into the above but `isArray`
+        // narrows to `Array`.
+        propertiesFactory(
+          /** @type {Props} */
+          test
+        )
+      );
+    }
+    if (typeof test === "string") {
+      return typeFactory(test);
+    }
+    throw new Error("Expected function, string, or object as test");
+  })
+);
+function anyFactory(tests) {
+  const checks = [];
+  let index = -1;
+  while (++index < tests.length) {
+    checks[index] = convert(tests[index]);
+  }
+  return castFactory(any);
+  function any(...parameters) {
+    let index2 = -1;
+    while (++index2 < checks.length) {
+      if (checks[index2].apply(this, parameters)) return true;
+    }
+    return false;
+  }
+}
+function propertiesFactory(check) {
+  const checkAsRecord = (
+    /** @type {Record<string, unknown>} */
+    check
+  );
+  return castFactory(all);
+  function all(node) {
+    const nodeAsRecord = (
+      /** @type {Record<string, unknown>} */
+      /** @type {unknown} */
+      node
+    );
+    let key;
+    for (key in check) {
+      if (nodeAsRecord[key] !== checkAsRecord[key]) return false;
+    }
+    return true;
+  }
+}
+function typeFactory(check) {
+  return castFactory(type);
+  function type(node) {
+    return node && node.type === check;
+  }
+}
+function castFactory(testFunction) {
+  return check;
+  function check(value, index, parent) {
+    return Boolean(
+      looksLikeANode(value) && testFunction.call(
+        this,
+        value,
+        typeof index === "number" ? index : void 0,
+        parent || void 0
+      )
+    );
+  }
+}
+function ok() {
+  return true;
+}
+function looksLikeANode(value) {
+  return value !== null && typeof value === "object" && "type" in value;
+}
+
+// ../../../node_modules/unist-util-visit-parents/lib/color.node.js
+function color(d) {
+  return "\x1B[33m" + d + "\x1B[39m";
+}
+
+// ../../../node_modules/unist-util-visit-parents/lib/index.js
+var empty = [];
+var CONTINUE = true;
+var EXIT = false;
+var SKIP = "skip";
+function visitParents(tree, test, visitor, reverse) {
+  let check;
+  if (typeof test === "function" && typeof visitor !== "function") {
+    reverse = visitor;
+    visitor = test;
+  } else {
+    check = test;
+  }
+  const is2 = convert(check);
+  const step = reverse ? -1 : 1;
+  factory(tree, void 0, [])();
+  function factory(node, index, parents) {
+    const value = (
+      /** @type {Record<string, unknown>} */
+      node && typeof node === "object" ? node : {}
+    );
+    if (typeof value.type === "string") {
+      const name = (
+        // `hast`
+        typeof value.tagName === "string" ? value.tagName : (
+          // `xast`
+          typeof value.name === "string" ? value.name : void 0
+        )
+      );
+      Object.defineProperty(visit2, "name", {
+        value: "node (" + color(node.type + (name ? "<" + name + ">" : "")) + ")"
+      });
+    }
+    return visit2;
+    function visit2() {
+      let result = empty;
+      let subresult;
+      let offset;
+      let grandparents;
+      if (!test || is2(node, index, parents[parents.length - 1] || void 0)) {
+        result = toResult(visitor(node, parents));
+        if (result[0] === EXIT) {
+          return result;
+        }
+      }
+      if ("children" in node && node.children) {
+        const nodeAsParent = (
+          /** @type {UnistParent} */
+          node
+        );
+        if (nodeAsParent.children && result[0] !== SKIP) {
+          offset = (reverse ? nodeAsParent.children.length : -1) + step;
+          grandparents = parents.concat(nodeAsParent);
+          while (offset > -1 && offset < nodeAsParent.children.length) {
+            const child = nodeAsParent.children[offset];
+            subresult = factory(child, offset, grandparents)();
+            if (subresult[0] === EXIT) {
+              return subresult;
+            }
+            offset = typeof subresult[1] === "number" ? subresult[1] : offset + step;
+          }
+        }
+      }
+      return result;
+    }
+  }
+}
+function toResult(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "number") {
+    return [CONTINUE, value];
+  }
+  return value === null || value === void 0 ? empty : [value];
+}
+
+// ../../../node_modules/unist-util-visit/lib/index.js
+function visit(tree, testOrVisitor, visitorOrReverse, maybeReverse) {
+  let reverse;
+  let test;
+  let visitor;
+  if (typeof testOrVisitor === "function" && typeof visitorOrReverse !== "function") {
+    test = void 0;
+    visitor = testOrVisitor;
+    reverse = visitorOrReverse;
+  } else {
+    test = testOrVisitor;
+    visitor = visitorOrReverse;
+    reverse = maybeReverse;
+  }
+  visitParents(tree, test, overload, reverse);
+  function overload(node, parents) {
+    const parent = parents[parents.length - 1];
+    const index = parent ? parent.children.indexOf(node) : void 0;
+    return visitor(node, index, parent);
+  }
+}
+
+// src/plugins/remark-lazy-images.ts
+function remarkLazyImages() {
+  return (tree) => {
+    visit(tree, "image", (node) => {
+      const data = node.data || (node.data = {});
+      const hProperties = data.hProperties || (data.hProperties = {});
+      hProperties.loading = "lazy";
+      hProperties.decoding = "async";
+    });
+  };
+}
+
+// src/plugins/inject-mdx.ts
+function injectMdx() {
+  let transformFn;
+  let resolveIdFn;
+  let loadFn;
+  return {
+    name: "acmekit:docs-mdx",
+    enforce: "pre",
+    async configResolved() {
+      const mdx = (await import("@mdx-js/rollup")).default;
+      const remarkGfm = (await import("remark-gfm")).default;
+      const remarkFrontmatter = (await import("remark-frontmatter")).default;
+      const remarkMdxFrontmatter = (await import("remark-mdx-frontmatter")).default;
+      const rehypeSlug = (await import("rehype-slug")).default;
+      const rehypeAutolinkHeadings = (await import("rehype-autolink-headings")).default;
+      const mdxPlugin = mdx({
+        remarkPlugins: [
+          remarkGfm,
+          remarkFrontmatter,
+          [remarkMdxFrontmatter, { name: "frontmatter" }],
+          remarkLazyImages
+        ],
+        rehypePlugins: [
+          rehypeSlug,
+          [rehypeAutolinkHeadings, { behavior: "wrap" }]
+        ],
+        providerImportSource: "@mdx-js/react"
+      });
+      transformFn = mdxPlugin.transform;
+      resolveIdFn = mdxPlugin.resolveId;
+      loadFn = mdxPlugin.load;
+    },
+    transform(code, id) {
+      if (transformFn) {
+        return transformFn.call(this, code, id);
+      }
+    },
+    resolveId(source, importer, options) {
+      if (resolveIdFn) {
+        return resolveIdFn.call(this, source, importer, options);
+      }
+    },
+    load(id) {
+      if (loadFn) {
+        return loadFn.call(this, id);
+      }
+    }
+  };
+}
+
+// src/utils/write-static-files.ts
+var import_fs = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_outdent = require("outdent");
+function writeFileIfChanged(filePath, content) {
+  if (import_fs.default.existsSync(filePath)) {
+    const existing = import_fs.default.readFileSync(filePath, "utf-8");
+    if (existing === content) return;
+  }
+  import_fs.default.writeFileSync(filePath, content);
+}
+async function writeStaticFiles(options) {
+  const outDir = import_path2.default.resolve(process.cwd(), ".acmekit/docs");
+  if (!import_fs.default.existsSync(outDir)) {
+    import_fs.default.mkdirSync(outDir, { recursive: true });
+  }
+  await writeHtmlFile(outDir);
+  await writeEntryFile(outDir, options.plugins);
+  await writeSSREntryFile(outDir);
+  await writeCSSFile(outDir);
+}
+async function writeHtmlFile(outDir) {
+  const html = import_outdent.outdent`
+    <!DOCTYPE html>
+    <html lang="en">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Documentation</title>
+      </head>
+      <body>
+        <div id="acmekit-docs"></div>
+        <script type="module" src="./entry.jsx"></script>
+      </body>
+    </html>
+  `;
+  writeFileIfChanged(import_path2.default.join(outDir, "index.html"), html);
+}
+async function writeEntryFile(outDir, plugins) {
+  const pluginImports = (plugins || []).map((p, i) => `import plugin${i} from "${p}"`).join("\n");
+  const pluginArray = (plugins || []).map((_, i) => `plugin${i}`).join(", ");
+  const entry = import_outdent.outdent`
+    import { DocsApp } from "@acmekit/docs-app"
+    import React from "react"
+    import ReactDOM from "react-dom/client"
+    import "./index.css"
+    ${pluginImports}
+
+    const plugins = [${pluginArray}]
+
+    const root = ReactDOM.createRoot(document.getElementById("acmekit-docs"))
+    root.render(
+      React.createElement(
+        React.StrictMode,
+        null,
+        React.createElement(DocsApp, { plugins })
+      )
+    )
+
+    if (import.meta.hot) {
+      import.meta.hot.accept()
+    }
+  `;
+  writeFileIfChanged(import_path2.default.join(outDir, "entry.jsx"), entry);
+}
+async function writeSSREntryFile(outDir) {
+  const entry = import_outdent.outdent`
+    export { render, routes } from "@acmekit/docs-app/entry-server"
+  `;
+  writeFileIfChanged(import_path2.default.join(outDir, "entry-server.jsx"), entry);
+}
+async function writeCSSFile(outDir) {
+  const themeCSS = require.resolve("@acmekit/docs-tailwind/theme.css");
+  const themeContent = import_fs.default.readFileSync(themeCSS, "utf-8");
+  const css = import_outdent.outdent`
+    ${themeContent}
+    @tailwind base;
+    @tailwind components;
+    @tailwind utilities;
+  `;
+  writeFileIfChanged(import_path2.default.join(outDir, "index.css"), css);
+}
+
+// src/plugins/write-static-files.ts
+function writeStaticFiles2(options) {
+  return {
+    name: "acmekit:docs-write-static-files",
+    buildStart: async () => {
+      await writeStaticFiles({ plugins: options.plugins });
+    }
+  };
+}
+
+// src/utils/config.ts
+async function getViteConfig(options) {
+  const { searchForWorkspaceRoot, mergeConfig } = await import("vite");
+  const { default: react } = await import("@vitejs/plugin-react");
+  const { default: docsPlugin } = await import("@acmekit/docs-vite-plugin");
+  const getPort = await import("get-port");
+  const hmrPort = process.env.HMR_PORT ? parseInt(process.env.HMR_PORT) : await getPort.default();
+  const hmrOptions = getHmrConfig(hmrPort);
+  const root = import_path3.default.resolve(process.cwd(), ".acmekit/docs");
+  const resolvePackageDist = (pkg) => {
+    try {
+      const pkgJson = require.resolve(`${pkg}/package.json`, {
+        paths: [process.cwd()]
+      });
+      return import_path3.default.resolve(import_path3.default.dirname(pkgJson), "dist");
+    } catch {
+      return null;
+    }
+  };
+  const watchPackages = ["@acmekit/docs-ui", "@acmekit/docs-app"];
+  const watchDirs = watchPackages.map((pkg) => resolvePackageDist(pkg)).filter(Boolean);
+  const baseConfig = {
+    root,
+    base: options.path,
+    cacheDir: import_path3.default.resolve(process.cwd(), "node_modules/.vite/acmekit-docs"),
+    build: {
+      emptyOutDir: true,
+      outDir: import_path3.default.resolve(process.cwd(), options.outDir)
+    },
+    optimizeDeps: {
+      include: [
+        "react",
+        "react/jsx-runtime",
+        "react-dom/client",
+        "react-router-dom",
+        "@mdx-js/react",
+        "@acmekit/ui",
+        "@acmekit/icons",
+        "@uidotdev/usehooks",
+        "clsx",
+        "prism-react-renderer",
+        "react-markdown",
+        "react-medium-image-zoom",
+        "react-tooltip",
+        "react-transition-group",
+        "react-uuid"
+      ],
+      exclude: [
+        ...import_docs_shared.DOCS_VIRTUAL_MODULES,
+        "@acmekit/docs-ui",
+        "@acmekit/docs-app"
+      ]
+    },
+    define: {
+      __DOCS_BASE__: JSON.stringify(options.path),
+      __BACKEND_URL__: JSON.stringify(options.backendUrl ?? "")
+    },
+    server: {
+      fs: {
+        allow: [searchForWorkspaceRoot(process.cwd())]
+      },
+      hmr: hmrOptions
+    },
+    plugins: [
+      watchWorkspacePackages(watchDirs),
+      writeStaticFiles2({
+        plugins: options.plugins
+      }),
+      injectTailwindCSS({
+        entry: root,
+        sources: options.sources,
+        plugins: options.plugins
+      }),
+      injectMdx(),
+      react(),
+      docsPlugin({
+        sources: options.sources,
+        basePath: options.path,
+        pluginSources: options.pluginSources
+      })
+    ]
+  };
+  let finalConfig = baseConfig;
+  if (options.vite) {
+    const customConfig = options.vite(baseConfig);
+    finalConfig = mergeConfig(baseConfig, customConfig);
+  }
+  return finalConfig;
+}
+function watchWorkspacePackages(dirs) {
+  return {
+    name: "watch-workspace-packages",
+    configureServer(server) {
+      if (!dirs.length) {
+        return;
+      }
+      for (const dir of dirs) {
+        server.watcher.add(dir);
+      }
+      server.watcher.on("change", (file) => {
+        if (dirs.some((dir) => file.startsWith(dir))) {
+          server.moduleGraph.invalidateAll();
+          server.ws.send({ type: "full-reload" });
+        }
+      });
+    }
+  };
+}
+function getHmrConfig(hmrPort) {
+  const options = {
+    port: hmrPort
+  };
+  if (process.env.HMR_PROTOCOL) {
+    options.protocol = process.env.HMR_PROTOCOL;
+  }
+  if (process.env.HMR_HOST) {
+    options.host = process.env.HMR_HOST;
+  }
+  if (process.env.HMR_CLIENT_PORT) {
+    options.clientPort = parseInt(process.env.HMR_CLIENT_PORT);
+  }
+  return options;
+}
+
+// src/commands/develop.ts
+var router = import_express.default.Router();
+function findTemplateFilePath(reqPath, root) {
+  if (reqPath.endsWith(".html")) {
+    const pathToTest = import_path4.default.join(root, reqPath);
+    if (import_fs2.default.existsSync(pathToTest)) {
+      return pathToTest;
+    }
+  }
+  const basePath = reqPath.slice(0, reqPath.lastIndexOf("/"));
+  const dirs = basePath.split("/");
+  while (dirs.length > 0) {
+    const pathToTest = import_path4.default.join(root, ...dirs, "index.html");
+    if (import_fs2.default.existsSync(pathToTest)) {
+      return pathToTest;
+    }
+    dirs.pop();
+  }
+  return void 0;
+}
+async function injectViteMiddleware(router3, middleware) {
+  router3.use((req, res, next) => {
+    req.path.endsWith(".html") ? next() : middleware(req, res, next);
+  });
+}
+async function injectHtmlMiddleware(router3, server) {
+  router3.use(async (req, res, next) => {
+    if (req.method !== "GET") {
+      return next();
+    }
+    const templateFilePath = findTemplateFilePath(req.path, server.config.root);
+    if (!templateFilePath) {
+      return next();
+    }
+    const template = import_fs2.default.readFileSync(templateFilePath, "utf8");
+    const html = await server.transformIndexHtml(
+      templateFilePath,
+      template,
+      req.originalUrl
+    );
+    res.send(html);
+  });
+}
+async function develop(options) {
+  const vite = await import("vite");
+  try {
+    const viteConfig = await getViteConfig(options);
+    const developConfig = {
+      mode: "development",
+      logLevel: "error",
+      appType: "spa",
+      server: {
+        middlewareMode: true
+      }
+    };
+    const mergedConfig = vite.mergeConfig(viteConfig, developConfig);
+    const server = await vite.createServer(mergedConfig);
+    await injectViteMiddleware(router, server.middlewares);
+    await injectHtmlMiddleware(router, server);
+  } catch (error) {
+    console.error(error);
+    throw new Error(
+      "Failed to start docs development server. See error above."
+    );
+  }
+  return router;
+}
+
+// src/commands/serve.ts
+var import_compression = __toESM(require("compression"));
+var import_express2 = require("express");
+var import_fs3 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+var router2 = (0, import_express2.Router)();
+async function serve(options) {
+  const htmlPath = import_path5.default.resolve(options.outDir, "index.html");
+  const indexExists = import_fs3.default.existsSync(htmlPath);
+  if (!indexExists) {
+    throw new Error(
+      `Could not find index.html in the docs build directory. Make sure to run 'acmekit build' before starting the server.`
+    );
+  }
+  const html = import_fs3.default.readFileSync(htmlPath, "utf-8");
+  const sendHtml = (_req, res) => {
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Vary", "Origin, Cache-Control");
+    res.send(html);
+  };
+  const setStaticHeaders = (res) => {
+    res.setHeader("Cache-Control", "max-age=31536000, immutable");
+    res.setHeader("Vary", "Origin, Cache-Control");
+  };
+  router2.use((0, import_compression.default)());
+  router2.get("/", sendHtml);
+  router2.use(
+    (0, import_express2.static)(options.outDir, {
+      setHeaders: setStaticHeaders
+    })
+  );
+  router2.get(`/*`, sendHtml);
+  return router2;
+}
+
+// src/commands/build.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+
+// src/utils/prerender.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+async function prerender(options) {
+  const { ssrEntry, htmlTemplate, outDir, basePath } = options;
+  const html = import_node_fs.default.readFileSync(htmlTemplate, "utf-8");
+  const { render, routes } = await import(ssrEntry);
+  for (const route of routes) {
+    try {
+      const rendered = render(route.path, basePath);
+      const pageHtml = html.replace(
+        '<div id="acmekit-docs"></div>',
+        `<div id="acmekit-docs">${rendered}</div>`
+      );
+      const routePath = route.path === "/" ? "" : route.path;
+      const dir = import_node_path.default.join(outDir, routePath);
+      if (!import_node_fs.default.existsSync(dir)) {
+        import_node_fs.default.mkdirSync(dir, { recursive: true });
+      }
+      import_node_fs.default.writeFileSync(import_node_path.default.join(dir, "index.html"), pageHtml);
+    } catch {
+    }
+  }
+}
+
+// src/commands/build.ts
+async function build(options) {
+  const vite = await import("vite");
+  const viteConfig = await getViteConfig(options);
+  const buildConfig = {
+    mode: "production",
+    logLevel: "error"
+  };
+  await vite.build(vite.mergeConfig(viteConfig, buildConfig));
+  const root = import_node_path2.default.resolve(process.cwd(), ".acmekit/docs");
+  const ssrOutDir = import_node_path2.default.resolve(process.cwd(), options.outDir, ".ssr");
+  try {
+    const ssrConfig = {
+      ...buildConfig,
+      root,
+      base: options.path,
+      build: {
+        ssr: import_node_path2.default.join(root, "entry-server.jsx"),
+        outDir: ssrOutDir,
+        emptyOutDir: true
+      },
+      plugins: viteConfig.plugins,
+      define: viteConfig.define,
+      resolve: viteConfig.resolve
+    };
+    await vite.build(vite.mergeConfig(viteConfig, ssrConfig));
+    const resolvedOutDir = import_node_path2.default.resolve(process.cwd(), options.outDir);
+    const ssrEntry = import_node_path2.default.join(ssrOutDir, "entry-server.js");
+    if (import_node_fs2.default.existsSync(ssrEntry)) {
+      await prerender({
+        ssrEntry,
+        htmlTemplate: import_node_path2.default.join(resolvedOutDir, "index.html"),
+        outDir: resolvedOutDir,
+        basePath: options.path
+      });
+    }
+    import_node_fs2.default.rmSync(ssrOutDir, { recursive: true, force: true });
+  } catch {
+    if (import_node_fs2.default.existsSync(ssrOutDir)) {
+      import_node_fs2.default.rmSync(ssrOutDir, { recursive: true, force: true });
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build,
+  develop,
+  serve
+});