livemark 0.7.2 → 0.9.0

package/target/plugins/vite-livemark.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "vite";
+export interface LivemarkOptions {
+    defaultsRoot: string;
+    overridesRoot: string;
+    subdirs: string[];
+    configPath: string;
+}
+/** Livemark dev/build integration:
+ * - Redirects imports that land in `<defaultsRoot>/<subdir>/` to the matching
+ *   user file under `<overridesRoot>/<subdir>/` when it exists.
+ * - Watches `livemark.config.ts` and `.livemark/**` so edits, additions and
+ *   deletions trigger the right reload without manual restart. */
+export declare function livemark(opts: LivemarkOptions): Plugin;

package/target/plugins/vite-livemark.js

@@ -0,0 +1,76 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/** Livemark dev/build integration:
+ * - Redirects imports that land in `<defaultsRoot>/<subdir>/` to the matching
+ *   user file under `<overridesRoot>/<subdir>/` when it exists.
+ * - Watches `livemark.config.ts` and `.livemark/**` so edits, additions and
+ *   deletions trigger the right reload without manual restart. */
+export function livemark(opts) {
+    const EXT_RE = /\.(tsx|ts|jsx|js|css)(\?|$)/;
+    return {
+        name: "livemark",
+        enforce: "pre",
+        async resolveId(id, importer, options) {
+            if (!importer || !EXT_RE.test(id))
+                return null;
+            const resolved = await this.resolve(id, importer, {
+                ...options,
+                skipSelf: true,
+            });
+            if (!resolved)
+                return null;
+            const queryIdx = resolved.id.indexOf("?");
+            const path = queryIdx === -1 ? resolved.id : resolved.id.slice(0, queryIdx);
+            const query = queryIdx === -1 ? "" : resolved.id.slice(queryIdx);
+            for (const subdir of opts.subdirs) {
+                const defaultsSubdir = `${join(opts.defaultsRoot, subdir)}/`;
+                if (!path.startsWith(defaultsSubdir))
+                    continue;
+                const rel = path.slice(defaultsSubdir.length);
+                const userPath = join(opts.overridesRoot, subdir, rel);
+                if (existsSync(userPath))
+                    return userPath + query;
+                return null;
+            }
+            return null;
+        },
+        configureServer(server) {
+            server.watcher.add(opts.configPath);
+            server.watcher.add(join(opts.overridesRoot, "**/*"));
+            const overrideRoots = opts.subdirs.map(subdir => `${join(opts.overridesRoot, subdir)}/`);
+            const routesRoot = `${join(opts.overridesRoot, "routes")}/`;
+            const onChange = (file) => {
+                if (file === opts.configPath) {
+                    server.restart();
+                    return;
+                }
+                if (file.startsWith(routesRoot)) {
+                    server.restart();
+                    return;
+                }
+                for (let i = 0; i < opts.subdirs.length; i++) {
+                    const root = overrideRoots[i];
+                    if (!root || !file.startsWith(root))
+                        continue;
+                    const rel = file.slice(root.length);
+                    const subdir = opts.subdirs[i];
+                    if (!subdir)
+                        continue;
+                    const defaultPath = join(opts.defaultsRoot, subdir, rel);
+                    const mod = server.moduleGraph.getModuleById(defaultPath);
+                    if (mod)
+                        server.moduleGraph.invalidateModule(mod);
+                    server.ws.send({ type: "full-reload" });
+                    return;
+                }
+            };
+            server.watcher.on("add", onChange);
+            server.watcher.on("unlink", onChange);
+            server.watcher.on("change", file => {
+                if (file === opts.configPath)
+                    server.restart();
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vite-livemark.js","sourceRoot":"","sources":["../../source/plugins/vite-livemark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAUhC;;;;kEAIkE;AAClE,MAAM,UAAU,QAAQ,CAAC,IAAqB;IAC5C,MAAM,MAAM,GAAG,6BAA6B,CAAA;IAC5C,OAAO;QACL,IAAI,EAAE,UAAU;QAChB,OAAO,EAAE,KAAK;QACd,KAAK,CAAC,SAAS,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO;YACnC,IAAI,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBAAE,OAAO,IAAI,CAAA;YAC9C,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE,QAAQ,EAAE;gBAChD,GAAG,OAAO;gBACV,QAAQ,EAAE,IAAI;aACf,CAAC,CAAA;YACF,IAAI,CAAC,QAAQ;gBAAE,OAAO,IAAI,CAAA;YAC1B,MAAM,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YACzC,MAAM,IAAI,GACR,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAA;YAChE,MAAM,KAAK,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;YAChE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAClC,MAAM,cAAc,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC,GAAG,CAAA;gBAC5D,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;oBAAE,SAAQ;gBAC9C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAA;gBAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;gBACtD,IAAI,UAAU,CAAC,QAAQ,CAAC;oBAAE,OAAO,QAAQ,GAAG,KAAK,CAAA;gBACjD,OAAO,IAAI,CAAA;YACb,CAAC;YACD,OAAO,IAAI,CAAA;QACb,CAAC;QACD,eAAe,CAAC,MAAM;YACpB,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YACnC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAA;YAEpD,MAAM,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CACpC,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,GAAG,CACjD,CAAA;YACD,MAAM,UAAU,GAAG,GAAG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,GAAG,CAAA;YAE3D,MAAM,QAAQ,GAAG,CAAC,IAAY,EAAE,EAAE;gBAChC,IAAI,IAAI,KAAK,IAAI,CAAC,UAAU,EAAE,CAAC;oBAC7B,MAAM,CAAC,OAAO,EAAE,CAAA;oBAChB,OAAM;gBACR,CAAC;gBAED,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;oBAChC,MAAM,CAAC,OAAO,EAAE,CAAA;oBAChB,OAAM;gBACR,CAAC;gBAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7C,MAAM,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;oBAC7B,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;wBAAE,SAAQ;oBAC7C,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;oBACnC,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAA;oBAC9B,IAAI,CAAC,MAAM;wBAAE,SAAQ;oBACrB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,GAAG,CAAC,CAAA;oBACxD,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,CAAA;oBACzD,IAAI,GAAG;wBAAE,MAAM,CAAC,WAAW,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAA;oBACjD,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAA;oBACvC,OAAM;gBACR,CAAC;YACH,CAAC,CAAA;YAED,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;YAClC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAA;YACrC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE;gBACjC,IAAI,IAAI,KAAK,IAAI,CAAC,UAAU;oBAAE,MAAM,CAAC,OAAO,EAAE,CAAA;YAChD,CAAC,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["import { existsSync } from \"node:fs\"\nimport { join } from \"node:path\"\nimport type { Plugin } from \"vite\"\n\nexport interface LivemarkOptions {\n  defaultsRoot: string\n  overridesRoot: string\n  subdirs: string[]\n  configPath: string\n}\n\n/** Livemark dev/build integration:\n * - Redirects imports that land in `<defaultsRoot>/<subdir>/` to the matching\n *   user file under `<overridesRoot>/<subdir>/` when it exists.\n * - Watches `livemark.config.ts` and `.livemark/**` so edits, additions and\n *   deletions trigger the right reload without manual restart. */\nexport function livemark(opts: LivemarkOptions): Plugin {\n  const EXT_RE = /\\.(tsx|ts|jsx|js|css)(\\?|$)/\n  return {\n    name: \"livemark\",\n    enforce: \"pre\",\n    async resolveId(id, importer, options) {\n      if (!importer || !EXT_RE.test(id)) return null\n      const resolved = await this.resolve(id, importer, {\n        ...options,\n        skipSelf: true,\n      })\n      if (!resolved) return null\n      const queryIdx = resolved.id.indexOf(\"?\")\n      const path =\n        queryIdx === -1 ? resolved.id : resolved.id.slice(0, queryIdx)\n      const query = queryIdx === -1 ? \"\" : resolved.id.slice(queryIdx)\n      for (const subdir of opts.subdirs) {\n        const defaultsSubdir = `${join(opts.defaultsRoot, subdir)}/`\n        if (!path.startsWith(defaultsSubdir)) continue\n        const rel = path.slice(defaultsSubdir.length)\n        const userPath = join(opts.overridesRoot, subdir, rel)\n        if (existsSync(userPath)) return userPath + query\n        return null\n      }\n      return null\n    },\n    configureServer(server) {\n      server.watcher.add(opts.configPath)\n      server.watcher.add(join(opts.overridesRoot, \"**/*\"))\n\n      const overrideRoots = opts.subdirs.map(\n        subdir => `${join(opts.overridesRoot, subdir)}/`,\n      )\n      const routesRoot = `${join(opts.overridesRoot, \"routes\")}/`\n\n      const onChange = (file: string) => {\n        if (file === opts.configPath) {\n          server.restart()\n          return\n        }\n\n        if (file.startsWith(routesRoot)) {\n          server.restart()\n          return\n        }\n\n        for (let i = 0; i < opts.subdirs.length; i++) {\n          const root = overrideRoots[i]\n          if (!root || !file.startsWith(root)) continue\n          const rel = file.slice(root.length)\n          const subdir = opts.subdirs[i]\n          if (!subdir) continue\n          const defaultPath = join(opts.defaultsRoot, subdir, rel)\n          const mod = server.moduleGraph.getModuleById(defaultPath)\n          if (mod) server.moduleGraph.invalidateModule(mod)\n          server.ws.send({ type: \"full-reload\" })\n          return\n        }\n      }\n\n      server.watcher.on(\"add\", onChange)\n      server.watcher.on(\"unlink\", onChange)\n      server.watcher.on(\"change\", file => {\n        if (file === opts.configPath) server.restart()\n      })\n    },\n  }\n}\n"]}

package/target/program.js

@@ -0,0 +1,18 @@
+import { Command } from "commander";
+import { build } from "./commands/build.js";
+import { escape } from "./commands/escape.js";
+import { preview } from "./commands/preview.js";
+import { start } from "./commands/start.js";
+import { helpConfiguration } from "./helpers/program.js";
+import packageJson from "../package.json" with { type: "json" };
+export const program = new Command()
+    .name("livemark")
+    .description("Livemark static site generator")
+    .version(packageJson.version, "-v, --version", "display the livemark version")
+    .option("-c, --config <path>", "path to config file")
+    .configureHelp(helpConfiguration)
+    .addCommand(start)
+    .addCommand(build)
+    .addCommand(preview)
+    .addCommand(escape);
+//# sourceMappingURL=data:application/json;base64,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

package/target/routeTree.gen.d.ts

@@ -0,0 +1,57 @@
+import { Route as rootRouteImport } from './routes/__root';
+import { Route as splatRouteImport } from './routes/$';
+import { Route as IndexRouteImport } from './../.livemark/routes/index';
+declare const splatRoute: any;
+declare const IndexRoute: any;
+export interface FileRoutesByFullPath {
+    '/': typeof IndexRoute;
+    '/$': typeof splatRoute;
+}
+export interface FileRoutesByTo {
+    '/': typeof IndexRoute;
+    '/$': typeof splatRoute;
+}
+export interface FileRoutesById {
+    __root__: typeof rootRouteImport;
+    '/': typeof IndexRoute;
+    '/$': typeof splatRoute;
+}
+export interface FileRouteTypes {
+    fileRoutesByFullPath: FileRoutesByFullPath;
+    fullPaths: '/' | '/$';
+    fileRoutesByTo: FileRoutesByTo;
+    to: '/' | '/$';
+    id: '__root__' | '/' | '/$';
+    fileRoutesById: FileRoutesById;
+}
+export interface RootRouteChildren {
+    IndexRoute: typeof IndexRoute;
+    splatRoute: typeof splatRoute;
+}
+declare module '@tanstack/react-router' {
+    interface FileRoutesByPath {
+        '/$': {
+            id: '/$';
+            path: '/$';
+            fullPath: '/$';
+            preLoaderRoute: typeof splatRouteImport;
+            parentRoute: typeof rootRouteImport;
+        };
+        '/': {
+            id: '/';
+            path: '/';
+            fullPath: '/';
+            preLoaderRoute: typeof IndexRouteImport;
+            parentRoute: typeof rootRouteImport;
+        };
+    }
+}
+export declare const routeTree: any;
+import type { getRouter } from './router.tsx';
+declare module '@tanstack/react-start' {
+    interface Register {
+        ssr: true;
+        router: Awaited<ReturnType<typeof getRouter>>;
+    }
+}
+export {};

package/target/routeTree.gen.js

@@ -0,0 +1,27 @@
+/* eslint-disable */
+// @ts-nocheck
+// noinspection JSUnusedGlobalSymbols
+// This file was automatically generated by TanStack Router.
+// You should NOT make any changes in this file as it will be overwritten.
+// Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
+import { Route as rootRouteImport } from './routes/__root';
+import { Route as splatRouteImport } from './routes/$';
+import { Route as IndexRouteImport } from './../.livemark/routes/index';
+const splatRoute = splatRouteImport.update({
+    id: '/$',
+    path: '/$',
+    getParentRoute: () => rootRouteImport,
+});
+const IndexRoute = IndexRouteImport.update({
+    id: '/',
+    path: '/',
+    getParentRoute: () => rootRouteImport,
+});
+const rootRouteChildren = {
+    IndexRoute: IndexRoute,
+    splatRoute: splatRoute,
+};
+export const routeTree = rootRouteImport
+    ._addFileChildren(rootRouteChildren)
+    ._addFileTypes();
+//# sourceMappingURL=data:application/json;base64,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

package/target/router.d.ts

@@ -0,0 +1,6 @@
+export declare function getRouter(): import("@tanstack/router-core").RouterCore<any, "always", false, import("@tanstack/history").RouterHistory, Record<string, any>>;
+declare module "@tanstack/react-router" {
+    interface Register {
+        router: ReturnType<typeof getRouter>;
+    }
+}

package/target/router.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { QueryClient } from "@tanstack/react-query";
+import { createRouter } from "@tanstack/react-router";
+import { setupRouterSsrQueryIntegration } from "@tanstack/react-router-ssr-query";
+import { DefaultCatchBoundary } from "./components/DefaultCatchBoundary.js";
+import { NotFound } from "./components/NotFound.js";
+import { routeTree } from "./routeTree.gen.js";
+export function getRouter() {
+    const queryClient = new QueryClient();
+    const router = createRouter({
+        routeTree,
+        context: { queryClient },
+        trailingSlash: "always",
+        defaultPreload: "intent",
+        defaultViewTransition: true,
+        defaultErrorComponent: DefaultCatchBoundary,
+        defaultNotFoundComponent: () => _jsx(NotFound, {}),
+        scrollRestoration: true,
+    });
+    setupRouterSsrQueryIntegration({
+        router,
+        queryClient,
+    });
+    return router;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/target/routes/$.d.ts

@@ -0,0 +1 @@
+export declare const Route: import("@tanstack/router-core").Route<import("@tanstack/react-router").Register, any, "/$", "/$", "/$", "/$", undefined, import("@tanstack/react-router").ResolveParams<"/$">, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, {}, ({ params }: import("@tanstack/router-core").LoaderFnContext<import("@tanstack/react-router").Register, any, "/$", import("@tanstack/react-router").ResolveParams<"/$">, {}, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, unknown, undefined>) => any, unknown, unknown, unknown, unknown, undefined>;

package/target/routes/$.js

@@ -0,0 +1,85 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createFileRoute, notFound, redirect } from "@tanstack/react-router";
+import { currentSection, firstArticle, homeArticle, sortedArticles, } from "../content/article.js";
+import { sectionTags } from "../content/tag.js";
+import { Article } from "../components/Article.js";
+import { BlogIndex } from "../components/BlogIndex.js";
+import { ChangelogIndex } from "../components/ChangelogIndex.js";
+import { TagIndex } from "../components/TagIndex.js";
+import markdownCss from "../styles/markdown.css?url";
+export const Route = createFileRoute("/$")({
+    loader: ({ params }) => {
+        if (!params._splat) {
+            if (homeArticle)
+                return { ...homeArticle, sidebar: homeArticle.sidebar };
+            if (!firstArticle)
+                throw notFound();
+            throw redirect({
+                to: "/$",
+                params: { _splat: firstArticle.path.replace(/^\/|\/$/g, "") },
+            });
+        }
+        const splat = `/${params._splat}/`;
+        const article = sortedArticles.find(a => a.path === splat);
+        if (article)
+            return article;
+        const section = currentSection(splat);
+        if (section?.type === "changelog" && section.prefix === splat) {
+            return {
+                changelogIndex: true,
+                sectionPrefix: section.prefix,
+                title: section.title,
+                sidebar: true,
+            };
+        }
+        if (section?.type === "blog") {
+            if (section.prefix === splat) {
+                return {
+                    blogIndex: true,
+                    sectionPrefix: section.prefix,
+                    title: section.title,
+                    sidebar: true,
+                };
+            }
+            const tagMatch = splat.match(new RegExp(`^${section.prefix}tags/([^/]+)/$`));
+            const tag = tagMatch?.[1];
+            if (tag) {
+                const tagMap = sectionTags.get(section.prefix);
+                if (tagMap?.has(tag)) {
+                    return {
+                        tagPage: true,
+                        sectionPrefix: section.prefix,
+                        tag,
+                        title: `Posts tagged '${tag}'`,
+                        sidebar: true,
+                    };
+                }
+            }
+        }
+        throw notFound();
+    },
+    head: ({ loaderData }) => ({
+        meta: [
+            ...(loaderData ? [{ title: loaderData.title }] : []),
+            ...("description" in loaderData && loaderData.description
+                ? [{ name: "description", content: loaderData.description }]
+                : []),
+        ],
+        links: [{ rel: "stylesheet", href: markdownCss }],
+    }),
+    component: Component,
+});
+function Component() {
+    const data = Route.useLoaderData();
+    if ("blogIndex" in data) {
+        return _jsx(BlogIndex, { sectionPrefix: data.sectionPrefix });
+    }
+    if ("changelogIndex" in data) {
+        return _jsx(ChangelogIndex, { sectionPrefix: data.sectionPrefix });
+    }
+    if ("tagPage" in data) {
+        return _jsx(TagIndex, { sectionPrefix: data.sectionPrefix, tag: data.tag });
+    }
+    return _jsx(Article, { article: data });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/target/routes/__root.d.ts

@@ -0,0 +1 @@
+export declare const Route: import("@tanstack/react-router").RootRoute<import("@tanstack/react-router").Register, undefined, {}, import("@tanstack/react-router").AnyContext, import("@tanstack/react-router").AnyContext, {}, undefined, unknown, unknown, unknown, unknown, undefined>;

package/target/routes/__root.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TanStackDevtools } from "@tanstack/react-devtools";
+import { ReactQueryDevtoolsPanel } from "@tanstack/react-query-devtools";
+import { createRootRoute, HeadContent, Outlet, Scripts, useMatch, } from "@tanstack/react-router";
+import { TanStackRouterDevtoolsPanel } from "@tanstack/react-router-devtools";
+import { Layout } from "../components/Layout.js";
+import { DefaultCatchBoundary } from "../components/DefaultCatchBoundary.js";
+import { NotFound } from "../components/NotFound.js";
+import { Toaster } from "../elements/sonner.js";
+import { faviconType } from "../helpers/favicon.js";
+import defaultFavicon from "../assets/logo.svg";
+import generalCss from "../styles/general.css?url";
+export const Route = createRootRoute({
+    head: () => {
+        const favicon = import.meta.env.CONFIG.favicon ??
+            import.meta.env.CONFIG.logo ??
+            defaultFavicon;
+        return {
+            meta: [
+                { charSet: "utf-8" },
+                { title: import.meta.env.CONFIG.title },
+                { name: "description", content: import.meta.env.CONFIG.description },
+                { property: "og:title", content: import.meta.env.CONFIG.title },
+                {
+                    property: "og:description",
+                    content: import.meta.env.CONFIG.description,
+                },
+                { property: "og:site_name", content: import.meta.env.CONFIG.title },
+                { property: "og:type", content: "website" },
+                {
+                    name: "viewport",
+                    content: "width=device-width, initial-scale=1",
+                },
+            ],
+            links: [
+                { rel: "icon", href: favicon, type: faviconType(favicon) },
+                { rel: "stylesheet", href: generalCss },
+            ],
+        };
+    },
+    notFoundComponent: () => _jsx(NotFound, {}),
+    errorComponent: props => {
+        return (_jsx(Document, { children: _jsx(DefaultCatchBoundary, { ...props }) }));
+    },
+    component: () => {
+        return (_jsx(Document, { children: _jsx(Outlet, {}) }));
+    },
+});
+function Document(props) {
+    const articleRoute = useMatch({ from: "/$", shouldThrow: false });
+    const withSidebar = articleRoute?.loaderData?.sidebar;
+    return (_jsxs("html", { lang: "en", children: [
+            _jsx("head", { children: _jsx(HeadContent, {}) }), _jsxs("body", { children: [
+                    _jsx(Layout, { withSidebar: withSidebar, children: props.children }), _jsx(Toaster, { position: "top-center" }), _jsx(TanStackDevtools, { config: { hideUntilHover: true, position: "bottom-left" }, plugins: [
+                            {
+                                name: "TanStack Query",
+                                render: _jsx(ReactQueryDevtoolsPanel, {}),
+                                defaultOpen: true,
+                            },
+                            {
+                                name: "TanStack Router",
+                                render: _jsx(TanStackRouterDevtoolsPanel, {}),
+                                defaultOpen: false,
+                            },
+                        ] }), _jsx(Scripts, {})
+                ] })
+        ] }));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/target/server.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@tanstack/react-start/server-entry").ServerEntry;
+export default _default;

package/target/server.js

@@ -0,0 +1,7 @@
+import handler, { createServerEntry } from "@tanstack/react-start/server-entry";
+export default createServerEntry({
+    fetch(request) {
+        return handler.fetch(request);
+    },
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VydmVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc291cmNlL3NlcnZlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE9BQU8sRUFBRSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sb0NBQW9DLENBQUE7QUFFL0UsZUFBZSxpQkFBaUIsQ0FBQztJQUMvQixLQUFLLENBQUMsT0FBTztRQUNYLE9BQU8sT0FBTyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQUMvQixDQUFDO0NBQ0YsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGhhbmRsZXIsIHsgY3JlYXRlU2VydmVyRW50cnkgfSBmcm9tIFwiQHRhbnN0YWNrL3JlYWN0LXN0YXJ0L3NlcnZlci1lbnRyeVwiXG5cbmV4cG9ydCBkZWZhdWx0IGNyZWF0ZVNlcnZlckVudHJ5KHtcbiAgZmV0Y2gocmVxdWVzdCkge1xuICAgIHJldHVybiBoYW5kbGVyLmZldGNoKHJlcXVlc3QpXG4gIH0sXG59KVxuIl19

package/target/settings.js

@@ -0,0 +1,7 @@
+/** Sub-directories of `website/` that participate in the override mechanism. */
+export const OVERRIDE_SUBDIRS = [
+    "components",
+    "elements",
+    "styles",
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0dGluZ3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zb3VyY2Uvc2V0dGluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsZ0ZBQWdGO0FBQ2hGLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFzQjtJQUNqRCxZQUFZO0lBQ1osVUFBVTtJQUNWLFFBQVE7Q0FDVCxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIFN1Yi1kaXJlY3RvcmllcyBvZiBgd2Vic2l0ZS9gIHRoYXQgcGFydGljaXBhdGUgaW4gdGhlIG92ZXJyaWRlIG1lY2hhbmlzbS4gKi9cbmV4cG9ydCBjb25zdCBPVkVSUklERV9TVUJESVJTOiByZWFkb25seSBzdHJpbmdbXSA9IFtcbiAgXCJjb21wb25lbnRzXCIsXG4gIFwiZWxlbWVudHNcIixcbiAgXCJzdHlsZXNcIixcbl1cbiJdfQ==

package/target/utils/style.d.ts

@@ -0,0 +1,2 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;

package/target/utils/style.js

@@ -0,0 +1,6 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3R5bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zb3VyY2UvdXRpbHMvc3R5bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFtQixJQUFJLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFDNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBRXhDLE1BQU0sVUFBVSxFQUFFLENBQUMsR0FBRyxNQUFvQjtJQUN4QyxPQUFPLE9BQU8sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQTtBQUM5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgdHlwZSBDbGFzc1ZhbHVlLCBjbHN4IH0gZnJvbSBcImNsc3hcIlxuaW1wb3J0IHsgdHdNZXJnZSB9IGZyb20gXCJ0YWlsd2luZC1tZXJnZVwiXG5cbmV4cG9ydCBmdW5jdGlvbiBjbiguLi5pbnB1dHM6IENsYXNzVmFsdWVbXSkge1xuICByZXR1cm4gdHdNZXJnZShjbHN4KGlucHV0cykpXG59XG4iXX0=

package/target/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/target/vite.config.js

@@ -0,0 +1,67 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import contentCollections from "@content-collections/vite";
+import tailwind from "@tailwindcss/vite";
+import { devtools } from "@tanstack/devtools-vite";
+import { tanstackStart } from "@tanstack/react-start/plugin/vite";
+import { physical, rootRoute, route, } from "@tanstack/virtual-file-routes";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+import svgr from "vite-plugin-svgr";
+import { loadConfig } from "./actions/config/load.js";
+import { WebsiteConfig } from "./models/config.js";
+import { OVERRIDE_SUBDIRS } from "./settings.js";
+import { livemark } from "./plugins/vite-livemark.js";
+const config = await loadConfig();
+const sourceDir = import.meta.dirname;
+const sourceRelative = relative(config.root, sourceDir);
+const overridesRoot = join(config.root, ".livemark");
+// Seed `.livemark/.gitignore` on first run so Vite's build/cache artifacts
+// never get committed by accident.
+const gitignorePath = join(overridesRoot, ".gitignore");
+if (!existsSync(gitignorePath)) {
+    mkdirSync(overridesRoot, { recursive: true });
+    writeFileSync(gitignorePath, "/build\n/cache\n");
+}
+const routeChildren = [route("/$", "$.tsx")];
+if (existsSync(join(overridesRoot, "routes"))) {
+    // physical() resolves its argument relative to this file. Hardcoding a
+    // relative literal lands at <pkg>/.livemark/ when livemark is installed
+    // under node_modules/. Compute it from the consumer's overridesRoot.
+    routeChildren.push(physical(relative(sourceDir, join(overridesRoot, "routes"))));
+}
+export default defineConfig({
+    root: config.root,
+    publicDir: join(config.root, ".livemark", "public"),
+    build: { outDir: ".livemark/build" },
+    define: {
+        "import.meta.env.CONFIG": JSON.stringify(WebsiteConfig.parse(config)),
+    },
+    plugins: [
+        livemark({
+            defaultsRoot: sourceDir,
+            overridesRoot,
+            subdirs: [...OVERRIDE_SUBDIRS],
+            configPath: config.configPath,
+        }),
+        devtools(),
+        tailwind(),
+        contentCollections({
+            configPath: join(sourceRelative, "content-collections.ts"),
+        }),
+        tanstackStart({
+            srcDirectory: sourceRelative,
+            pages: [{ path: "/" }],
+            prerender: { enabled: true, crawlLinks: true },
+            sitemap: config.site
+                ? { enabled: true, host: config.site }
+                : { enabled: false },
+            router: {
+                virtualRouteConfig: rootRoute("__root.tsx", routeChildren),
+            },
+        }),
+        react(),
+        svgr(),
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,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