comarkserv 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,301 @@
+import { ComarkPlugin, ConditionalNodeHandler, Node, NodeHandler } from "comark";
+import { TocLink } from "comark/plugins/toc";
+//#region src/markdown.d.ts
+interface MarkdownRendererOptions {
+  /** Show line numbers on all code blocks. */
+  lineNumbers?: boolean;
+  /** More Comark plugins. They run after the built-in plugins. */
+  plugins?: ComarkPlugin[];
+  /** More Comark components. A component with a built-in name replaces the built-in one. */
+  components?: Record<string, NodeHandler | ConditionalNodeHandler>;
+  /** Changes the `href` of each link. The static build uses it to change `.md` links to `.html`. */
+  transformLink?: (href: string) => string;
+}
+interface MarkdownFeatures {
+  math: boolean;
+  mermaid: boolean;
+}
+interface RenderedMarkdown {
+  html: string;
+  title: string | undefined;
+  description: string | undefined;
+  frontmatter: Record<string, unknown>;
+  toc: TocLink[];
+  features: MarkdownFeatures;
+}
+interface RenderOptions {
+  /** Changes the `href` of each link for this call. It replaces the `transformLink` of the renderer. */
+  transformLink?: (href: string) => string;
+}
+type MarkdownRenderer = (source: string, options?: RenderOptions) => Promise<RenderedMarkdown>;
+export declare function createMarkdownRenderer(options?: MarkdownRendererOptions): MarkdownRenderer;
+//#endregion
+//#region src/theme-parse.d.ts
+/** A color theme with the 16 base16 slots, from `base00` to `base0F`. */
+interface Palette {
+  id: string;
+  name: string;
+  variant: "light" | "dark";
+  /** The 16 slots as `#rrggbb`, from `base00` to `base0F`. */
+  colors: string[];
+  /** An accent color. Omarchy themes have one. Other themes use `base0D`. */
+  accent?: string;
+}
+/**
+ * Reads a base16 or base24 scheme (YAML) or an Omarchy `colors.toml`.
+ * Returns `undefined` when the text is not a complete scheme.
+ *
+ * The colors go into CSS, and the text can come from the network, so the
+ * function accepts only hex colors. The browser gets this function with
+ * `toString()`, so it must not use anything from outside its body.
+ */
+export declare function parseTheme(text: string, id: string, fallbackName: string): Palette | undefined;
+//#endregion
+//#region src/themes.d.ts
+/** The remote theme sources. Each theme is one file in a GitHub repository. */
+export declare const THEME_SOURCES: {
+  readonly base16: {
+    readonly repo: "tinted-theming/schemes";
+    readonly dir: "base16/";
+    readonly suffix: ".yaml";
+  };
+  readonly base24: {
+    readonly repo: "tinted-theming/schemes";
+    readonly dir: "base24/";
+    readonly suffix: ".yaml";
+  };
+  readonly omarchy: {
+    readonly repo: "basecamp/omarchy";
+    readonly dir: "themes/";
+    readonly suffix: "/colors.toml";
+  };
+};
+type ThemeSource = keyof typeof THEME_SOURCES;
+interface CatalogEntry {
+  /** The value for `--theme`, such as `base16:nord`. */
+  id: string;
+  name: string;
+  source: ThemeSource | "omarchy-live";
+  /** The URL of the theme file. */
+  url: string;
+}
+interface ThemeStoreOptions {
+  /** The directory for downloaded themes and listings. @default ~/.cache/comarkserv/themes */
+  cacheDir?: string;
+  fetch?: (input: string) => Promise<Response>;
+  now?: () => number;
+  /** The `colors.toml` of the current Omarchy theme. */
+  omarchyPath?: string;
+}
+interface ThemeStore {
+  /** Lists the themes of all remote sources. `urlFor` gives the URL of each entry. @default the raw GitHub URL */
+  catalog: (urlFor?: (source: ThemeSource, id: string) => string) => Promise<CatalogEntry[]>;
+  /** Returns the text of a remote theme, or `undefined` when it does not exist. */
+  raw: (source: ThemeSource, id: string) => Promise<string | undefined>;
+  /**
+   * Loads the theme for a `--theme` value. Returns `undefined` for the built-in GitHub theme.
+   * Rejects with a message when it cannot load the theme.
+   */
+  load: (spec: string, cwd?: string) => Promise<Palette | undefined>;
+}
+/** The `colors.toml` of the current Omarchy theme. `omarchy-theme-set` replaces it on each change. */
+export declare const OMARCHY_CURRENT: string;
+export declare function createThemeStore(options?: ThemeStoreOptions): ThemeStore;
+//#endregion
+//#region src/build.d.ts
+interface BuildOptions extends MarkdownRendererOptions {
+  /** The directory to build. @default process.cwd() */
+  root?: string;
+  /** The directory for the site. The build deletes an earlier build in it. @default "dist" */
+  outDir?: string;
+  /** Include dotfiles. `.well-known` is always included. @default false */
+  dotfiles?: boolean;
+  /** The default theme, as for the server. A theme that does not load stops the build. @default "github" */
+  theme?: string;
+  /** Write the theme catalog, so the theme picker of the site can list all themes. @default true */
+  themeCatalog?: boolean;
+  /** The store that loads and caches the themes. */
+  themeStore?: ThemeStore;
+}
+interface BuildResult {
+  outDir: string;
+  /** The number of HTML pages that the build wrote. */
+  pages: number;
+  /** The number of other files that the build copied. */
+  files: number;
+  ms: number;
+  /** Problems that did not stop the build. */
+  warnings: string[];
+}
+/** Changes the path of a markdown file to the path of its HTML page. */
+export declare function toHtmlPath(path: string): string;
+/**
+ * Returns a link transform for a page in `directory` (from the root, `""` for the root).
+ * Links to markdown files go to their HTML pages, and links to directories go to their `index.html`.
+ */
+export declare function staticLinkTransform(directory: string): (href: string) => string;
+/** Builds a static HTML site from a directory. */
+export declare function build(options?: BuildOptions): Promise<BuildResult>;
+//#endregion
+//#region src/editor.d.ts
+/** Opens a file in the editor of the user, at a line when one is given. */
+type OpenEditor = (file: string, line?: number) => Promise<void>;
+//#endregion
+//#region src/share.d.ts
+interface ShareStatus {
+  state: "off" | "starting" | "on";
+  /** The public URL, when the state is "on". */
+  url?: string;
+  /** True when cloudflared is not installed, so the user must accept the Cloudflare license first. */
+  needsConsent: boolean;
+  /** The error of the last start that failed. */
+  error?: string;
+}
+interface ShareService {
+  status: () => ShareStatus;
+  /** Starts the tunnel to `origin`, or returns the URL of the tunnel that runs. */
+  start: (options: {
+    origin: string;
+    accept?: boolean;
+  }) => Promise<string>;
+  stop: () => Promise<void>;
+  subscribe: (listener: (status: ShareStatus) => void) => () => void;
+}
+//#endregion
+//#region src/handler.d.ts
+/** The URL prefix of the files and endpoints of comarkserv itself. */
+export declare const INTERNAL_PREFIX = "/__comarkserv/";
+interface ComarkservOptions extends MarkdownRendererOptions {
+  /** The directory to serve. @default process.cwd() */
+  root?: string;
+  /** Watch the files and update open pages when they change. @default true */
+  livereload?: boolean;
+  /** Serve and list dotfiles, such as `.github/`. `.well-known` is always served. @default false */
+  dotfiles?: boolean;
+  /** The maximum number of rendered pages in memory. @default 500 */
+  cacheSize?: number;
+  /**
+   * The default theme: `github`, `base16:<id>`, `base24:<id>`, `omarchy:<id>`, `omarchy`
+   * (the current Omarchy theme, live), a scheme file or a URL. @default "github"
+   */
+  theme?: string;
+  /** The store that loads and caches the themes. Replace it to use another cache or no network. */
+  themeStore?: ThemeStore;
+  /** The `colors.toml` of the current Omarchy theme. @default ~/.local/state/omarchy/current/theme/colors.toml */
+  omarchyPath?: string;
+  /**
+   * Show an Edit button that opens the file in the editor of the user. Turn it off
+   * when other machines can reach the server. @default true
+   */
+  editor?: boolean;
+  /** Replaces the function that opens a file in the editor. */
+  openEditor?: OpenEditor;
+  /** Show a Share button that shares the pages at a public URL, through a Cloudflare tunnel. @default true */
+  share?: boolean;
+  /** Replaces the service that starts and stops the tunnel. */
+  shareService?: ShareService;
+}
+interface ComarkservHandler {
+  /** The absolute path of the served directory. */
+  readonly root: string;
+  /** The request handler. Give it to srvx, or to any server that uses web `Request` and `Response`. */
+  fetch: (request: Request) => Promise<Response>;
+  /** Loads the markdown renderer before the first request needs it. */
+  warmup: () => Promise<void>;
+  /** The tunnel for sharing, or `undefined` when sharing is off. */
+  readonly share: ShareService | undefined;
+  /** Stops the file watcher, the tunnel and the live reload streams. */
+  close: () => Promise<void>;
+}
+export declare function createHandler(options?: ComarkservOptions): ComarkservHandler;
+//#endregion
+//#region src/languages.d.ts
+type LanguageId = "bash" | "css" | "go" | "html" | "javascript" | "json" | "markdown" | "python" | "rust" | "sql" | "svelte" | "toml" | "tsx" | "typescript" | "yaml";
+/** A grammar: it returns the highlighted HTML of the code. */
+type Highlighter = (code: string) => string;
+export declare const supportedLanguages: readonly LanguageId[];
+/** Fence names that are not a canonical language id. */
+export declare const languageAliases: Readonly<Record<string, LanguageId>>;
+/** Returns the canonical language id for a fence name, or `undefined` for an unknown name. */
+export declare function resolveLanguage(name: string | undefined): LanguageId | undefined;
+/** Loads a grammar. Concurrent and later calls share one import. */
+export declare function loadLanguage(id: LanguageId): Promise<Highlighter>;
+//#endregion
+//#region src/highlight.d.ts
+interface CodeHighlighterOptions {
+  /** Show line numbers on all code blocks. A fence can override this with `:line-numbers` or `:no-line-numbers`. */
+  lineNumbers?: boolean;
+}
+interface CodeHighlighter {
+  /** Loads, in parallel, the grammars that the nodes use. */
+  preload: (nodes: Node[]) => Promise<void>;
+  /** Comark components that highlight code blocks and `code{:lang}` inline code. */
+  components: Record<string, NodeHandler | ConditionalNodeHandler>;
+}
+/** Returns the ids of the known grammars that code blocks and inline code in the nodes use. */
+export declare function collectLanguages(nodes: Node[]): Set<LanguageId>;
+export declare function createCodeHighlighter(options?: CodeHighlighterOptions): CodeHighlighter;
+//#endregion
+//#region src/search.d.ts
+interface SearchHeading {
+  id: string;
+  text: string;
+  depth: number;
+  /** The line of the heading in the source file, from 1. */
+  line: number;
+}
+interface SearchEntry {
+  /** The URL path of the page, from the site root. */
+  url: string;
+  title: string;
+  headings: SearchHeading[];
+}
+interface Outline {
+  title: string | undefined;
+  headings: SearchHeading[];
+}
+/** Reads the title and the headings of a markdown source, with no full parse. */
+export declare function extractOutline(source: string): Outline;
+interface SearchIndexOptions {
+  root: string;
+  dotfiles: boolean;
+  /** Changes the path of a file, from the root with a leading `/`, to the URL of its page. */
+  toUrl?: (path: string) => string;
+  /** More glob patterns to skip. */
+  ignore?: readonly string[];
+}
+interface SearchIndex {
+  /** Returns the entries. The first call reads all markdown files. Later calls read only the changed files. */
+  get: () => Promise<SearchEntry[]>;
+  /** Marks paths as changed. Use the URL paths from the file watcher. */
+  invalidate: (paths: string[]) => void;
+}
+export declare function createSearchIndex(options: SearchIndexOptions): SearchIndex;
+//#endregion
+//#region src/server.d.ts
+interface ServeOptions extends ComarkservOptions {
+  /** The port to listen on. @default 8642 */
+  port?: number;
+  /** The host to listen on. Use `0.0.0.0` to accept connections from the network. @default "localhost" */
+  host?: string;
+  /** Fail when the port is in use. When false, the server uses the next free port. @default false */
+  strictPort?: boolean;
+  /** Print a line for each request. @default false */
+  log?: boolean;
+}
+interface ComarkservServer {
+  /** The URL of the server, with a trailing slash. */
+  url: string;
+  port: number;
+  host: string;
+  handler: ComarkservHandler;
+  /** Stops the server, the file watcher and the open connections. */
+  close: () => Promise<void>;
+}
+export declare const DEFAULT_PORT = 8642;
+/** Returns the first free port from `start`. With `strict`, it rejects when `start` is in use. */
+export declare function findPort(start: number, host: string, strict: boolean): Promise<number>;
+/** Starts a comarkserv server with srvx. */
+export declare function startServer(options?: ServeOptions): Promise<ComarkservServer>;
+//#endregion
+export type { BuildOptions, BuildResult, CatalogEntry, CodeHighlighter, CodeHighlighterOptions, ComarkservHandler, ComarkservOptions, ComarkservServer, Highlighter, LanguageId, MarkdownFeatures, MarkdownRenderer, MarkdownRendererOptions, Palette, RenderOptions, RenderedMarkdown, SearchEntry, SearchHeading, SearchIndex, SearchIndexOptions, ServeOptions, ThemeSource, ThemeStore, ThemeStoreOptions, TocLink };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { C as parseTheme, n as THEME_SOURCES, o as createSearchIndex, r as createThemeStore, s as extractOutline, t as OMARCHY_CURRENT } from "./themes-mEufQ_3e.mjs";
+import { a as resolveLanguage, n as languageAliases, o as supportedLanguages, r as loadLanguage } from "./languages-C0kEygG_.mjs";
+import { n as collectLanguages, r as createCodeHighlighter, t as createMarkdownRenderer } from "./markdown-BqKed1Vq.mjs";
+import { i as toHtmlPath, n as build, r as staticLinkTransform } from "./build-Cv5aO0CB.mjs";
+import { a as createHandler, i as INTERNAL_PREFIX, n as findPort, r as startServer, t as DEFAULT_PORT } from "./server-Dkjk_D1Y.mjs";
+export { DEFAULT_PORT, INTERNAL_PREFIX, OMARCHY_CURRENT, THEME_SOURCES, build, collectLanguages, createCodeHighlighter, createHandler, createMarkdownRenderer, createSearchIndex, createThemeStore, extractOutline, findPort, languageAliases, loadLanguage, parseTheme, resolveLanguage, startServer, staticLinkTransform, supportedLanguages, toHtmlPath };

package/dist/languages-C0kEygG_.mjs

@@ -0,0 +1,119 @@
+import { escapeHtml } from "comark/utils";
+//#region src/nodes.ts
+function isElement(node) {
+	return Array.isArray(node) && typeof node[0] === "string";
+}
+/** Returns the child nodes of an element. */
+function childrenOf(node) {
+	return node.slice(2);
+}
+/** Returns an attribute value when it is a string that is not empty. */
+function stringAttr(attrs, name) {
+	const value = attrs[name];
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+/** Renders source text that failed to render, with the error message above it. */
+function errorBlock(source, error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return `<figure class="cms-code-error"><figcaption>${escapeHtml(message)}</figcaption><pre class="twinkleplop"><code>${escapeHtml(source)}</code></pre></figure>`;
+}
+//#endregion
+//#region src/languages.ts
+const loaders = {
+	bash: () => import("./dist-BnmL9jeq.mjs"),
+	css: () => import("./dist-Dr9uTCX7.mjs"),
+	go: () => import("./dist-Dxvc11TH.mjs"),
+	html: () => import("./dist-BK-bpLWg.mjs"),
+	javascript: () => import("./dist-B-IALNns.mjs"),
+	json: () => import("./dist-ByijHttv.mjs"),
+	markdown: () => import("./dist-CtONMLh4.mjs"),
+	python: () => import("./dist-BiVw4ojz.mjs"),
+	rust: () => import("./dist-fh99cWMN.mjs"),
+	sql: () => import("./dist-C2E4zSX1.mjs"),
+	svelte: () => import("./dist-V1rkISnf.mjs"),
+	toml: () => import("./dist-CsTXDvwi.mjs"),
+	tsx: () => import("./dist-BtedNLrc.mjs"),
+	typescript: () => import("./dist-GmbcGEAc.mjs"),
+	yaml: () => import("./dist-CXQ7eTfT.mjs")
+};
+const supportedLanguages = Object.keys(loaders);
+/** Fence names that are not a canonical language id. */
+const languageAliases = {
+	sh: "bash",
+	shell: "bash",
+	shellscript: "bash",
+	zsh: "bash",
+	console: "bash",
+	golang: "go",
+	htm: "html",
+	xhtml: "html",
+	vue: "html",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	jsonc: "json",
+	json5: "json",
+	jsonl: "json",
+	md: "markdown",
+	mdc: "markdown",
+	comark: "markdown",
+	py: "python",
+	python3: "python",
+	rs: "rust",
+	mysql: "sql",
+	postgres: "sql",
+	postgresql: "sql",
+	pgsql: "sql",
+	sqlite: "sql",
+	jsx: "tsx",
+	ts: "typescript",
+	mts: "typescript",
+	cts: "typescript",
+	yml: "yaml"
+};
+function isLanguageId(name) {
+	return Object.hasOwn(loaders, name);
+}
+/** Returns the canonical language id for a fence name, or `undefined` for an unknown name. */
+function resolveLanguage(name) {
+	const key = name?.trim().toLowerCase();
+	if (!key) return void 0;
+	if (isLanguageId(key)) return key;
+	return Object.hasOwn(languageAliases, key) ? languageAliases[key] : void 0;
+}
+const pending = /* @__PURE__ */ new Map();
+const loaded = /* @__PURE__ */ new Map();
+/** Loads a grammar. Concurrent and later calls share one import. */
+function loadLanguage(id) {
+	let promise = pending.get(id);
+	if (!promise) {
+		promise = loaders[id]().then((module) => {
+			const highlight = module.language();
+			loaded.set(id, highlight);
+			return highlight;
+		});
+		promise.catch(() => pending.delete(id));
+		pending.set(id, promise);
+	}
+	return promise;
+}
+const tokenizers = /* @__PURE__ */ new Map();
+/** Loads the tokenizer of a grammar, for output that is not HTML, such as a terminal. */
+function loadTokenizer(id) {
+	let promise = tokenizers.get(id);
+	if (!promise) {
+		promise = Promise.all([loaders[id](), import("./twinkleplop.production-Coccf2Q9.mjs")]).then(([module, core]) => {
+			const tokenize = module.tokenize();
+			return (code) => core.tokens_to_named(tokenize(code), code);
+		});
+		promise.catch(() => tokenizers.delete(id));
+		tokenizers.set(id, promise);
+	}
+	return promise;
+}
+/** Returns a grammar that is already loaded, without a load. */
+function getLoadedLanguage(id) {
+	return loaded.get(id);
+}
+//#endregion
+export { resolveLanguage as a, errorBlock as c, loadTokenizer as i, isElement as l, languageAliases as n, supportedLanguages as o, loadLanguage as r, childrenOf as s, getLoadedLanguage as t, stringAttr as u };