@marko/run 0.0.1-beta1

package/dist/vite/index.js

@@ -0,0 +1,1359 @@
+// src/vite/plugin.ts
+import path2 from "path";
+import crypto from "crypto";
+import { mergeConfig, normalizePath } from "vite";
+import markoVitePlugin, { FileStore } from "@marko/vite";
+
+// src/vite/constants.ts
+var markoServeFilePrefix = "__marko-serve__";
+var virtualFilePrefix = "virtual:marko-serve";
+var virtualRoutesPrefix = `${virtualFilePrefix}/routes`;
+var httpVerbs = ["get", "post", "put", "delete"];
+var serverEntryQuery = "?marko-server-entry";
+var browserEntryQuery = "?marko-browser-entry";
+var RoutableFileTypes = {
+  Page: "page",
+  Layout: "layout",
+  Handler: "handler",
+  Middleware: "middleware",
+  Meta: "meta",
+  NotFound: "404",
+  Error: "500"
+};
+
+// src/vite/routes/builder.ts
+var markoFiles = `(${RoutableFileTypes.Layout}|${RoutableFileTypes.Page}|${RoutableFileTypes.NotFound}|${RoutableFileTypes.Error})\\.(?:.*\\.)?(marko)`;
+var nonMarkoFiles = `(${RoutableFileTypes.Middleware}|${RoutableFileTypes.Handler}|${RoutableFileTypes.Meta})\\.(?:.*\\.)?(.+)`;
+var routeableFileRegex = new RegExp(
+  `^[+](?:${markoFiles}|${nonMarkoFiles})$`,
+  "i"
+);
+function isRoutableFile(filename) {
+  return routeableFileRegex.test(filename);
+}
+function matchRoutableFile(filename) {
+  const match = filename.match(routeableFileRegex);
+  return match && (match[1] || match[3]).toLowerCase();
+}
+function scorePath(path3, index) {
+  const [pattern, splat] = path3.split("/$$", 2);
+  const segments = pattern.split("/").filter(Boolean);
+  return segments.reduce(
+    (score, segment) => score + (segment.startsWith("$") ? 3 : 4),
+    segments.length + (splat === void 0 ? 1 : 2)
+  ) * 1e4 - index;
+}
+function isSpecialType(type) {
+  return type === RoutableFileTypes.NotFound || type === RoutableFileTypes.Error;
+}
+async function buildRoutes(walk, basePath) {
+  const dirStack = basePath ? basePath.split("/") : [];
+  const pathStack = [];
+  const paramStack = [];
+  const layoutsStack = [];
+  const middlewareStack = [];
+  const routes = /* @__PURE__ */ new Map();
+  const special = {};
+  let isRoot = true;
+  let nextId = 1;
+  let current;
+  let children = [];
+  await walk({
+    onFile(entry) {
+      const type = matchRoutableFile(entry.name);
+      if (!type) {
+        return;
+      }
+      if (!isRoot && isSpecialType(type)) {
+        console.warn(
+          `Special pages '${RoutableFileTypes.NotFound}' and '${RoutableFileTypes.Error}' are only considered in the root directory - ignoring ${entry.path}`
+        );
+        return;
+      }
+      if (!current) {
+        current = {
+          path: "/" + pathStack.join("/"),
+          originalPath: dirStack.join("/"),
+          children: [],
+          files: /* @__PURE__ */ new Map()
+        };
+        children.push(current);
+      }
+      let entries = current.files.get(type);
+      if (!entries) {
+        current.files.set(type, entries = []);
+      }
+      entries.push({
+        type,
+        filePath: entry.path,
+        importPath: `${current.originalPath}/${entry.name}`,
+        name: entry.name,
+        verbs: type === RoutableFileTypes.Page ? ["get"] : void 0
+      });
+    },
+    onDir(dir) {
+      var _a, _b, _c, _d, _e;
+      if (!current) {
+        return;
+      }
+      const { path: path3, files } = current;
+      const middleware = (_a = files.get(RoutableFileTypes.Middleware)) == null ? void 0 : _a[0];
+      const layout = (_b = files.get(RoutableFileTypes.Layout)) == null ? void 0 : _b[0];
+      const handler = (_c = files.get(RoutableFileTypes.Handler)) == null ? void 0 : _c[0];
+      const page = (_d = files.get(RoutableFileTypes.Page)) == null ? void 0 : _d[0];
+      const middlewareStackLength = middlewareStack.length;
+      const layoutsStackLength = layoutsStack.length;
+      middleware && middlewareStack.push(middleware);
+      layout && layoutsStack.push(layout);
+      if (handler || page) {
+        const key = path3.replace(/(\$\$?)[^\/]*/g, "$1").replace(/^\/+/, "").replace(/[^a-z0-9_$\/]+/gi, "").replace(/\//g, "__") || "index";
+        if (routes.has(key)) {
+          console.warn(`Duplicate route for path ${path3} -- ignoring`, current);
+        } else {
+          const index = nextId++;
+          routes.set(key, {
+            index,
+            key,
+            path: path3,
+            params: [...paramStack],
+            middleware: [...middlewareStack],
+            layouts: page ? [...layoutsStack] : [],
+            meta: (_e = files.get(RoutableFileTypes.Meta)) == null ? void 0 : _e[0],
+            page,
+            handler,
+            score: scorePath(path3, index)
+          });
+        }
+      }
+      if (isRoot) {
+        for (const [type, entries] of files) {
+          if (isSpecialType(type)) {
+            special[type] = {
+              index: 0,
+              key: type,
+              path: path3,
+              middleware: [],
+              layouts: [...layoutsStack],
+              page: entries[0],
+              score: 0
+            };
+          }
+        }
+      } else if (dir.startsWith("$$")) {
+        return false;
+      }
+      return () => {
+        middlewareStack.length = middlewareStackLength;
+        layoutsStack.length = layoutsStackLength;
+      };
+    },
+    onEnter({ name }) {
+      const pathStackLength = pathStack.length;
+      const paramStackLength = paramStack.length;
+      const prevChildren = children;
+      const prevCurrent = current;
+      const prevIsRoot = isRoot;
+      if (name.charCodeAt(0) === 95 || name.charCodeAt(0) === 40 && name.charCodeAt(name.length - 1) === 41 || name.toLowerCase() === "index") {
+      } else {
+        if (name.charCodeAt(0) === 36) {
+          if (name.charCodeAt(1) === 36) {
+            paramStack.push({
+              name: name.slice(2) || "*",
+              index: -1
+            });
+          } else if (name.length > 1) {
+            paramStack.push({
+              name: name.slice(1),
+              index: pathStackLength
+            });
+          }
+        }
+        pathStack.push(name.toLowerCase());
+      }
+      dirStack.push(name);
+      isRoot = false;
+      if (current) {
+        children = current.children;
+        current = void 0;
+      }
+      return () => {
+        dirStack.pop();
+        pathStack.length = pathStackLength;
+        paramStack.length = paramStackLength;
+        children = prevChildren;
+        current = prevCurrent;
+        isRoot = prevIsRoot;
+      };
+    }
+  });
+  return {
+    list: [...routes.values()],
+    special
+  };
+}
+
+// src/vite/routes/walk.ts
+import fs from "fs";
+import path from "path";
+function createFSWalker(dir) {
+  return async function walkFS({ onFile, onEnter, onDir, maxDepth = 50 }) {
+    async function walk(dir2, depth) {
+      const dirs = [];
+      const entries = await fs.promises.readdir(dir2, { withFileTypes: true });
+      const prefix = dir2 + path.sep;
+      for (const dirEntry of entries) {
+        const entry = {
+          name: dirEntry.name,
+          path: prefix + dirEntry.name
+        };
+        if (dirEntry.isDirectory()) {
+          dirs.push(entry);
+        } else {
+          onFile == null ? void 0 : onFile(entry);
+        }
+      }
+      const onAfter = onDir == null ? void 0 : onDir(dir2);
+      if (onAfter !== false) {
+        if (--depth > 0) {
+          for (const entry of dirs) {
+            const onExit = onEnter == null ? void 0 : onEnter(entry);
+            if (onExit !== false) {
+              await walk(entry.path, depth);
+              onExit == null ? void 0 : onExit();
+            }
+          }
+        }
+        onAfter == null ? void 0 : onAfter();
+      }
+    }
+    await walk(dir, maxDepth);
+  };
+}
+
+// src/vite/codegen/writer.ts
+function createWriter(sink, options) {
+  let buffer = "";
+  let indentLevel = 0;
+  let indentString = "";
+  let firstOpenIndex = 0;
+  const branches = [];
+  const openWriters = /* @__PURE__ */ new Map();
+  const writer = {
+    __isActive: true,
+    get indent() {
+      return indentLevel;
+    },
+    set indent(value) {
+      if (options == null ? void 0 : options.indentWith) {
+        if (value < 0) {
+          value = 0;
+        }
+        if (value !== indentLevel) {
+          indentLevel = value;
+          indentString = options.indentWith.repeat(indentLevel);
+        }
+      }
+    },
+    write(data) {
+      if (!writer.__isActive) {
+        throw new Error("Cannot write to branch that has been joined");
+      }
+      if (openWriters.size) {
+        buffer += data;
+      } else {
+        sink(data);
+      }
+      return writer;
+    },
+    writeLines(...lines) {
+      for (const line of lines) {
+        if (line) {
+          if (indentString) {
+            writer.write(indentString);
+          }
+          writer.write(line);
+        }
+        writer.write("\n");
+      }
+      return writer;
+    },
+    writeBlockStart(data) {
+      writer.writeLines(data).indent++;
+      return writer;
+    },
+    writeBlockEnd(data = "}") {
+      writer.indent--;
+      writer.writeLines(data);
+      return writer;
+    },
+    writeBlock(start, lines, end) {
+      return writer.writeBlockStart(start).writeLines(...lines).writeBlockEnd(end);
+    },
+    branch(name) {
+      let existing = openWriters.get(name);
+      if (existing) {
+        return existing;
+      }
+      const branch = {
+        buffer,
+        writer: createWriter(
+          (data) => {
+            branch.buffer += data;
+          },
+          {
+            ...options,
+            onJoin() {
+              openWriters.delete(name);
+              for (let i = firstOpenIndex; i < branches.length; i++) {
+                const b = branches[i];
+                if (!b) {
+                  continue;
+                } else if (b.writer.__isActive) {
+                  break;
+                }
+                sink(b.buffer);
+                branches[i] = null;
+                firstOpenIndex++;
+              }
+            }
+          }
+        )
+      };
+      branch.writer.indent = indentLevel;
+      openWriters.set(name, branch.writer);
+      branches.push(branch);
+      buffer = "";
+      return branch.writer;
+    },
+    join(recursive) {
+      var _a;
+      if (writer.__isActive) {
+        if (openWriters.size) {
+          if (recursive) {
+            for (const branch of openWriters.values()) {
+              branch.join(true);
+            }
+          } else {
+            throw new Error(
+              `Cannot join a Writer with un-joined branches - use the \`recursive\` argument to join all open branches`
+            );
+          }
+        }
+        buffer && sink(buffer);
+        writer.__isActive = false;
+        (_a = options == null ? void 0 : options.onJoin) == null ? void 0 : _a.call(options, writer);
+      }
+    }
+  };
+  return writer;
+}
+function createStringWriter(opts) {
+  let code = "";
+  const writer = createWriter((data) => {
+    code += data;
+  }, { indentWith: "	", ...opts });
+  return Object.assign(writer, {
+    end() {
+      writer.join(true);
+      return code;
+    }
+  });
+}
+
+// src/vite/routes/routeTrie.ts
+function createRouteTrie(routes) {
+  const root = {
+    key: ""
+  };
+  function insert(keys, value) {
+    let node = root;
+    for (const key of keys) {
+      if (key.startsWith("$$")) {
+        if (!node.catchAll) {
+          node.catchAll = value;
+          return true;
+        }
+        return false;
+      } else if (key.startsWith("$")) {
+        node = node.dynamic ?? (node.dynamic = {
+          key: ""
+        });
+      } else {
+        node.static ?? (node.static = /* @__PURE__ */ new Map());
+        let next = node.static.get(key);
+        if (!next) {
+          next = {
+            key
+          };
+          node.static.set(key, next);
+        }
+        node = next;
+      }
+    }
+    if (node.route === void 0) {
+      node.route = value;
+      return true;
+    }
+    return false;
+  }
+  for (const route of routes) {
+    const keys = route.path === "/" ? [] : route.path.split("/").slice(1);
+    insert(keys, route);
+  }
+  return root;
+}
+
+// src/vite/utils/route.ts
+function getVerbs(route) {
+  var _a, _b;
+  const verbs = ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.slice()) || [];
+  if (route.page && !verbs.includes("get")) {
+    verbs.unshift("get");
+  }
+  return verbs;
+}
+function hasVerb(route, verb) {
+  var _a, _b;
+  return verb === "get" && route.page || ((_b = (_a = route.handler) == null ? void 0 : _a.verbs) == null ? void 0 : _b.includes(verb));
+}
+
+// src/vite/codegen/index.ts
+var DefaultCodegenOptions = {
+  trailingSlashes: "RedirectWithout"
+};
+function renderRouteTemplate(route) {
+  if (!route.page) {
+    throw new Error(`Route ${route.key} has no page to render`);
+  }
+  const writer = createStringWriter();
+  writer.writeLines(
+    `// ${virtualFilePrefix}/${markoServeFilePrefix}route__${route.key}.marko`
+  );
+  writer.branch("imports");
+  writer.writeLines("");
+  writeRouteTemplateTag(writer, [...route.layouts, route.page]);
+  return writer.end();
+}
+function writeRouteTemplateTag(writer, [file, ...rest], index = 1) {
+  if (file) {
+    const isLast = !rest.length;
+    const tag = isLast ? "page" : `layout${index}`;
+    writer.branch("imports").writeLines(`import ${tag} from './${file.importPath}';`);
+    if (isLast) {
+      writer.writeLines(`<${tag} ...input />`);
+    } else {
+      writer.writeBlockStart(`<${tag} ...input>`);
+      writeRouteTemplateTag(writer, rest, index + 1);
+      writer.writeBlockEnd(`</>`);
+    }
+  }
+}
+function renderRouteEntry(route) {
+  var _a;
+  const { key, index, handler, page, middleware, meta } = route;
+  const verbs = getVerbs(route);
+  if (!verbs) {
+    throw new Error(
+      `Route ${key} doesn't have a handler or page for any HTTP verbs`
+    );
+  }
+  const writer = createStringWriter();
+  writer.writeLines(
+    `// ${virtualFilePrefix}/${markoServeFilePrefix}route__${key}.js`
+  );
+  const imports = writer.branch("imports");
+  let i = 1;
+  for (const { importPath } of middleware) {
+    imports.writeLines(`import middleware$${i} from './${importPath}';`);
+    i++;
+  }
+  if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.length) {
+    const names = handler.verbs.map(
+      (verb) => `${verb === "delete" ? "del" : verb} as handler$${verb}`
+    );
+    imports.writeLines(
+      `import { ${names.join(", ")} } from './${handler.importPath}';`
+    );
+  }
+  if (page) {
+    imports.writeLines(
+      `import page from '${virtualFilePrefix}/${markoServeFilePrefix}route__${key}.marko${serverEntryQuery}';`
+    );
+  }
+  if (meta) {
+    imports.writeLines(
+      `export { default as meta$${index} } from './${meta.importPath}';`
+    );
+  }
+  if (!page || verbs.length > 1) {
+    writer.writeLines("").writeBlockStart(`function create204Response() {`).writeBlockStart(`return new Response(null, {`).writeLines(`status: 204`).writeBlockEnd(`})`).writeBlockEnd(`}`);
+  }
+  for (const verb of verbs) {
+    writeRouteEntryHandler(writer, route, verb);
+  }
+  return writer.end();
+}
+function writePageResponseContinuation(writer) {
+  writer.writeBlock(
+    `return new Response(page.stream(ctx), {`,
+    ["status: 200,", 'headers: { "content-type": "text/html;charset=UTF-8" }'],
+    "});"
+  );
+}
+function writeRouteEntryHandler(writer, route, verb) {
+  var _a;
+  const { key, index, page, handler, middleware } = route;
+  const len = middleware.length;
+  let nextName;
+  let currentName;
+  let hasBody = false;
+  writer.writeLines("").writeBlockStart(`export async function ${verb}$${index}(ctx) {`);
+  const continuations = writer.branch("cont");
+  if (page && verb === "get") {
+    currentName = "createPageResponse";
+    if ((_a = handler == null ? void 0 : handler.verbs) == null ? void 0 : _a.includes(verb)) {
+      continuations.writeBlockStart(`async function ${currentName}() {`);
+      writePageResponseContinuation(continuations);
+      continuations.writeBlockEnd("}");
+      if (len) {
+        nextName = currentName;
+        currentName = `__handler$${verb}`;
+        continuations.writeBlock(
+          `async function ${currentName}() {`,
+          [`return await handler$${verb}(ctx, ${nextName});`],
+          "}"
+        );
+      } else {
+        writer.writeLines(`return await handler$${verb}(ctx, ${currentName})`);
+        hasBody = true;
+      }
+    } else if (len) {
+      continuations.writeBlockStart(`async function ${currentName}() {`);
+      writePageResponseContinuation(continuations);
+      continuations.writeBlockEnd("}");
+      nextName = currentName;
+    } else {
+      writePageResponseContinuation(continuations);
+      hasBody = true;
+    }
+  } else if (handler) {
+    currentName = `__handler$${verb}`;
+    if (len) {
+      continuations.writeBlock(
+        `async function ${currentName}() {`,
+        [`return await handler$${verb}(ctx, create204Response);`],
+        "}"
+      );
+    } else {
+      writer.writeLines(
+        `return await handler$${verb}(ctx, create204Response);`
+      );
+      hasBody = true;
+    }
+  } else {
+    throw new Error(`Route ${key} has no handler for ${verb} requests`);
+  }
+  if (!hasBody) {
+    let i = len;
+    while (--i) {
+      nextName = currentName;
+      currentName = `__middleware${i + 1}`;
+      continuations.writeLines("").writeBlock(
+        `async function ${currentName}() {`,
+        [`return await middleware$${i + 1}(ctx, ${nextName});`],
+        "}"
+      );
+    }
+    writer.writeLines(`return await middleware$1(ctx, ${currentName});`);
+  }
+  continuations.join();
+  writer.writeBlockEnd("}");
+}
+function renderRouter(routes, options = DefaultCodegenOptions) {
+  const writer = createStringWriter();
+  writer.writeLines(`// @marko/run/router`);
+  const imports = writer.branch("imports");
+  for (const route of routes.list) {
+    const verbs = getVerbs(route);
+    const names = verbs.map((verb) => `${verb}$${route.index}`);
+    route.meta && names.push(`meta$${route.index}`);
+    imports.writeLines(
+      `import { ${names.join(
+        ", "
+      )} } from '${virtualFilePrefix}/${markoServeFilePrefix}route__${route.key}.js';`
+    );
+  }
+  for (const { key } of Object.values(routes.special)) {
+    imports.writeLines(
+      `import page$${key} from '${virtualFilePrefix}/${markoServeFilePrefix}special__${key}.marko${serverEntryQuery}';`
+    );
+  }
+  writer.writeLines("").writeBlockStart(`function matchRoute(method, pathname) {`).writeBlockStart(`switch (method.toLowerCase()) {`);
+  for (const verb of httpVerbs) {
+    const filteredRoutes = routes.list.filter((route) => hasVerb(route, verb));
+    if (filteredRoutes.length) {
+      const trie = createRouteTrie(filteredRoutes);
+      writer.writeBlockStart(`case '${verb}': {`);
+      writeRouterVerb(writer, trie, verb);
+      writer.writeBlockEnd("}");
+    }
+  }
+  writer.writeBlockEnd("}").writeBlockEnd("}");
+  writer.writeLines("").writeBlockStart(`async function invokeRoute(route, url, request) {`);
+  const errorRoute = routes.special[RoutableFileTypes.Error];
+  if (errorRoute) {
+    writer.writeBlockStart(`try {`);
+  }
+  writer.writeBlock(
+    `if (route) {`,
+    [
+      `const [handler, params = {}, meta] = route;`,
+      `const response = await handler({ request, url, params, meta });`,
+      `if (response) return response;`
+    ],
+    `}`
+  );
+  const notFoundRoute = routes.special[RoutableFileTypes.NotFound];
+  if (notFoundRoute) {
+    writer.writeBlockStart(
+      `if (request.headers.get('Accept')?.includes('text/html')) {`
+    ).writeBlock(
+      `return new Response(page$404.stream({ request, url, params: {} }), {`,
+      [
+        `status: 404,`,
+        `headers: { "content-type": "text/html;charset=UTF-8" },`
+      ],
+      `});`
+    ).writeBlockEnd("}");
+  }
+  writer.writeLines(`return null;`);
+  if (errorRoute) {
+    writer.indent--;
+    writer.writeBlockStart(`} catch (err) {`).writeBlockStart(
+      `if (request.headers.get('Accept')?.includes('text/html')) {`
+    ).writeBlock(
+      `return new Response(page$500.stream({ request, url, params: {}, error: err }), {`,
+      [
+        `status: 500,`,
+        `headers: { "content-type": "text/html;charset=UTF-8" },`
+      ],
+      `});`
+    ).writeBlockEnd("}").writeLines(`throw err;`).writeBlockEnd("}");
+  }
+  writer.writeBlockEnd("}");
+  writer.write(`
+export function getMatchedRoute(method, url) {
+  const route = matchRoute(method, url.pathname);
+  if (route) {
+    const [handler, params = {}, meta] = route;
+    return {
+      handler,
+      params,
+      meta,
+      async invoke(request) {
+        return await invokeRoute(route, url, request);
+      }
+    }
+  }
+  return null;
+}
+
+export async function handler(context) {
+	const response = await router(context.request);
+	//if (response.body) {
+	//	context.waitUntil?.(once(Readable.from(response.body), "end"));
+	//}
+	return response;
+}
+
+export async function router(request) {
+  try {
+    const url = new URL(request.url);
+    let { pathname } = url;
+
+    if (pathname !== '/') {
+      if (pathname.endsWith('/')) {
+        pathname = pathname.replace(/\\/+$/, '');
+`);
+  switch (options.trailingSlashes) {
+    case "RedirectWithout":
+      writer.write(`
+        url.pathname = pathname;
+        return Response.redirect(url.href);
+`);
+      break;
+    case "RedirectWith":
+      writer.write(`
+      } else {
+        url.pathname = pathname + '/';
+        return Response.redirect(url.href);
+`);
+      break;
+    case "RewriteWithout":
+      writer.write(`
+        url.pathname = pathname;
+`);
+      break;
+    case "RewriteWith":
+      writer.write(`
+      } else {
+        url.pathname = pathname + '/';
+`);
+      break;
+  }
+  writer.write(`
+      }
+    }
+    const route = matchRoute(request.method, pathname);
+    return await invokeRoute(route, url, request) || new Response(null, {
+      statusText: \`Not Found (No route matched \${pathname})\`,
+      status: 404
+    });
+  } catch (err) {
+    const message = import.meta.env.DEV
+      ? \`Internal Server Error (\${err.message})\`
+      : "Internal Server Error";
+
+    return new Response(
+      JSON.stringify({
+        error: {
+          message,
+          stack: import.meta.env.DEV
+            ? \`This will only be seen in development mode\\n\\n\${err.stack}\`
+            : ""
+        }
+      }),
+      {
+        statusText: message,
+        status: 500,
+      }
+    );
+  }
+}`);
+  return writer.end();
+}
+function writeRouterVerb(writer, trie, verb, level = 0, pathIndex = 0, useSwitch) {
+  const { key, route: value, static: children, dynamic, catchAll } = trie;
+  pathIndex += key.length;
+  if (level <= 0) {
+    level = 0;
+    if (value) {
+      writer.writeLines(
+        `if (pathname === '/') return ${renderMatch(verb, value)}; // ${value.path}`
+      );
+    }
+    if (children || dynamic) {
+      writer.writeLines(
+        `const segments = pathname.split('/');`,
+        `const len = segments.length;`
+      );
+    }
+  } else {
+    if (!key) {
+      writer.writeBlockStart(`if (segments[${level}]) {`);
+    } else if (useSwitch) {
+      writer.writeBlockStart(`case '${key}':`);
+    } else {
+      writer.writeBlockStart(
+        `if (segments[${level}]?.toLowerCase() === '${key}') {`
+      );
+    }
+    if (value) {
+      writer.writeLines(
+        `if (len === ${level + 1}) return ${renderMatch(verb, value)}; // ${value.path}`
+      );
+    }
+  }
+  if (children || dynamic) {
+    if (children) {
+      if (children.size > 1) {
+        writer.writeBlockStart(
+          `switch(segments[${level + 1}]?.toLowerCase()) {`
+        );
+        for (const child of children.values()) {
+          writeRouterVerb(writer, child, verb, level + 1, pathIndex, true);
+        }
+        writer.writeBlockEnd("}");
+      } else {
+        for (const child of children.values()) {
+          writeRouterVerb(writer, child, verb, level + 1, pathIndex);
+        }
+      }
+    }
+    if (dynamic) {
+      writeRouterVerb(writer, dynamic, verb, level + 1, pathIndex);
+    }
+  }
+  if (catchAll) {
+    writer.writeLines(
+      `return ${renderMatch(verb, catchAll, pathIndex)}; // ${catchAll.path}`
+    );
+    if (level > 0) {
+      writer.indent--;
+    }
+  } else if (level === 0) {
+    writer.writeLines("return;");
+  } else if (useSwitch) {
+    writer.writeLines("break;").indent--;
+  } else {
+    writer.writeBlockEnd("}");
+  }
+}
+function renderParamsInfo(params, pathIndex) {
+  let result = "";
+  let catchAll = "";
+  let dynamicLength = "";
+  for (const { name, index } of params) {
+    if (index >= 0) {
+      result += result ? ", " : "{ ";
+      result += `'${name}': segments[${index + 1}]`;
+      dynamicLength += ` + segments[${index + 1}].length`;
+    } else if (pathIndex && pathIndex >= 0) {
+      catchAll = name;
+    }
+  }
+  if (catchAll) {
+    result += result ? ", " : "{ ";
+    result += `'${catchAll}': pathname.slice(${pathIndex}${dynamicLength})`;
+  }
+  return result ? result + " }" : "{}";
+}
+function renderMatch(verb, { index, params, meta }, pathIndex) {
+  const tuple = [`${verb}$${index}`];
+  if (params == null ? void 0 : params.length) {
+    tuple[1] = renderParamsInfo(params, pathIndex);
+  }
+  if (meta) {
+    tuple[2] = `meta$${index}`;
+  }
+  return `[${tuple.join(", ")}]`;
+}
+
+// src/vite/utils/ast.ts
+import * as t from "@babel/types";
+function getExportIdentifiers(astProgramNode) {
+  const result = [];
+  if (t.isProgram(astProgramNode)) {
+    for (const node of astProgramNode.body) {
+      if (t.isExportNamedDeclaration(node)) {
+        const { declaration, specifiers } = node;
+        if (declaration) {
+          if (t.isFunctionDeclaration(declaration) && declaration.id) {
+            result.push(declaration.id.name);
+          } else if (t.isVariableDeclaration(declaration)) {
+            for (const declarator of declaration.declarations) {
+              if (t.isIdentifier(declarator.id)) {
+                result.push(declarator.id.name);
+              }
+            }
+          }
+        } else if (specifiers) {
+          for (const specifier of specifiers) {
+            if (t.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported)) {
+              result.push(specifier.exported.name);
+            }
+          }
+        }
+      } else if (t.isExportDefaultDeclaration(node)) {
+        const { declaration } = node;
+        if (t.isObjectExpression(declaration)) {
+          for (const property of declaration.properties) {
+            if (t.isObjectMember(property) && t.isIdentifier(property.key)) {
+              result.push(property.key.name);
+            }
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/vite/utils/log.ts
+import Table from "cli-table3";
+import kleur from "kleur";
+import { gzipSizeSync } from "gzip-size";
+import prettyBytes from "pretty-bytes";
+var HttpVerbColors = {
+  get: kleur.green,
+  post: kleur.magenta,
+  put: kleur.cyan,
+  delete: kleur.red,
+  other: kleur.white
+};
+var HttpVerbOrder = {
+  get: 0,
+  post: 1,
+  put: 2,
+  delete: 3
+};
+function logRoutesTable(routes, bundle) {
+  const hasMiddleware = routes.list.some((route) => route.middleware.length);
+  const hasMeta = routes.list.some((route) => route.meta);
+  const headings = ["Method", "Path", "Entry"];
+  const colAligns = ["left", "left", "left"];
+  if (hasMiddleware) {
+    headings.push("MW");
+    colAligns.push("right");
+  }
+  if (hasMeta) {
+    headings.push("Meta");
+    colAligns.push("center");
+  }
+  headings.push("Size");
+  colAligns.push("right");
+  const table = new Table({
+    head: headings.map((title) => kleur.bold(kleur.white(title.toUpperCase()))),
+    wordWrap: true,
+    colAligns,
+    style: { compact: true }
+  });
+  for (const route of routes.list.sort((a, b) => b.score - a.score)) {
+    const verbs = getVerbs(route).sort(
+      (a, b) => HttpVerbOrder[a] - HttpVerbOrder[b]
+    );
+    let firstRow = true;
+    for (const verb of verbs) {
+      let size = "";
+      const entryType = [];
+      if (route.handler) {
+        entryType.push(kleur.blue("handler"));
+      }
+      if (verb === "get" && route.page) {
+        entryType.push(kleur.yellow("page"));
+        size = prettySize(computeRouteSize(route, bundle));
+      }
+      const row = [kleur.bold(HttpVerbColors[verb](verb.toUpperCase()))];
+      if (verbs.length === 1 || firstRow) {
+        row.push({ rowSpan: verbs.length, content: prettyPath(route.path) });
+        firstRow = false;
+      }
+      row.push(entryType.join(" -> "));
+      hasMiddleware && row.push(route.middleware.length || "");
+      hasMeta && row.push(route.meta ? "\u2713" : "");
+      row.push(size || { hAlign: "center", content: "-" });
+      table.push(row);
+    }
+  }
+  for (const [key, route] of Object.entries(routes.special).sort()) {
+    const row = [kleur.bold(kleur.white("*")), key, kleur.yellow("page")];
+    hasMiddleware && row.push("");
+    hasMeta && row.push("");
+    row.push(prettySize(computeRouteSize(route, bundle)));
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+function computeRouteSize(route, bundle) {
+  if (route.page) {
+    for (const chunk of Object.values(bundle)) {
+      if (chunk.type === "chunk" && chunk.modules[route.page.filePath]) {
+        return computeChunkSize(chunk, bundle);
+      }
+    }
+  }
+  return 0;
+}
+function computeChunkSize(chunk, bundle, seen = /* @__PURE__ */ new Set()) {
+  if (chunk.type === "asset") {
+    return gzipSizeSync(chunk.source);
+  }
+  let size = gzipSizeSync(chunk.code);
+  for (const id of chunk.imports) {
+    if (!seen.has(id)) {
+      size += computeChunkSize(bundle[id], bundle, seen);
+      seen.add(id);
+    }
+  }
+  return size;
+}
+function prettySize(size) {
+  const _size = prettyBytes(size, {
+    minimumFractionDigits: 1,
+    maximumFractionDigits: 1
+  }).replace(/\sB$/, " B ");
+  if (size < 20 * 1e3)
+    return kleur.green(_size);
+  if (size < 50 * 1e3)
+    return kleur.yellow(_size);
+  return kleur.bold(kleur.red(_size));
+}
+function prettyPath(path3) {
+  return path3.replace(/\/\$\$(.*)$/, (_, p) => "/" + kleur.bold(kleur.dim(`*${p}`))).replace(/\/\$([^/]+)/g, (_, p) => "/" + kleur.bold(kleur.dim(`:${p}`)));
+}
+
+// src/vite/utils/config.ts
+var KEY = "__MARKO_SERVE_OPTIONS__";
+function getMarkoServeOptions(viteConfig) {
+  return viteConfig[KEY];
+}
+function setMarkoServeOptions(viteConfig, options) {
+  viteConfig[KEY] = options;
+  return viteConfig;
+}
+
+// src/vite/plugin.ts
+var markoExt = ".marko";
+var markoServeFilePrefix2 = "__marko-serve__";
+function isMarkoFile(id) {
+  return id.endsWith(markoExt);
+}
+function markoServe(opts = {}) {
+  const { routesDir = "src/routes", adapter, ...markoOptions } = opts;
+  let store;
+  let root;
+  let resolvedRoutesDir;
+  let isBuild = false;
+  let isSSRBuild = false;
+  let ssrEntryFiles;
+  let devEntryFile;
+  let devServer;
+  let routes;
+  let routeData;
+  let routeDataFilename = "routes.json";
+  let extractVerbs;
+  let resolvedConfig;
+  let isStale = true;
+  let isRendered = false;
+  const virtualFiles = /* @__PURE__ */ new Map();
+  let times = {
+    routesBuild: 0,
+    routesRender: 0
+  };
+  async function setVirtualFiles(render = false) {
+    for (const route of routes.list) {
+      if (render && route.handler) {
+        route.handler.verbs = await extractVerbs(route.handler.filePath);
+        if (!route.handler.verbs.length) {
+          console.warn(
+            `Did not find any valid exports in middleware entry file:'${route.handler.filePath}' - expected to find any of 'get', 'post', 'put' or 'del'`
+          );
+        }
+      }
+      if (route.page) {
+        virtualFiles.set(
+          path2.join(root, `${markoServeFilePrefix2}route__${route.key}.marko`),
+          render ? renderRouteTemplate(route) : ""
+        );
+      }
+      virtualFiles.set(
+        path2.join(root, `${markoServeFilePrefix2}route__${route.key}.js`),
+        render ? renderRouteEntry(route) : ""
+      );
+    }
+    for (const route of Object.values(routes.special)) {
+      virtualFiles.set(
+        path2.join(root, `${markoServeFilePrefix2}special__${route.key}.marko`),
+        render ? renderRouteTemplate(route) : ""
+      );
+    }
+    virtualFiles.set(
+      "@marko/run/router",
+      render ? renderRouter(routes, opts.codegen) : ""
+    );
+  }
+  const buildVirtualFiles = single(async () => {
+    const startTime = performance.now();
+    routes = await buildRoutes(createFSWalker(resolvedRoutesDir), routesDir);
+    times.routesBuild = performance.now() - startTime;
+    await setVirtualFiles(false);
+    isStale = false;
+    isRendered = false;
+  });
+  const renderVirtualFiles = single(async () => {
+    const startTime = performance.now();
+    await setVirtualFiles(true);
+    times.routesRender = performance.now() - startTime;
+    isRendered = true;
+  });
+  return [
+    {
+      name: "marko-run-vite:pre",
+      enforce: "pre",
+      async config(config, env) {
+        var _a, _b, _c;
+        const externalPluginOptions = getMarkoServeOptions(config);
+        if (externalPluginOptions) {
+          opts = mergeConfig(opts, externalPluginOptions);
+        }
+        const adapterOptions = await ((_a = adapter == null ? void 0 : adapter.pluginOptions) == null ? void 0 : _a.call(adapter, opts));
+        if (adapterOptions) {
+          opts = mergeConfig(opts, adapterOptions);
+        }
+        root = normalizePath(config.root || process.cwd());
+        store = opts.store || new FileStore(
+          `marko-serve-vite-${crypto.createHash("SHA1").update(root).digest("hex")}`
+        );
+        isBuild = env.command === "build";
+        isSSRBuild = isBuild && Boolean((_b = config.build) == null ? void 0 : _b.ssr);
+        resolvedRoutesDir = path2.resolve(root, routesDir);
+        devEntryFile = path2.join(root, "index.html");
+        let pluginConfig = {
+          logLevel: isBuild ? "warn" : void 0,
+          define: isBuild ? {
+            "process.env.NODE_ENV": "'production'"
+          } : void 0,
+          build: {
+            emptyOutDir: isSSRBuild
+          }
+        };
+        const adapterConfig = await ((_c = adapter == null ? void 0 : adapter.viteConfig) == null ? void 0 : _c.call(adapter, config));
+        if (adapterConfig) {
+          pluginConfig = mergeConfig(pluginConfig, adapterConfig);
+        }
+        return setMarkoServeOptions(pluginConfig, opts);
+      },
+      configResolved(config) {
+        resolvedConfig = config;
+        const {
+          ssr,
+          rollupOptions: { input }
+        } = config.build;
+        if (typeof ssr === "string") {
+          ssrEntryFiles = [ssr];
+        } else if (typeof input === "string") {
+          ssrEntryFiles = [input];
+        } else if (Array.isArray(input)) {
+          ssrEntryFiles = input;
+        } else if (input) {
+          ssrEntryFiles = Object.values(input);
+        } else {
+          ssrEntryFiles = [];
+        }
+      },
+      configureServer(_server) {
+        devServer = _server;
+        devServer.watcher.on("all", async (type, filename) => {
+          const file = path2.parse(filename);
+          if (filename.startsWith(resolvedRoutesDir) && isRoutableFile(file.base)) {
+            if (type === "add") {
+              isStale = true;
+            } else if (type === "unlink") {
+              isStale = true;
+            } else if (type === "change") {
+              const match = matchRoutableFile(file.base);
+              if (match === RoutableFileTypes.Handler) {
+                isStale = true;
+              }
+            }
+            if (isStale) {
+              for (const id of virtualFiles.keys()) {
+                devServer.watcher.emit("change", id);
+              }
+            }
+          }
+        });
+      },
+      async buildStart(_options) {
+        if (isBuild && !isSSRBuild) {
+          try {
+            routeData = JSON.parse(
+              await store.get(routeDataFilename)
+            );
+          } catch {
+            this.error(
+              `You must run the "ssr" build before the "browser" build.`
+            );
+          }
+          routes = routeData.routes;
+          times = routeData.times;
+          for (const { key, code } of routeData.files) {
+            virtualFiles.set(key, code);
+          }
+          isStale = false;
+          isRendered = true;
+        } else {
+          extractVerbs = isBuild ? getVerbsFromFileBuild.bind(null, this) : getVerbsFromFileDev.bind(null, devServer);
+        }
+      },
+      async resolveId(importee, importer, { ssr }) {
+        let resolved;
+        if (importee.startsWith(virtualFilePrefix)) {
+          importee = path2.resolve(
+            root,
+            importee.slice(virtualFilePrefix.length + 1)
+          );
+        } else if (!isBuild && importer === devEntryFile && importee.startsWith(`/${markoServeFilePrefix2}`)) {
+          importee = path2.resolve(root, "." + importee);
+        }
+        if (isStale) {
+          await buildVirtualFiles();
+        }
+        if (virtualFiles.has(importee)) {
+          resolved = importee;
+          if (isBuild && !ssr && isMarkoFile(resolved)) {
+            resolved += browserEntryQuery;
+          }
+        }
+        return resolved || null;
+      },
+      async load(id) {
+        var _a;
+        if (virtualFiles.has(id)) {
+          if (!isRendered) {
+            await renderVirtualFiles();
+            if (!isBuild) {
+              await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+            }
+          }
+          return virtualFiles.get(id);
+        }
+      }
+    },
+    ...markoVitePlugin({
+      ...markoOptions,
+      get store() {
+        return store;
+      }
+    }),
+    {
+      name: "marko-run-vite:post",
+      enforce: "post",
+      async writeBundle(options, bundle) {
+        var _a;
+        if (isSSRBuild) {
+          const builtEntries = Object.values(bundle).reduce(
+            (acc, item) => {
+              if (item.type === "chunk" && item.isEntry) {
+                acc.push(path2.join(options.dir, item.fileName));
+              }
+              return acc;
+            },
+            []
+          );
+          routeData = {
+            routes,
+            files: [],
+            times,
+            builtEntries,
+            sourceEntries: ssrEntryFiles
+          };
+          for (const [key, code] of virtualFiles) {
+            routeData.files.push({ key, code });
+          }
+          await store.set(routeDataFilename, JSON.stringify(routeData));
+          await ((_a = opts == null ? void 0 : opts.emitRoutes) == null ? void 0 : _a.call(opts, routes.list));
+        } else if (isBuild) {
+          logRoutesTable(routes, bundle);
+        }
+      },
+      async closeBundle() {
+        if (isBuild && !isSSRBuild && (adapter == null ? void 0 : adapter.buildEnd)) {
+          await adapter.buildEnd(
+            resolvedConfig,
+            routes.list,
+            routeData.builtEntries,
+            routeData.sourceEntries
+          );
+        }
+      }
+    }
+  ];
+}
+async function getVerbsFromFileBuild(context, filePath) {
+  const verbs = [];
+  const result = await context.load({
+    id: filePath,
+    resolveDependencies: false
+  });
+  if (result) {
+    const exportIds = getExportIdentifiers(result.ast);
+    for (const id of exportIds) {
+      const verb = id === "del" ? "delete" : id;
+      if (httpVerbs.includes(verb)) {
+        verbs.push(verb);
+      }
+    }
+  }
+  return verbs;
+}
+async function getVerbsFromFileDev(devServer, filePath) {
+  const verbs = [];
+  const result = await devServer.transformRequest(filePath, { ssr: true });
+  if (result && result.code) {
+    const verbMatchReg = /__vite_ssr_exports__,\s+["'](get|post|put|del)["']/g;
+    let match = verbMatchReg.exec(result.code);
+    while (match) {
+      const verb = match[1] === "del" ? "delete" : match[1];
+      if (httpVerbs.includes(verb)) {
+        verbs.push(verb);
+      }
+      match = verbMatchReg.exec(result.code);
+    }
+  }
+  return verbs;
+}
+function single(fn) {
+  let promise;
+  return async (...args) => {
+    if (promise) {
+      return promise;
+    }
+    promise = fn(...args);
+    const result = await promise;
+    promise = void 0;
+    return result;
+  };
+}
+
+// src/vite/utils/server.ts
+import net from "net";
+import cp from "child_process";
+async function spawnServer(cmd, port = 0, cwd = process.cwd(), wait = 3e4) {
+  if (port <= 0) {
+    port = await getAvailablePort();
+  }
+  const proc = cp.spawn(cmd, {
+    cwd,
+    shell: true,
+    stdio: "inherit",
+    windowsHide: true,
+    env: { NODE_ENV: "development", ...process.env, PORT: `${port}` }
+  });
+  const close = () => {
+    proc.unref();
+    proc.kill();
+  };
+  let remaining = wait > 0 ? wait : Infinity;
+  while (!await isPortInUse(port)) {
+    if (remaining >= 100) {
+      remaining -= 100;
+      await sleep(100);
+    } else {
+      close();
+      throw new Error(
+        `site-write: timeout while wating for server to start on port "${port}".`
+      );
+    }
+  }
+  return {
+    port,
+    close
+  };
+}
+async function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const connection = net.connect(port).setNoDelay(true).setKeepAlive(false).on("error", () => done(false)).on("connect", () => done(true));
+    function done(connected) {
+      connection.end();
+      resolve(connected);
+    }
+  });
+}
+async function getAvailablePort() {
+  return new Promise((resolve) => {
+    const server = net.createServer().listen(0, () => {
+      const { port } = server.address();
+      server.close(() => resolve(port));
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  markoServe as default,
+  getAvailablePort,
+  isPortInUse,
+  spawnServer
+};