@marko/vite 3.1.6 → 4.0.0

package/dist/index.mjs

@@ -1,49 +1,606 @@
-import "./chunk-KIYHBIE6.mjs";
-import {
-  FileStore
-} from "./chunk-FCWFM7VD.mjs";
-import {
-  MemoryStore
-} from "./chunk-DCBMHGK4.mjs";
-import {
-  plugin
-} from "./chunk-AEF7OQDP.mjs";
-import {
-  esbuildPlugin
-} from "./chunk-J6VIHWF4.mjs";
-import {
-  generateDocManifest,
-  generateInputDoc
-} from "./chunk-2E5QX7AF.mjs";
-import {
-  isCJSModule
-} from "./chunk-Y3E2OP42.mjs";
-import "./chunk-NTHVNXFC.mjs";
-import {
-  server_entry_template_default
-} from "./chunk-6IJ5UJ3N.mjs";
-
 // src/index.ts
-import fs from "fs";
-import path from "path";
+import fs4 from "fs";
+import path5 from "path";
 import crypto from "crypto";
 import anyMatch from "anymatch";
-import { pathToFileURL, fileURLToPath } from "url";
+import { pathToFileURL } from "url";
+
+// src/server-entry-template.ts
+import path from "path";
+
+// src/render-assets-runtime.ts
+var renderAssetsRuntimeId = "\0marko-render-assets.mjs";
+function getRenderAssetsRuntime(opts) {
+  return `${!opts.basePathVar ? "const base = import.meta.env.BASE_URL;" : `const base = globalThis.${opts.basePathVar};
+if (typeof base !== "string") throw new Error("${opts.basePathVar} must be defined when using basePathVar.");
+if (!base.endsWith("/")) throw new Error("${opts.basePathVar} must end with a '/' when using basePathVar.");`}
+export function addAssets(g, newEntries) {
+  const entries = g.___viteEntries;
+  if (entries) {
+    g.___viteEntries = entries.concat(newEntries);
+  } else {
+    g.___viteEntries = newEntries;
+    g.___viteRenderAssets = renderAssets;
+    g.___viteInjectAttrs = g.cspNonce
+      ? \` nonce="\${g.cspNonce.replace(/"/g, "'")}"\`
+      : "";
+    ${opts.runtimeId ? `$ g.runtimeId = ${JSON.stringify(opts.runtimeId)};` : ""}
+  }
+}
+
+function renderAssets(slot) {
+  const entries = this.___viteEntries;
+  let html = "";
+
+  if (entries) {
+    const slotWrittenEntriesKey = \`___viteWrittenEntries-\${slot}\`;
+    const lastWrittenEntry = this[slotWrittenEntriesKey] || 0;
+    const writtenEntries = (this[slotWrittenEntriesKey] = entries.length);
+
+    if(!this.___flushedMBP && slot !== "head-prepend") {
+        this.___flushedMBP = true;
+
+        html += \`<script\${this.___viteInjectAttrs}>${opts.runtimeId ? `$mbp_${opts.runtimeId}` : "$mbp"}=\${JSON.stringify(base)}</script>\`
+    }
+
+    for (let i = lastWrittenEntry; i < writtenEntries; i++) {
+      let entry = entries[i];
+
+      if (typeof entry === "string") {
+        entry = __MARKO_MANIFEST__[entry] || {};
+      }${opts.isBuild ? "" : ` else if (slot === "head") {
+        // In dev mode we have is a list entries of the top level modules that need to be imported.
+        // To avoid FOUC we will hide the page until all of these modules are loaded.
+        const { preload } = entry;
+        if (preload) {
+          let sep = "";
+          html += \`<script\${this.___viteInjectAttrs}>((root=document.documentElement)=>{\`;
+          html += "root.style.visibility='hidden';";
+          html += "document.currentScript.remove();";
+          html += "Promise.allSettled([";
+
+          for (const id of preload) {
+            html += \`\${sep}import(\${JSON.stringify(base + id)})\`;
+            sep = ",";
+          }
+
+          html += "]).then(()=>{";
+          html += "root.style.visibility='';";
+          html +=
+            "if(root.getAttribute('style')==='')root.removeAttribute('style')";
+          html += "})})()</script>";
+        }
+      }`}
+
+      const parts = entry[slot];
+
+      if (parts) {
+        for (const part of parts) {
+          html +=
+            part === 0 /** InjectType.AssetAttrs */
+              ? this.___viteInjectAttrs
+              : part === 1 /** InjectType.PublicPath */
+              ? base
+              : part;
+        }
+      }
+    }
+  }
+
+  return html;
+}
+`;
+}
+
+// src/server-entry-template.ts
+var server_entry_template_default = async (opts) => {
+  const fileNameStr = JSON.stringify(`./${path.basename(opts.fileName)}`);
+  return `import template from ${fileNameStr};
+export * from ${fileNameStr};
+import { addAssets } from "${renderAssetsRuntimeId}";
+
+$ const g = out.global;
+$ addAssets(g, [${opts.entryData.join(",")}]);
+
+<__flush_here_and_after__>
+  $!{
+    g.___viteRenderAssets("head-prepend") +
+    g.___viteRenderAssets("head") +
+    g.___viteRenderAssets("body-prepend")
+  }
+</__flush_here_and_after__>
+
+<\${template} ...input/>
+<init-components/>
+<await-reorderer/>
+
+<__flush_here_and_after__>
+  $!{g.___viteRenderAssets("body")}
+</__flush_here_and_after__>
+`;
+};
+
+// src/manifest-generator.ts
+import { Parser } from "htmlparser2";
+import { ElementType as ElementType2 } from "domelementtype";
+import { DomHandler } from "domhandler";
+
+// src/serializer.ts
+import { ElementType } from "domelementtype";
+var voidElements = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+function serialize(basePath, nodes, preload, parts) {
+  let curString = parts ? parts.pop() : "";
+  parts ??= [];
+  for (const node of nodes) {
+    switch (node.type) {
+      case ElementType.Tag:
+      case ElementType.Style:
+      case ElementType.Script: {
+        const tag = node;
+        const { name } = tag;
+        let urlAttr;
+        curString += `<${name}`;
+        switch (tag.tagName) {
+          case "script":
+            parts.push(curString, 0 /* AssetAttrs */);
+            urlAttr = "src";
+            curString = "";
+            break;
+          case "style":
+            parts.push(curString, 0 /* AssetAttrs */);
+            curString = "";
+            break;
+          case "link":
+            urlAttr = "href";
+            if (tag.attribs.rel === "stylesheet" || tag.attribs.rel === "modulepreload" || tag.attribs.as === "style" || tag.attribs.as === "script") {
+              parts.push(curString, 0 /* AssetAttrs */);
+              curString = "";
+            }
+            break;
+        }
+        for (const attr of tag.attributes) {
+          if (attr.value === "") {
+            curString += ` ${attr.name}`;
+          } else if (attr.name === urlAttr) {
+            const id = stripBasePath(basePath, attr.value).replace(/^\.\//, "");
+            if (tag.name === "script") {
+              preload.push(id);
+            }
+            curString += ` ${attr.name}="`;
+            parts.push(
+              curString,
+              1 /* PublicPath */,
+              id.replace(/"/g, "&#39;") + '"'
+            );
+            curString = "";
+          } else {
+            curString += ` ${attr.name}="${attr.value.replace(/"/g, "&#39;")}"`;
+          }
+        }
+        curString += ">";
+        if (tag.children.length) {
+          parts.push(curString);
+          serialize(basePath, tag.children, preload, parts);
+          curString = parts.pop();
+        }
+        if (!voidElements.has(name)) {
+          curString += `</${name}>`;
+        }
+        break;
+      }
+      case ElementType.Text: {
+        const text = node.data;
+        if (!/^\s*$/.test(text)) {
+          curString += text;
+        }
+        break;
+      }
+      case ElementType.Comment:
+        curString += `<!--${node.data}-->`;
+        break;
+    }
+  }
+  if (curString) {
+    parts.push(curString);
+  }
+  return parts;
+}
+function stripBasePath(basePath, path6) {
+  if (path6.startsWith(basePath))
+    return path6.slice(basePath.length);
+  return path6;
+}
+
+// src/manifest-generator.ts
+var MARKER_COMMENT = "MARKO_VITE";
+function generateDocManifest(basePath, rawHtml) {
+  return new Promise((resolve2, reject) => {
+    const parser = new Parser(
+      new DomHandler(function(err, dom) {
+        if (err) {
+          return reject(err);
+        }
+        const htmlChildren = dom.find(isElement).childNodes;
+        const preload = [];
+        const headPrepend = [];
+        const head = [];
+        const bodyPrepend = [];
+        const body = [];
+        splitNodesByMarker(
+          htmlChildren.find(
+            (node) => isElement(node) && node.tagName === "head"
+          ).childNodes,
+          headPrepend,
+          head
+        );
+        splitNodesByMarker(
+          htmlChildren.find(
+            (node) => isElement(node) && node.tagName === "body"
+          ).childNodes,
+          bodyPrepend,
+          body
+        );
+        resolve2({
+          preload,
+          "head-prepend": serializeOrNull(basePath, headPrepend, preload),
+          head: serializeOrNull(basePath, head, preload),
+          "body-prepend": serializeOrNull(basePath, bodyPrepend, preload),
+          body: serializeOrNull(basePath, body, preload)
+        });
+      })
+    );
+    parser.write(rawHtml);
+    parser.end();
+  });
+}
+function generateInputDoc(entry) {
+  return `<!DOCTYPE html><html><head><!--${MARKER_COMMENT}--></head><body><!--${MARKER_COMMENT}--><script async type="module" src=${JSON.stringify(
+    entry
+  )}></script></body></html>`;
+}
+function serializeOrNull(basePath, nodes, preload) {
+  const result = serialize(basePath, nodes, preload);
+  if (result.length) {
+    return result;
+  }
+  return null;
+}
+function splitNodesByMarker(nodes, before, after) {
+  for (let i = 0; i < nodes.length; i++) {
+    let node = nodes[i];
+    if (node.data === MARKER_COMMENT) {
+      i++;
+      for (; i < nodes.length; i++) {
+        node = nodes[i];
+        after.push(node);
+      }
+      break;
+    }
+    before.push(node);
+  }
+}
+function isElement(node) {
+  return node.type === ElementType2.Tag;
+}
+
+// src/esbuild-plugin.ts
+import fs from "fs";
+import path2 from "path";
+var markoErrorRegExp = /^(.+?)(?:\((\d+)(?:\s*,\s*(\d+))?\))?: (.*)$/gm;
+function esbuildPlugin(compiler, config) {
+  return {
+    name: "marko",
+    async setup(build) {
+      const { platform = "browser" } = build.initialOptions;
+      const isScan = build.initialOptions.plugins?.some(
+        (v) => v.name === "vite:dep-scan"
+      );
+      const virtualFiles2 = /* @__PURE__ */ new Map();
+      const finalConfig = {
+        ...config,
+        output: isScan ? "hydrate" : platform === "browser" ? "dom" : "html",
+        resolveVirtualDependency(from, dep) {
+          virtualFiles2.set(path2.join(from, "..", dep.virtualPath), dep);
+          return dep.virtualPath;
+        }
+      };
+      build.onResolve({ filter: /\.marko\./ }, (args) => {
+        return {
+          namespace: "marko:virtual",
+          path: path2.resolve(args.resolveDir, args.path),
+          external: isScan
+        };
+      });
+      build.onLoad(
+        { filter: /\.marko\./, namespace: "marko:virtual" },
+        (args) => ({
+          contents: virtualFiles2.get(args.path).code,
+          loader: path2.extname(args.path).slice(1)
+        })
+      );
+      build.onLoad({ filter: /\.marko$/ }, async (args) => {
+        try {
+          const { code, meta } = await compiler.compileFile(
+            args.path,
+            finalConfig
+          );
+          return {
+            loader: "js",
+            contents: code,
+            watchFiles: meta.watchFiles,
+            resolveDir: path2.dirname(args.path)
+          };
+        } catch (e) {
+          const text = e.message;
+          const errors = [];
+          let match;
+          let lines;
+          while (match = markoErrorRegExp.exec(text)) {
+            const [, file, rawLine, rawCol, text2] = match;
+            const line = parseInt(rawLine, 10) || 1;
+            const column = parseInt(rawCol, 10) || 1;
+            lines ||= (await fs.promises.readFile(args.path, "utf-8")).split(
+              /\n/g
+            );
+            errors.push({
+              text: text2,
+              location: {
+                file,
+                line,
+                column,
+                lineText: ` ${lines[line - 1]}`
+              }
+            });
+          }
+          if (!errors.length) {
+            errors.push({ text });
+          }
+          return {
+            errors
+          };
+        }
+      });
+    }
+  };
+}
+
+// src/babel-plugin-cjs-interop.ts
+import * as t from "@babel/types";
+
+// src/resolve.ts
+import { exports } from "resolve.exports";
+import Resolve from "resolve";
+import path3 from "path";
+import fs2 from "fs";
+var exportsMainFile = `__package_exports__`;
+var modulePathReg = /^.*[/\\]node_modules[/\\](?:@[^/\\]+[/\\])?[^/\\]+[/\\]/;
+var cjsModuleLookup = /* @__PURE__ */ new Map();
+function isCJSModule(id) {
+  const modulePath = modulePathReg.exec(id)?.[0];
+  if (modulePath) {
+    const pkgPath = modulePath + "package.json";
+    let isCJS = cjsModuleLookup.get(pkgPath);
+    if (isCJS === void 0) {
+      try {
+        const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+        isCJS = pkg.type !== "module" && !pkg.exports;
+      } catch {
+        isCJS = false;
+      }
+      cjsModuleLookup.set(pkgPath, isCJS);
+    }
+    return isCJS;
+  }
+  return false;
+}
+function resolve(id, from, extensions, conditions) {
+  return Resolve.sync(id, {
+    basedir: path3.dirname(from),
+    filename: from,
+    pathFilter,
+    packageFilter,
+    extensions
+  });
+  function pathFilter(pkg, pkgFile, relativePath) {
+    cjsModuleLookup.set(pkgFile, pkg.type !== "module" && !pkg.exports);
+    if (pkg.exports) {
+      return exports(
+        pkg,
+        relativePath === exportsMainFile ? "." : relativePath,
+        {
+          conditions
+        }
+      )?.[0];
+    }
+    return relativePath;
+  }
+}
+function packageFilter(pkg) {
+  if (pkg.exports) {
+    pkg.main = exportsMainFile;
+  }
+  return pkg;
+}
+
+// src/babel-plugin-cjs-interop.ts
+function plugin(options) {
+  return {
+    name: "marko-import-interop",
+    visitor: {
+      ImportDeclaration(path6) {
+        if (!path6.node.specifiers.length || /\.(?:mjs|marko)$|\?/.test(path6.node.source.value)) {
+          return;
+        }
+        try {
+          const resolved = resolve(
+            path6.node.source.value,
+            path6.hub.file.opts.filename,
+            options.extensions,
+            options.conditions
+          );
+          if (!/\.c?js$/.test(resolved) || !isCJSModule(resolved)) {
+            return;
+          }
+        } catch (_) {
+          return;
+        }
+        let namespaceId;
+        let defaultImportId;
+        let imports;
+        for (const s of path6.node.specifiers) {
+          if (t.isImportSpecifier(s)) {
+            (imports ||= []).push({
+              name: t.isStringLiteral(s.imported) ? s.imported.value : s.imported.name,
+              alias: s.local.name
+            });
+          } else if (t.isImportDefaultSpecifier(s)) {
+            defaultImportId = s.local;
+          } else if (t.isImportNamespaceSpecifier(s)) {
+            namespaceId = s.local;
+          }
+        }
+        namespaceId ||= path6.scope.generateUidIdentifier(
+          defaultImportId?.name || path6.node.source.value
+        );
+        path6.node.specifiers = [t.importDefaultSpecifier(namespaceId)];
+        if (defaultImportId) {
+          path6.insertAfter(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                defaultImportId,
+                t.conditionalExpression(
+                  t.optionalMemberExpression(
+                    namespaceId,
+                    t.identifier("__esModule"),
+                    false,
+                    true
+                  ),
+                  t.memberExpression(namespaceId, t.identifier("default")),
+                  namespaceId
+                )
+              )
+            ])
+          );
+        }
+        if (imports) {
+          path6.insertAfter(
+            t.variableDeclaration("const", [
+              t.variableDeclarator(
+                t.objectPattern(
+                  imports.map(
+                    ({ name, alias }) => t.objectProperty(
+                      t.identifier(name),
+                      t.identifier(alias),
+                      false,
+                      name === alias
+                    )
+                  )
+                ),
+                namespaceId
+              )
+            ])
+          );
+        }
+      }
+    }
+  };
+}
+
+// src/render-assets-transform.ts
+var render_assets_transform_default = (tag, t2) => {
+  const body = tag.get("body");
+  const tagName = tag.get("name").node.value;
+  body.unshiftContainer("body", renderAssetsCall(t2, `${tagName}-prepend`));
+  body.pushContainer("body", renderAssetsCall(t2, tagName));
+};
+function renderAssetsCall(t2, slot) {
+  return t2.markoPlaceholder(
+    t2.callExpression(
+      t2.memberExpression(
+        t2.memberExpression(t2.identifier("out"), t2.identifier("global")),
+        t2.identifier("___viteRenderAssets")
+      ),
+      [t2.stringLiteral(slot)]
+    ),
+    false
+  );
+}
+
+// src/read-once-persisted-store.ts
+import os from "os";
+import path4 from "path";
+import { promises as fs3 } from "fs";
+var noop = () => {
+};
+var tmpFile = path4.join(os.tmpdir(), "marko-vite-storage.json");
+var values = /* @__PURE__ */ new Map();
+var loadedFromDisk;
+var ReadOncePersistedStore = class {
+  constructor(uid) {
+    this.uid = uid;
+  }
+  write(value) {
+    values.set(this.uid, value);
+  }
+  async read() {
+    const { uid } = this;
+    if (values.has(uid)) {
+      const value = values.get(uid);
+      values.delete(uid);
+      return value;
+    }
+    if (loadedFromDisk === true) {
+      throw new Error(`Value for ${uid} could not be loaded.`);
+    }
+    await (loadedFromDisk ||= fs3.readFile(tmpFile, "utf-8").then(syncDataFromDisk).catch(finishLoadFromDisk));
+    return this.read();
+  }
+};
+function syncDataFromDisk(data) {
+  finishLoadFromDisk();
+  fs3.unlink(tmpFile).catch(noop);
+  for (const [k, v] of JSON.parse(data)) {
+    values.set(k, v);
+  }
+}
+function finishLoadFromDisk() {
+  loadedFromDisk = true;
+}
+process.once("beforeExit", (code) => {
+  if (code === 0 && values.size) {
+    fs3.writeFile(tmpFile, JSON.stringify([...values])).catch(noop);
+  }
+});
+
+// src/index.ts
 var POSIX_SEP = "/";
 var WINDOWS_SEP = "\\";
-var normalizePath = path.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
+var normalizePath = path5.sep === WINDOWS_SEP ? (id) => id.replace(/\\/g, POSIX_SEP) : (id) => id;
 var virtualFiles = /* @__PURE__ */ new Map();
 var queryReg = /\?marko-[^?]+$/;
 var browserEntryQuery = "?marko-browser-entry";
 var serverEntryQuery = "?marko-server-entry";
 var virtualFileQuery = "?marko-virtual";
 var browserQuery = "?marko-browser";
-var manifestFileName = "manifest.json";
 var markoExt = ".marko";
 var htmlExt = ".html";
 var resolveOpts = { skipSelf: true };
 var cache = /* @__PURE__ */ new Map();
-var thisFile = typeof __filename === "string" ? __filename : fileURLToPath(import.meta.url);
 var babelCaller = {
   name: "@marko/vite",
   supportsStaticESM: true,
@@ -51,7 +608,7 @@ var babelCaller = {
   supportsTopLevelAwait: true,
   supportsExportNamespaceFrom: true
 };
-var registeredTag = false;
+var registeredTagLib = false;
 function markoPlugin(opts = {}) {
   let compiler;
   let { linked = true } = opts;
@@ -64,7 +621,7 @@ function markoPlugin(opts = {}) {
   let hydrateConfig;
   const resolveVirtualDependency = (from, dep) => {
     const normalizedFrom = normalizePath(from);
-    const query = `${virtualFileQuery}&id=${Buffer.from(dep.virtualPath).toString("base64url") + path.extname(dep.virtualPath)}`;
+    const query = `${virtualFileQuery}&id=${Buffer.from(dep.virtualPath).toString("base64url") + path5.extname(dep.virtualPath)}`;
     const id = normalizePath(normalizedFrom) + query;
     if (devServer) {
       const prev = virtualFiles.get(id);
@@ -73,30 +630,33 @@ function markoPlugin(opts = {}) {
       }
     }
     virtualFiles.set(id, dep);
-    return `./${path.posix.basename(normalizedFrom) + query}`;
+    return `./${path5.posix.basename(normalizedFrom) + query}`;
   };
   let root;
   let devEntryFile;
   let devEntryFilePosix;
+  let renderAssetsRuntimeCode;
   let isTest = false;
   let isBuild = false;
   let isSSRBuild = false;
   let devServer;
   let serverManifest;
-  let store;
   let basePath = "/";
+  let getMarkoAssetFns;
   const entryIds = /* @__PURE__ */ new Set();
   const cachedSources = /* @__PURE__ */ new Map();
   const transformWatchFiles = /* @__PURE__ */ new Map();
   const transformOptionalFiles = /* @__PURE__ */ new Map();
+  const store = new ReadOncePersistedStore(
+    `vite-marko${runtimeId ? `-${runtimeId}` : ""}`
+  );
   return [
     {
       name: "marko-vite:pre",
       enforce: "pre",
       // Must be pre to allow us to resolve assets before vite.
       async config(config, env) {
-        var _a, _b, _c, _d, _e;
-        compiler ?? (compiler = await import(opts.compiler || "@marko/compiler"));
+        compiler ??= await import(opts.compiler || "@marko/compiler");
         runtimeId = opts.runtimeId;
         basePathVar = opts.basePathVar;
         baseConfig = {
@@ -138,53 +698,48 @@ function markoPlugin(opts = {}) {
         };
         compiler.configure(baseConfig);
         root = normalizePath(config.root || process.cwd());
-        devEntryFile = path.join(root, "index.html");
+        devEntryFile = path5.join(root, "index.html");
         devEntryFilePosix = normalizePath(devEntryFile);
         isTest = env.mode === "test";
         isBuild = env.command === "build";
         isSSRBuild = isBuild && linked && Boolean(config.build.ssr);
-        store = opts.store || new FileStore(
-          `marko-vite-${crypto.createHash("SHA1").update(root).digest("hex")}`
-        );
+        renderAssetsRuntimeCode = getRenderAssetsRuntime({
+          isBuild,
+          basePathVar,
+          runtimeId
+        });
         if (isTest) {
           linked = false;
-          if ((_b = (_a = config.test) == null ? void 0 : _a.environment) == null ? void 0 : _b.includes(
+          if (config.test?.environment?.includes(
             "dom"
           )) {
-            config.resolve ?? (config.resolve = {});
-            (_c = config.resolve).conditions ?? (_c.conditions = []);
+            config.resolve ??= {};
+            config.resolve.conditions ??= [];
             config.resolve.conditions.push("browser");
           }
         }
-        if (!registeredTag) {
-          const transformer = path.resolve(
-            thisFile,
-            "../render-assets-transform"
-          );
-          registeredTag = normalizePath(
-            path.resolve(thisFile, "../components", "vite.marko")
-          );
+        if (!registeredTagLib) {
+          registeredTagLib = true;
           compiler.taglib.register("@marko/vite", {
-            "<_vite>": { template: registeredTag },
-            "<head>": { transformer },
-            "<body>": { transformer }
+            "<head>": { transformer: render_assets_transform_default },
+            "<body>": { transformer: render_assets_transform_default }
           });
         }
-        const optimizeDeps = config.optimizeDeps ?? (config.optimizeDeps = {});
-        optimizeDeps.entries ?? (optimizeDeps.entries = [
+        const optimizeDeps = config.optimizeDeps ??= {};
+        optimizeDeps.entries ??= [
           "**/*.marko",
           "!**/__snapshots__/**",
           `!**/__tests__/**`,
           `!**/coverage/**`
-        ]);
+        ];
         const domDeps = compiler.getRuntimeEntryFiles("dom", opts.translator);
         optimizeDeps.include = optimizeDeps.include ? [...optimizeDeps.include, ...domDeps] : domDeps;
-        const optimizeExtensions = optimizeDeps.extensions ?? (optimizeDeps.extensions = []);
+        const optimizeExtensions = optimizeDeps.extensions ??= [];
         optimizeExtensions.push(".marko");
-        const esbuildOptions = optimizeDeps.esbuildOptions ?? (optimizeDeps.esbuildOptions = {});
-        const esbuildPlugins = esbuildOptions.plugins ?? (esbuildOptions.plugins = []);
+        const esbuildOptions = optimizeDeps.esbuildOptions ??= {};
+        const esbuildPlugins = esbuildOptions.plugins ??= [];
         esbuildPlugins.push(esbuildPlugin(compiler, baseConfig));
-        const ssr = config.ssr ?? (config.ssr = {});
+        const ssr = config.ssr ??= {};
         let { noExternal } = ssr;
         if (noExternal !== true) {
           const noExternalReg = /\.marko$/;
@@ -199,13 +754,13 @@ function markoPlugin(opts = {}) {
           }
         }
         if (basePathVar) {
-          config.experimental ?? (config.experimental = {});
+          config.experimental ??= {};
           if (config.experimental.renderBuiltUrl) {
             throw new Error(
               "Cannot use @marko/vite `basePathVar` with Vite's `renderBuiltUrl` option."
             );
           }
-          const assetsDir = ((_e = (_d = config.build) == null ? void 0 : _d.assetsDir) == null ? void 0 : _e.replace(/[/\\]$/, "")) ?? "assets";
+          const assetsDir = config.build?.assetsDir?.replace(/[/\\]$/, "") ?? "assets";
           const assetsDirLen = assetsDir.length;
           const assetsDirEnd = assetsDirLen + 1;
           const trimAssertsDir = (fileName) => {
@@ -247,6 +802,17 @@ function markoPlugin(opts = {}) {
             )
           }
         };
+        getMarkoAssetFns = void 0;
+        for (const plugin2 of config.plugins) {
+          const fn = plugin2.api?.getMarkoAssetCodeForEntry;
+          if (fn) {
+            if (getMarkoAssetFns) {
+              getMarkoAssetFns.push(fn);
+            } else {
+              getMarkoAssetFns = [fn];
+            }
+          }
+        }
       },
       configureServer(_server) {
         ssrConfig.hot = domConfig.hot = true;
@@ -284,12 +850,10 @@ function markoPlugin(opts = {}) {
       async buildStart(inputOptions) {
         if (isBuild && linked && !isSSRBuild) {
           try {
-            serverManifest = JSON.parse(
-              await store.get(manifestFileName)
-            );
+            serverManifest = await store.read();
             inputOptions.input = toHTMLEntries(root, serverManifest.entries);
             for (const entry in serverManifest.entrySources) {
-              const id = normalizePath(path.resolve(root, entry));
+              const id = normalizePath(path5.resolve(root, entry));
               entryIds.add(id);
               cachedSources.set(id, serverManifest.entrySources[entry]);
             }
@@ -304,10 +868,12 @@ function markoPlugin(opts = {}) {
         }
       },
       async resolveId(importee, importer, importOpts, ssr = importOpts.ssr) {
-        var _a;
         if (virtualFiles.has(importee)) {
           return importee;
         }
+        if (importee === renderAssetsRuntimeId) {
+          return { id: renderAssetsRuntimeId };
+        }
         let importeeQuery = getMarkoQuery(importee);
         if (importeeQuery) {
           importee = importee.slice(0, -importeeQuery.length);
@@ -315,7 +881,7 @@ function markoPlugin(opts = {}) {
           if (ssr && linked && importer && (importer !== devEntryFile || normalizePath(importer) !== devEntryFilePosix) && // Vite tries to resolve against an `index.html` in some cases, we ignore it here.
           isMarkoFile(importee) && !isMarkoFile(importer.replace(queryReg, ""))) {
             importeeQuery = serverEntryQuery;
-          } else if (!ssr && isBuild && importer && isMarkoFile(importee) && ((_a = this.getModuleInfo(importer)) == null ? void 0 : _a.isEntry)) {
+          } else if (!ssr && isBuild && importer && isMarkoFile(importee) && this.getModuleInfo(importer)?.isEntry) {
             importeeQuery = browserEntryQuery;
           } else if (linked && !ssr && !importeeQuery && isMarkoFile(importee)) {
             importeeQuery = browserQuery;
@@ -324,7 +890,7 @@ function markoPlugin(opts = {}) {
         if (importeeQuery) {
           const resolved = importee[0] === "." ? {
             id: normalizePath(
-              importer ? path.resolve(importer, "..", importee) : path.resolve(root, importee)
+              importer ? path5.resolve(importer, "..", importee) : path5.resolve(root, importee)
             )
           } : await this.resolve(importee, importer, resolveOpts);
           if (resolved) {
@@ -338,7 +904,7 @@ function markoPlugin(opts = {}) {
             importer = importer.slice(0, -importerQuery.length);
             if (importee[0] === ".") {
               const resolved = normalizePath(
-                path.resolve(importer, "..", importee)
+                path5.resolve(importer, "..", importee)
               );
               if (resolved === normalizePath(importer))
                 return resolved;
@@ -350,6 +916,9 @@ function markoPlugin(opts = {}) {
       },
       async load(rawId) {
         const id = stripVersionAndTimeStamp(rawId);
+        if (id === renderAssetsRuntimeId) {
+          return renderAssetsRuntimeCode;
+        }
         const query = getMarkoQuery(id);
         switch (query) {
           case serverEntryQuery: {
@@ -371,22 +940,22 @@ function markoPlugin(opts = {}) {
           id = id.slice(0, -query.length);
           if (query === serverEntryQuery) {
             const fileName = id;
-            let entryData;
+            let mainEntryData;
             id = `${id.slice(0, -markoExt.length)}.entry.marko`;
             cachedSources.set(fileName, source);
             if (isBuild) {
-              const relativeFileName = path.posix.relative(root, fileName);
+              const relativeFileName = path5.posix.relative(root, fileName);
               const entryId = toEntryId(relativeFileName);
-              serverManifest ?? (serverManifest = {
+              serverManifest ??= {
                 entries: {},
                 entrySources: {},
                 chunksNeedingAssets: []
-              });
+              };
               serverManifest.entries[entryId] = relativeFileName;
               serverManifest.entrySources[relativeFileName] = source;
-              entryData = JSON.stringify(entryId);
+              mainEntryData = JSON.stringify(entryId);
             } else {
-              entryData = JSON.stringify(
+              mainEntryData = JSON.stringify(
                 await generateDocManifest(
                   basePath,
                   await devServer.transformIndexHtml(
@@ -398,6 +967,15 @@ function markoPlugin(opts = {}) {
                 )
               );
             }
+            const entryData = [mainEntryData];
+            if (getMarkoAssetFns) {
+              for (const getMarkoAsset of getMarkoAssetFns) {
+                const asset = getMarkoAsset(fileName);
+                if (asset) {
+                  entryData.push(asset);
+                }
+              }
+            }
             source = await server_entry_template_default({
               fileName,
               entryData,
@@ -500,7 +1078,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
         }
         if (devServer) {
           const templateName = getPosixBasenameWithoutExt(id);
-          const optionalFilePrefix = path.dirname(id) + path.sep + (templateName === "index" ? "" : `${templateName}.`);
+          const optionalFilePrefix = path5.dirname(id) + path5.sep + (templateName === "index" ? "" : `${templateName}.`);
           for (const file of meta.watchFiles) {
             this.addWatchFile(file);
           }
@@ -535,39 +1113,35 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
           );
         }
         if (isSSRBuild) {
-          const dir = outputOptions.dir ? path.resolve(outputOptions.dir) : path.resolve(outputOptions.file, "..");
+          const dir = outputOptions.dir ? path5.resolve(outputOptions.dir) : path5.resolve(outputOptions.file, "..");
           for (const fileName in bundle) {
             const chunk = bundle[fileName];
             if (chunk.type === "chunk") {
               for (const id in chunk.modules) {
-                if (id === registeredTag) {
+                if (id.endsWith(serverEntryQuery)) {
                   serverManifest.chunksNeedingAssets.push(
-                    path.resolve(dir, fileName)
+                    path5.resolve(dir, fileName)
                   );
                   break;
                 }
               }
             }
           }
-          await store.set(manifestFileName, JSON.stringify(serverManifest));
+          store.write(serverManifest);
         } else {
           const browserManifest = {};
           for (const entryId in serverManifest.entries) {
             const fileName = serverManifest.entries[entryId];
-            let chunkId = fileName + htmlExt;
-            let chunk = bundle[chunkId];
-            if (!chunk) {
-              chunkId = chunkId.replace(/\//g, "\\");
-              chunk = bundle[chunkId];
-            }
-            if ((chunk == null ? void 0 : chunk.type) === "asset") {
+            const chunkId = fileName + htmlExt;
+            const chunk = bundle[chunkId];
+            if (chunk?.type === "asset") {
               browserManifest[entryId] = {
                 ...await generateDocManifest(
                   basePath,
                   chunk.source.toString()
                 ),
-                entries: void 0
-                // clear out entries for prod builds.
+                preload: void 0
+                // clear out preload for prod builds.
               };
               delete bundle[chunkId];
             } else {
@@ -581,7 +1155,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
           )};
 `;
           for (const fileName of serverManifest.chunksNeedingAssets) {
-            await fs.promises.appendFile(fileName, manifestStr);
+            await fs4.promises.appendFile(fileName, manifestStr);
           }
         }
       }
@@ -589,8 +1163,7 @@ if (import.meta.hot) import.meta.hot.accept(() => {});`;
   ];
 }
 function getMarkoQuery(id) {
-  var _a;
-  return ((_a = queryReg.exec(id)) == null ? void 0 : _a[0]) || "";
+  return queryReg.exec(id)?.[0] || "";
 }
 function isMarkoFile(id) {
   return id.endsWith(markoExt);
@@ -598,7 +1171,7 @@ function isMarkoFile(id) {
 function toHTMLEntries(root, serverEntries) {
   const result = [];
   for (const id in serverEntries) {
-    const markoFile = path.posix.join(root, serverEntries[id]);
+    const markoFile = path5.posix.join(root, serverEntries[id]);
     const htmlFile = markoFile + htmlExt;
     virtualFiles.set(htmlFile, {
       code: generateInputDoc(markoFile + browserEntryQuery)
@@ -619,7 +1192,7 @@ function toEntryId(id) {
   return `${name}_${crypto.createHash("SHA1").update(id).digest("base64").replace(/[/+]/g, "-").slice(0, 4)}`;
 }
 function posixFileNameToURL(fileName, root) {
-  const relativeURL = path.posix.relative(
+  const relativeURL = path5.posix.relative(
     pathToFileURL(root).pathname,
     pathToFileURL(fileName).pathname
   );
@@ -636,18 +1209,18 @@ function getPosixBasenameWithoutExt(file) {
   return file.slice(baseStart, extStart);
 }
 function createDeferredPromise() {
-  let resolve;
+  let resolve2;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve = res;
+    resolve2 = res;
     reject = rej;
   });
-  promise.resolve = resolve;
+  promise.resolve = resolve2;
   promise.reject = reject;
   return promise;
 }
 function isDeferredPromise(obj) {
-  return typeof (obj == null ? void 0 : obj.then) === "function";
+  return typeof obj?.then === "function";
 }
 function isEmpty(obj) {
   for (const _ in obj) {
@@ -666,7 +1239,5 @@ function stripVersionAndTimeStamp(id) {
   return url;
 }
 export {
-  FileStore,
-  MemoryStore,
   markoPlugin as default
 };