odoro 1.0.9 → 2.0.0

package/dist/chunk-Q2KCMTB5.js

@@ -0,0 +1,741 @@
+#!/usr/bin/env node
+import { extractEntries, cssProviderFor } from './chunk-OMHEQVIW.js';
+import { transformHtmlWith, sourcePlugin, esbuildPluginsFrom, applyAlias, isBareSpecifier, readSuffix, textModule, urlModule, workerModule } from './chunk-WWTDEV4Y.js';
+import { info, colors, size, success, duration } from './chunk-7ZB5MAM6.js';
+import { existsSync } from 'fs';
+import { mkdir, writeFile, readFile, rm, cp, stat } from 'fs/promises';
+import { relative, resolve, dirname, join, basename, sep } from 'path';
+import { gzipSync } from 'zlib';
+import { build } from 'esbuild';
+import { pathToFileURL } from 'url';
+
+// src/build/prune.ts
+var GROUPS = /* @__PURE__ */ new Set(["media", "supports", "layer", "container", "scope"]);
+function parseCss(css) {
+  const nodes = [];
+  let i = 0;
+  let start = 0;
+  function advance() {
+    const c = css[i];
+    if (c === "\\") {
+      i += 2;
+      return;
+    }
+    if (c === "/" && css[i + 1] === "*") {
+      const end = css.indexOf("*/", i + 2);
+      i = end === -1 ? css.length : end + 2;
+      return;
+    }
+    if (c === '"' || c === "'") {
+      i += 1;
+      while (i < css.length && css[i] !== c) {
+        i += css[i] === "\\" ? 2 : 1;
+      }
+      i += 1;
+      return;
+    }
+    i += 1;
+  }
+  while (i < css.length) {
+    const c = css[i];
+    if (c === "{") {
+      const prelude = css.slice(start, i).trim();
+      let depth = 1;
+      i += 1;
+      const bodyStart = i;
+      while (i < css.length && depth > 0) {
+        const d = css[i];
+        if (d === "{") {
+          depth += 1;
+          i += 1;
+        } else if (d === "}") {
+          depth -= 1;
+          i += 1;
+        } else {
+          advance();
+        }
+      }
+      const body = css.slice(bodyStart, i - 1);
+      if (prelude.startsWith("@")) {
+        const name = /^@([a-zA-Z-]+)/.exec(prelude)?.[1] ?? "";
+        nodes.push(
+          GROUPS.has(name) ? { kind: "group", prelude, children: parseCss(body) } : (
+            // `@keyframes`, `@font-face`, `@property`: copied as they are.
+            { kind: "raw", text: `${prelude}{${body}}` }
+          )
+        );
+      } else if (prelude.length > 0) {
+        nodes.push({ kind: "rule", selector: prelude, body });
+      }
+      start = i;
+      continue;
+    }
+    if (c === ";" && css.slice(start, i).trim().startsWith("@")) {
+      nodes.push({ kind: "raw", text: `${css.slice(start, i).trim()};` });
+      i += 1;
+      start = i;
+      continue;
+    }
+    advance();
+  }
+  return nodes;
+}
+function writeCss(nodes) {
+  return nodes.map((node) => {
+    if (node.kind === "raw") return node.text;
+    if (node.kind === "rule") return `${node.selector}{${node.body}}`;
+    return `${node.prelude}{${writeCss(node.children)}}`;
+  }).join("\n");
+}
+function classesIn(selector) {
+  const classes = [];
+  const pattern = /(?<!\\)\.((?:\\.|[\w-])+)/g;
+  for (const found of selector.matchAll(pattern)) {
+    classes.push(found[1].replaceAll(/\\(.)/g, "$1"));
+  }
+  return classes;
+}
+function wordsIn(text) {
+  const words = /* @__PURE__ */ new Set();
+  const pattern = /[A-Za-z0-9_][A-Za-z0-9_:/.[\]%@-]*/g;
+  for (const found of text.matchAll(pattern)) words.add(found[0]);
+  return words;
+}
+function isUtility(className, prefix) {
+  const bare = className.slice(className.lastIndexOf(":") + 1);
+  return bare.startsWith(prefix);
+}
+function isKept(className, used, safelist) {
+  if (used.has(className)) return true;
+  for (const rule of safelist) {
+    if (typeof rule === "string" ? rule === className : rule.test(className)) return true;
+  }
+  return false;
+}
+function prune(css, sources, options = {}) {
+  const prefix = options.prefix ?? "o-";
+  const safelist = options.safelist ?? [];
+  const used = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    for (const word of wordsIn(source)) used.add(word);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const survivors = /* @__PURE__ */ new Set();
+  function filterSelector(selector) {
+    const kept = splitSelectors(selector).filter((one) => {
+      const utilities = classesIn(one).filter((c) => isUtility(c, prefix));
+      if (utilities.length === 0) return true;
+      for (const className of utilities) seen.add(className);
+      const survives = utilities.every((c) => isKept(c, used, safelist));
+      if (survives) for (const className of utilities) survivors.add(className);
+      return survives;
+    });
+    return kept.length === 0 ? void 0 : kept.join(",");
+  }
+  function filterNodes(nodes) {
+    const kept = [];
+    for (const node of nodes) {
+      if (node.kind === "raw") {
+        kept.push(node);
+        continue;
+      }
+      if (node.kind === "rule") {
+        const selector = filterSelector(node.selector);
+        if (selector !== void 0) kept.push({ ...node, selector });
+        continue;
+      }
+      const children = filterNodes(node.children);
+      if (children.length > 0) kept.push({ ...node, children });
+    }
+    return kept;
+  }
+  const pruned = writeCss(filterNodes(parseCss(css)));
+  return {
+    css: pruned,
+    bytesBefore: Buffer.byteLength(css),
+    bytesAfter: Buffer.byteLength(pruned),
+    kept: survivors.size,
+    removed: seen.size - survivors.size
+  };
+}
+function splitSelectors(selector) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < selector.length) {
+    const c = selector[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      i += 1;
+      while (i < selector.length && selector[i] !== c) {
+        i += selector[i] === "\\" ? 2 : 1;
+      }
+      i += 1;
+      continue;
+    }
+    if (c === "(" || c === "[") depth += 1;
+    else if (c === ")" || c === "]") depth -= 1;
+    else if (c === "," && depth === 0) {
+      parts.push(selector.slice(start, i).trim());
+      start = i + 1;
+    }
+    i += 1;
+  }
+  parts.push(selector.slice(start).trim());
+  return parts.filter((part) => part.length > 0);
+}
+
+// src/build/alias-plugin.ts
+function aliasPlugin(config) {
+  return {
+    name: "odoro-alias",
+    setup(builder) {
+      builder.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point") return null;
+        const aliased = applyAlias(args.path, config);
+        if (aliased === args.path || isBareSpecifier(aliased)) return null;
+        return builder.resolve(aliased, {
+          kind: "import-statement",
+          resolveDir: args.resolveDir,
+          importer: args.importer,
+          pluginData: { aliased: true }
+        });
+      });
+    }
+  };
+}
+function toUrlPath(path) {
+  return path.split(sep).join("/");
+}
+function outputPath(file, context) {
+  return toUrlPath(relative(context.assetsDir, resolve(context.root, file)));
+}
+function buildManifest(result, context) {
+  const outputs = result.metafile.outputs;
+  const keys = /* @__PURE__ */ new Map();
+  for (const [file, meta] of Object.entries(outputs)) {
+    if (!file.endsWith(".js")) continue;
+    keys.set(
+      file,
+      meta.entryPoint === void 0 ? outputPath(file, context) : toUrlPath(relative(context.root, resolve(context.root, meta.entryPoint)))
+    );
+  }
+  const entries = new Set((context.entries ?? []).map((entry) => resolve(entry)));
+  const manifest = {};
+  for (const [file, meta] of Object.entries(outputs)) {
+    if (!file.endsWith(".js")) continue;
+    const key = keys.get(file);
+    if (key === void 0) continue;
+    const statics = [];
+    const dynamics = [];
+    for (const imported of meta.imports) {
+      const target = keys.get(imported.path);
+      if (target === void 0 || target === key) continue;
+      if (imported.kind === "dynamic-import") dynamics.push(target);
+      else if (imported.kind === "import-statement") statics.push(target);
+    }
+    const stylesheets = meta.cssBundle === void 0 ? [] : [outputPath(meta.cssBundle, context)];
+    const source = meta.entryPoint === void 0 ? void 0 : resolve(context.root, meta.entryPoint);
+    manifest[key] = {
+      file: outputPath(file, context),
+      ...source === void 0 ? {} : { src: key, ...entries.has(source) ? { isEntry: true } : {} },
+      ...stylesheets.length > 0 ? { css: stylesheets } : {},
+      ...statics.length > 0 ? { imports: [...new Set(statics)].sort() } : {},
+      ...dynamics.length > 0 ? { dynamicImports: [...new Set(dynamics)].sort() } : {}
+    };
+  }
+  return manifest;
+}
+function chunksFor(result, entry, context) {
+  const outputs = result.metafile.outputs;
+  const seen = /* @__PURE__ */ new Set([entry]);
+  const stack = [entry];
+  const rendered = [];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === void 0) continue;
+    for (const imported of outputs[current]?.imports ?? []) {
+      if (imported.kind !== "import-statement") continue;
+      if (!imported.path.endsWith(".js") || seen.has(imported.path)) continue;
+      seen.add(imported.path);
+      stack.push(imported.path);
+      rendered.push(outputPath(imported.path, context));
+    }
+  }
+  return rendered.sort();
+}
+function assetUrls(result, context, base) {
+  const rendered = /* @__PURE__ */ new Map();
+  for (const [file, meta] of Object.entries(result.metafile.outputs)) {
+    if (file.endsWith(".js") || file.endsWith(".css") || file.endsWith(".map")) {
+      continue;
+    }
+    const sources = Object.keys(meta.inputs);
+    if (sources.length !== 1) continue;
+    const source = sources[0];
+    if (source === void 0) continue;
+    rendered.set(
+      resolve(context.root, source),
+      `${base}assets/${outputPath(file, context)}`
+    );
+  }
+  return rendered;
+}
+var WORKER_UNAVAILABLE = `export default class OdoroWorker {
+  constructor() {
+    throw new Error(
+      '[odoro] A worker does not run during prerendering. ' +
+        'Construct it from an effect, not at module load.',
+    )
+  }
+}
+`;
+var NAMESPACES = {
+  worker: "odoro-worker",
+  raw: "odoro-raw",
+  url: "odoro-url"
+};
+async function buildWorker(file, config, outputs) {
+  const assetsDir = join(config.outDir, "assets");
+  const result = await build({
+    entryPoints: [file],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: config.build.target,
+    minify: config.build.minify,
+    sourcemap: config.build.sourcemap,
+    metafile: true,
+    outdir: assetsDir,
+    absWorkingDir: config.root,
+    entryNames: "[name]-[hash]",
+    chunkNames: "chunk-[hash]",
+    assetNames: "[name]-[hash]",
+    logLevel: "silent",
+    define: {
+      "import.meta.env": JSON.stringify(config.envClient),
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      ...config.define
+    },
+    plugins: [
+      aliasPlugin(config),
+      sourcePlugin({ root: config.root, plugins: config.plugins, dev: false }),
+      ...esbuildPluginsFrom(config.plugins)
+    ]
+  });
+  let entry;
+  for (const [output, meta] of Object.entries(result.metafile.outputs)) {
+    outputs.add(resolve(config.root, output));
+    if (meta.entryPoint === void 0 || !output.endsWith(".js")) continue;
+    if (resolve(config.root, meta.entryPoint) !== resolve(file)) continue;
+    entry = relative(assetsDir, resolve(config.root, output)).split(sep).join("/");
+  }
+  if (entry !== void 0) return entry;
+  throw new Error(`[odoro] The build of worker "${basename(file)}" produced nothing.`);
+}
+function assetsPlugin(config, options) {
+  const built = /* @__PURE__ */ new Map();
+  return {
+    name: "odoro-assets",
+    setup(builder) {
+      builder.onResolve({ filter: /\?(worker|raw|url)$/ }, async (args) => {
+        const read = readSuffix(args.path);
+        if (read === void 0) return null;
+        const resolved = await builder.resolve(read.path, {
+          kind: "import-statement",
+          resolveDir: args.resolveDir,
+          importer: args.importer
+        });
+        if (resolved.errors.length > 0) return { errors: resolved.errors };
+        return { path: resolved.path, namespace: NAMESPACES[read.suffix] };
+      });
+      builder.onLoad({ filter: /.*/, namespace: NAMESPACES.raw }, async (args) => ({
+        contents: textModule(await readFile(args.path, "utf8")),
+        loader: "js"
+      }));
+      builder.onLoad({ filter: /.*/, namespace: NAMESPACES.url }, async (args) => {
+        if (options.ssr === true) {
+          return {
+            contents: urlModule(options.urls?.get(resolve(args.path)) ?? ""),
+            loader: "js"
+          };
+        }
+        return { contents: await readFile(args.path), loader: "file" };
+      });
+      builder.onLoad({ filter: /.*/, namespace: NAMESPACES.worker }, async (args) => {
+        if (options.ssr === true) {
+          return { contents: WORKER_UNAVAILABLE, loader: "js" };
+        }
+        let building = built.get(args.path);
+        if (building === void 0) {
+          building = buildWorker(args.path, config, options.outputs);
+          built.set(args.path, building);
+        }
+        return {
+          contents: workerModule(`${config.base}assets/${await building}`),
+          loader: "js"
+        };
+      });
+    }
+  };
+}
+
+// src/build/prerender.ts
+var CONTAINER = /(<div\b[^>]*\bid=["']([^"']+)["'][^>]*>)(\s*)(<\/div>)/i;
+var TITLE = /[ \t]*<title\b[^>]*>[\s\S]*?<\/title>\n?/i;
+function applyHead(page, head) {
+  if (head === "") return page;
+  const document = /<title\b/i.test(head) ? page.replace(TITLE, "") : page;
+  if (!document.includes("</head>")) return `${head}
+${document}`;
+  return document.replace("</head>", `  ${head}
+  </head>`);
+}
+async function loadEntry(config, assets) {
+  const settings = config.build.prerender;
+  if (settings === void 0) throw new Error("[odoro] Prerendering not requested.");
+  if (!existsSync(settings.entry)) {
+    throw new Error(
+      `[odoro] Prerendering requested, but "${settings.entry}" does not exist. This file must export \`render(url)\`, and may export \`routes\`.`
+    );
+  }
+  const directory = join(config.root, "node_modules", ".odoro");
+  const output = join(directory, `entry-server.${Date.now().toString(36)}.mjs`);
+  await mkdir(directory, { recursive: true });
+  const result = await build({
+    entryPoints: [settings.entry],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "node20",
+    write: false,
+    jsx: "automatic",
+    logLevel: "silent",
+    absWorkingDir: config.root,
+    // Packages stay external: React must be **the one of the project**,
+    // otherwise two copies coexist and the render fails on invalid hooks.
+    packages: "external",
+    define: {
+      "import.meta.env": JSON.stringify({ ...config.envClient, SSR: true }),
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      ...config.define
+    },
+    plugins: [
+      {
+        name: "odoro-server",
+        setup(builder) {
+          builder.onResolve({ filter: /\.css$/ }, () => ({
+            path: "odoro-empty",
+            namespace: "odoro-empty"
+          }));
+          builder.onLoad({ filter: /.*/, namespace: "odoro-empty" }, () => ({
+            contents: 'export default ""',
+            loader: "js"
+          }));
+          builder.onResolve(
+            { filter: /\.(svg|png|jpe?g|gif|webp|avif|ico|woff2?|mp4|webm)$/ },
+            async (args) => {
+              if (args.kind === "entry-point") return null;
+              const target = await builder.resolve(applyAlias(args.path, config), {
+                kind: "import-statement",
+                resolveDir: args.resolveDir,
+                importer: args.importer
+              });
+              if (target.errors.length > 0) return null;
+              return { path: target.path, namespace: "odoro-static-url" };
+            }
+          );
+          builder.onLoad({ filter: /.*/, namespace: "odoro-static-url" }, (args) => ({
+            contents: `export default ${JSON.stringify(
+              assets.urls?.get(args.path) ?? ""
+            )}`,
+            loader: "js"
+          }));
+          builder.onResolve({ filter: /.*/ }, (args) => {
+            if (args.kind === "entry-point") return null;
+            const alias = applyAlias(args.path, config);
+            if (alias === args.path || isBareSpecifier(alias)) return null;
+            return builder.resolve(alias, {
+              kind: "import-statement",
+              resolveDir: args.resolveDir,
+              importer: args.importer
+            });
+          });
+        }
+      },
+      assetsPlugin(config, { ...assets, ssr: true }),
+      sourcePlugin({
+        root: config.root,
+        plugins: config.plugins,
+        dev: false,
+        ssr: true
+      }),
+      ...esbuildPluginsFrom(config.plugins)
+    ]
+  });
+  const code = result.outputFiles[0]?.text;
+  if (code === void 0) {
+    throw new Error(`[odoro] "${settings.entry}" produced no code.`);
+  }
+  await writeFile(output, code, "utf8");
+  return {
+    module: await import(pathToFileURL(output).href),
+    cleanup: () => rm(output, { force: true })
+  };
+}
+function fileFor(route, outDir) {
+  const clean = route.split("?")[0]?.split("#")[0] ?? route;
+  const trimmed = clean.replace(/^\/+/, "").replace(/\/+$/, "");
+  return trimmed === "" ? join(outDir, "index.html") : join(outDir, trimmed, "index.html");
+}
+async function prerender(config, document, assets = { outputs: /* @__PURE__ */ new Set() }) {
+  const settings = config.build.prerender;
+  if (settings === void 0) return { pages: [] };
+  const { module, cleanup } = await loadEntry(config, assets);
+  try {
+    const render = module.render;
+    if (typeof render !== "function") {
+      throw new Error(`[odoro] "${settings.entry}" must export a "render(url)" function.`);
+    }
+    const routes = settings.routes.length > 0 ? settings.routes : module.routes ?? ["/"];
+    if (!CONTAINER.test(document)) {
+      throw new Error(
+        '[odoro] No empty container in "index.html": the prerender does not know where to write. Expected a tag such as <div id="root"></div>.'
+      );
+    }
+    const pages = [];
+    for (const route of routes) {
+      const output = await render(route);
+      const html = typeof output === "string" ? output : output.html;
+      const head = typeof output === "string" ? void 0 : output.head;
+      let page = document.replace(
+        CONTAINER,
+        (_whole, opening, _id, _blank, closing) => `${opening}${html}${closing}`
+      );
+      if (head !== void 0) page = applyHead(page, head);
+      page = await transformHtmlWith(config.plugins, page, { dev: false, route });
+      const file = fileFor(route, config.outDir);
+      await mkdir(dirname(file), { recursive: true });
+      await writeFile(file, page, "utf8");
+      pages.push(resolve(file));
+    }
+    info(
+      `  ${colors.dim("prerendered")} ${String(pages.length)} route${pages.length > 1 ? "s" : ""} \u2014 ${routes.join(", ")}`
+    );
+    return { pages };
+  } finally {
+    await cleanup();
+  }
+}
+
+// src/build/build.ts
+function toPosix(path) {
+  return path.split(sep).join("/");
+}
+var COMPRESSIBLE = [".js", ".mjs", ".css", ".html", ".json", ".svg", ".txt", ".md"];
+function outputsForEntry(result, entry, outDir, root) {
+  const toRelative = (file) => toPosix(relative(outDir, resolve(root, file)));
+  for (const [file, meta] of Object.entries(result.metafile.outputs)) {
+    if (meta.entryPoint === void 0) continue;
+    if (resolve(root, meta.entryPoint) !== resolve(entry)) continue;
+    if (!file.endsWith(".js")) continue;
+    return {
+      script: toRelative(file),
+      // The key of the report, as it is: it is what the chunks are followed by,
+      // and converting it would make it impossible to find.
+      key: file,
+      styles: meta.cssBundle === void 0 ? [] : [toRelative(meta.cssBundle)]
+    };
+  }
+  return { script: void 0, key: void 0, styles: [] };
+}
+async function trimStylesheets(result, config, html) {
+  const outputs = Object.keys(result.metafile.outputs).map((f) => resolve(config.root, f));
+  const stylesheets = outputs.filter((f) => f.endsWith(".css"));
+  if (stylesheets.length === 0) return;
+  const sources = [html];
+  for (const file of outputs) {
+    if (file.endsWith(".js")) sources.push(await readFile(file, "utf8"));
+  }
+  const provider = await cssProviderFor(config.root);
+  const used = /* @__PURE__ */ new Set();
+  if (provider !== void 0) {
+    for (const source of sources) for (const word of wordsIn(source)) used.add(word);
+    for (const kept of config.build.safelist) {
+      if (typeof kept === "string") used.add(kept);
+    }
+  }
+  for (const stylesheet of stylesheets) {
+    const before = await readFile(stylesheet, "utf8");
+    if (provider === void 0) {
+      const report = prune(before, sources, { safelist: config.build.safelist });
+      await writeFile(stylesheet, report.css, "utf8");
+      info(
+        `  ${colors.dim("pruning")} ${basename(stylesheet)}  ${size(report.bytesBefore)} \u2192 ${size(report.bytesAfter)}  ${colors.dim(`${String(report.kept)} classes kept`)}`
+      );
+      continue;
+    }
+    const base = prune(before, [], {}).css;
+    const utilities = provider.renderUtilitiesFor(used);
+    const after = `${base}
+${utilities}`;
+    await writeFile(stylesheet, after, "utf8");
+    info(
+      `  ${colors.dim("generating")} ${basename(stylesheet)}  ${size(Buffer.byteLength(before))} \u2192 ${size(Buffer.byteLength(after))}`
+    );
+  }
+}
+async function buildProject(config) {
+  const started = Date.now();
+  const indexFile = join(config.root, "index.html");
+  if (!existsSync(indexFile)) {
+    throw new Error(`[odoro] No "index.html" at the project root (${config.root}).`);
+  }
+  const html = await readFile(indexFile, "utf8");
+  const entries = extractEntries(html, config.root);
+  if (entries.length === 0) {
+    throw new Error(
+      '[odoro] No entry point: "index.html" must hold a <script type="module" src="...">.'
+    );
+  }
+  await rm(config.outDir, { recursive: true, force: true });
+  await mkdir(config.outDir, { recursive: true });
+  const sideOutputs = /* @__PURE__ */ new Set();
+  const result = await build({
+    entryPoints: [...entries],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: config.build.target,
+    splitting: true,
+    minify: config.build.minify,
+    sourcemap: config.build.sourcemap,
+    metafile: true,
+    outdir: join(config.outDir, "assets"),
+    absWorkingDir: config.root,
+    publicPath: `${config.base}assets`,
+    // The hashes make the files immutable: they can be cached indefinitely, and
+    // a deployment only invalidates what has changed.
+    entryNames: "[name]-[hash]",
+    chunkNames: "chunk-[hash]",
+    assetNames: "[name]-[hash]",
+    jsx: "automatic",
+    logLevel: "silent",
+    define: {
+      "import.meta.env": JSON.stringify(config.envClient),
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      ...config.define
+    },
+    loader: {
+      ".svg": "file",
+      ".png": "file",
+      ".jpg": "file",
+      ".jpeg": "file",
+      ".gif": "file",
+      ".webp": "file",
+      ".avif": "file",
+      ".ico": "file",
+      ".woff": "file",
+      ".woff2": "file",
+      ".mp4": "file",
+      ".webm": "file"
+    },
+    plugins: [
+      // The order is that of resolution: the suffixes first, because they
+      // change the target; the aliases next; the pass over the sources last, it
+      // resolves nothing.
+      assetsPlugin(config, { outputs: sideOutputs }),
+      aliasPlugin(config),
+      sourcePlugin({ root: config.root, plugins: config.plugins, dev: false }),
+      ...esbuildPluginsFrom(config.plugins)
+    ]
+  });
+  if (config.build.prune) await trimStylesheets(result, config, html);
+  const assetsDir = join(config.outDir, "assets");
+  const context = { root: config.root, assetsDir, entries };
+  let output = html;
+  for (const entry of entries) {
+    const { script, key, styles } = outputsForEntry(result, entry, assetsDir, config.root);
+    if (script === void 0 || key === void 0) continue;
+    const original = new RegExp(
+      `<script[^>]*type=["']module["'][^>]*src=["'][^"']*${basename(entry)}["'][^>]*></script>`,
+      "i"
+    );
+    const chunks = config.build.preload ? chunksFor(result, key, context) : [];
+    const tags = [
+      ...styles.map(
+        (style) => `<link rel="stylesheet" href="${config.base}assets/${style}">`
+      ),
+      ...chunks.map(
+        (chunk) => `<link rel="modulepreload" crossorigin href="${config.base}assets/${chunk}">`
+      ),
+      `<script type="module" crossorigin src="${config.base}assets/${script}"></script>`
+    ].join("\n    ");
+    output = output.replace(original, tags);
+  }
+  await writeFile(
+    join(config.outDir, "index.html"),
+    await transformHtmlWith(config.plugins, output, { dev: false, route: "/" }),
+    "utf8"
+  );
+  if (config.build.manifest) {
+    await writeFile(
+      join(config.outDir, "manifest.json"),
+      `${JSON.stringify(buildManifest(result, context), void 0, 2)}
+`,
+      "utf8"
+    );
+  }
+  if (existsSync(config.publicDir)) {
+    await cp(config.publicDir, config.outDir, { recursive: true });
+  }
+  if (config.build.prerender !== void 0) {
+    await prerender(config, output, {
+      outputs: sideOutputs,
+      ssr: true,
+      urls: assetUrls(result, context, config.base)
+    });
+  }
+  const all = /* @__PURE__ */ new Set([
+    ...Object.keys(result.metafile.outputs).map((file) => resolve(config.root, file)),
+    ...sideOutputs
+  ]);
+  const files = (await Promise.all(
+    [...all].map(async (path) => {
+      const relativePath = toPosix(relative(config.outDir, path));
+      const bytes = (await stat(path)).size;
+      if (!COMPRESSIBLE.some((extension) => relativePath.endsWith(extension))) {
+        return { path: relativePath, bytes };
+      }
+      return {
+        path: relativePath,
+        bytes,
+        gzip: gzipSync(await readFile(path), { level: 9 }).byteLength
+      };
+    })
+  )).sort((a, b) => b.bytes - a.bytes);
+  return { outDir: config.outDir, files, elapsed: Date.now() - started };
+}
+function reportBuild(output, root) {
+  const directory = toPosix(relative(root, output.outDir)) || ".";
+  let total = 0;
+  let compressed = 0;
+  for (const file of output.files) {
+    if (file.path.endsWith(".map")) continue;
+    total += file.bytes;
+    compressed += file.gzip ?? file.bytes;
+    const weight = file.gzip === void 0 ? size(file.bytes) : `${size(file.bytes)} ${colors.dim("|")} ${size(file.gzip)} gzip`;
+    info(
+      `  ${colors.dim(`${directory}/`)}${file.path}  ${colors.dim(weight)}`
+    );
+  }
+  success(
+    `built in ${duration(output.elapsed)} \u2014 ${size(total)} shipped, ${size(compressed)} over the wire` + colors.dim(" (source maps excluded)")
+  );
+}
+
+export { buildManifest, buildProject, chunksFor, prerender, reportBuild };