@markdstage/markdstage 0.1.1

package/shared/renderer/speaker-notes.mjs

@@ -0,0 +1,106 @@
+const FENCE_OPEN = /^([ \t]{0,3})(`{3,}|~{3,})[ \t]*([^\s`~]*)[ \t]*$/;
+const SLIDE_SIZE_DIRECTIVE = /^slide-size[ \t]*:/i;
+
+function normalizeText(text) {
+  return String(text ?? "").replace(/\r\n?/g, "\n");
+}
+
+function normalizeNote(text) {
+  const lines = normalizeText(text).split("\n");
+  while (lines.length && lines[0].trim() === "") lines.shift();
+  while (lines.length && lines.at(-1).trim() === "") lines.pop();
+  if (!lines.length) return "";
+
+  const indents = lines
+    .filter((line) => line.trim())
+    .map((line) => line.match(/^[ \t]*/)?.[0].length ?? 0);
+  const indent = indents.length ? Math.min(...indents) : 0;
+  return lines.map((line) => line.slice(indent)).join("\n").trim();
+}
+
+function closesFence(line, fence) {
+  const indentation = line.match(/^[ \t]*/)?.[0].length ?? 0;
+  if (indentation > 3) return false;
+  const trimmed = line.slice(indentation).trimEnd();
+  if (!trimmed || trimmed[0] !== fence[0]) return false;
+  let count = 0;
+  while (trimmed[count] === fence[0]) count += 1;
+  return count >= fence.length && trimmed.slice(count).trim() === "";
+}
+
+function parseSpeakerNotes(markdown) {
+  const notes = [];
+  const output = [];
+  let fence = "";
+  let comment = null;
+
+  for (const line of normalizeText(markdown).split("\n")) {
+    if (comment === null && fence) {
+      if (closesFence(line, fence)) fence = "";
+      output.push(line);
+      continue;
+    }
+
+    if (comment === null) {
+      const opening = FENCE_OPEN.exec(line);
+      if (opening) {
+        fence = opening[2];
+        output.push(line);
+        continue;
+      }
+    }
+
+    let visible = "";
+    let cursor = 0;
+    while (cursor <= line.length) {
+      if (comment === null) {
+        const start = line.indexOf("<!--", cursor);
+        if (start < 0) {
+          visible += line.slice(cursor);
+          break;
+        }
+        const before = visible + line.slice(cursor, start);
+        if (before.trim() || before.length > 3) {
+          visible += line.slice(cursor);
+          break;
+        }
+        visible = before;
+        comment = [];
+        cursor = start + 4;
+      }
+
+      const end = line.indexOf("-->", cursor);
+      if (end < 0) {
+        comment.push(line.slice(cursor), "\n");
+        break;
+      }
+
+      comment.push(line.slice(cursor, end));
+      const note = normalizeNote(comment.join(""));
+      if (note && !SLIDE_SIZE_DIRECTIVE.test(note)) notes.push(note);
+      comment = null;
+      cursor = end + 3;
+    }
+    output.push(visible);
+  }
+
+  return {
+    markdown: output.join("\n"),
+    notes: notes.join("\n\n"),
+  };
+}
+
+/**
+ * Extract Slidev/Marp-style speaker notes from top-level HTML comments.
+ *
+ * Comments inside fenced code examples are ignored. The renderer's
+ * `slide-size:` comment is a display directive rather than a speaker note.
+ */
+export function extractSpeakerNotes(markdown) {
+  return parseSpeakerNotes(markdown).notes;
+}
+
+/** Remove speaker-note comments while preserving comments in fenced examples. */
+export function stripSpeakerNotes(markdown) {
+  return parseSpeakerNotes(markdown).markdown;
+}

package/shared/renderer/theme.mjs

@@ -0,0 +1,205 @@
+export const BUILTIN_THEMES = new Set(["dark", "light", "microsoft"]);
+export const THEMES = new Set([...BUILTIN_THEMES, "custom"]);
+export const DEFAULT_THEME = "dark";
+export const THEME_METADATA_VERSION = 1;
+export const THEME_ASSET_MAX_BYTES = 2 * 1024 * 1024;
+
+const THEME_ASSET_SEGMENT = "[A-Za-z0-9][A-Za-z0-9_-]*(?:\\.[A-Za-z0-9_-]+)*";
+const THEME_ASSET_PATTERN = new RegExp(
+  `^assets/(?:${THEME_ASSET_SEGMENT}/)*${THEME_ASSET_SEGMENT}\\.(?:svg|png|webp|jpg|jpeg)$`,
+  "i",
+);
+
+export function normalizeTheme(value) {
+  const theme = typeof value === "string" ? value.trim().toLowerCase() : "";
+  return THEMES.has(theme) ? theme : DEFAULT_THEME;
+}
+
+export function parseFrontMatter(markdown) {
+  const meta = {};
+  const text = String(markdown ?? "").replace(/\r\n?/g, "\n");
+  const trimmed = text.replace(/^[\n \t\uFEFF]+/, "");
+  if (!trimmed.startsWith("---\n") && trimmed !== "---") return meta;
+  const lines = trimmed.split("\n");
+  for (let index = 1; index < lines.length; index += 1) {
+    if (lines[index].trim() === "---") break;
+    const separator = lines[index].indexOf(":");
+    if (separator <= 0) continue;
+    const key = lines[index].slice(0, separator).trim();
+    const value = lines[index]
+      .slice(separator + 1)
+      .trim()
+      .replace(/^["']+|["']+$/g, "");
+    if (key) meta[key] = value;
+  }
+  return meta;
+}
+
+export function resolveFrontMatterTheme(slides) {
+  for (const slide of Array.isArray(slides) ? slides : []) {
+    const meta = parseFrontMatter(slide);
+    if (typeof meta.theme === "string" && meta.theme.trim()) {
+      return {
+        theme: normalizeTheme(meta.theme),
+        themeFile: typeof meta["theme-file"] === "string" ? meta["theme-file"].trim() : "",
+      };
+    }
+    if (typeof meta["theme-file"] === "string" && meta["theme-file"].trim()) {
+      return { theme: "custom", themeFile: meta["theme-file"].trim() };
+    }
+  }
+  return { theme: DEFAULT_THEME, themeFile: "" };
+}
+
+function stripCssComments(css) {
+  return String(css ?? "").replace(/\/\*[\s\S]*?\*\//g, "");
+}
+
+export function parseThemeVariables(css) {
+  let body = stripCssComments(css).trim();
+  if (body.startsWith(":root")) {
+    const match = body.match(/^:root\s*\{([\s\S]*)\}\s*$/);
+    if (!match) throw new Error("custom theme CSS must contain only a complete :root block");
+    body = match[1].trim();
+  }
+  const variables = {};
+  for (const declaration of body.split(";")) {
+    const item = declaration.trim();
+    if (!item) continue;
+    const match = item.match(/^(--[A-Za-z0-9_-]+)\s*:\s*(.+)$/s);
+    if (!match) {
+      throw new Error("custom theme CSS may contain only --custom-property declarations");
+    }
+    const value = match[2].trim();
+    if (
+      !value ||
+      /<\/?style\b|@import\b|expression\s*\(|javascript\s*:|url\s*\(/i.test(value)
+    ) {
+      throw new Error(`custom theme CSS contains an unsafe value for ${match[1]}`);
+    }
+    variables[match[1]] = value;
+  }
+  if (Object.keys(variables).length === 0) {
+    throw new Error("custom theme CSS must define at least one custom property");
+  }
+  return variables;
+}
+
+export function serializeThemeVariables(variables) {
+  return Object.entries(variables)
+    .map(([name, value]) => `${name}:${value};`)
+    .join("");
+}
+
+function assertPlainObject(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  return value;
+}
+
+function assertOnlyKeys(value, allowed, path) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) throw new Error(`${path}.${key} is not supported`);
+  }
+}
+
+function parseImage(value, path, { altRequired = false } = {}) {
+  const image = assertPlainObject(value, path);
+  assertOnlyKeys(image, new Set(["image", "alt"]), path);
+  if (
+    typeof image.image !== "string" ||
+    image.image.length > 200 ||
+    !THEME_ASSET_PATTERN.test(image.image)
+  ) {
+    throw new Error(
+      `${path}.image must be a safe path under the theme assets/ folder using svg, png, webp, jpg, or jpeg`,
+    );
+  }
+  const alt = typeof image.alt === "string" ? image.alt.trim() : "";
+  if (altRequired && !alt) throw new Error(`${path}.alt must be a non-empty string`);
+  return { image: image.image, ...(alt ? { alt } : {}) };
+}
+
+export function parseThemeMetadata(value) {
+  const metadata = typeof value === "string" ? JSON.parse(value) : value;
+  const root = assertPlainObject(metadata, "theme metadata");
+  assertOnlyKeys(root, new Set(["$schema", "version", "cover", "backcover"]), "theme metadata");
+  if (root.version !== THEME_METADATA_VERSION) {
+    throw new Error(`theme metadata version must be ${THEME_METADATA_VERSION}`);
+  }
+
+  const result = { version: THEME_METADATA_VERSION };
+  if (root.cover !== undefined) {
+    const cover = assertPlainObject(root.cover, "cover");
+    assertOnlyKeys(cover, new Set(["background", "logo"]), "cover");
+    result.cover = {};
+    if (cover.background !== undefined) {
+      result.cover.background = parseImage(cover.background, "cover.background");
+    }
+    if (cover.logo !== undefined) {
+      result.cover.logo = parseImage(cover.logo, "cover.logo", { altRequired: true });
+    }
+    if (Object.keys(result.cover).length === 0) delete result.cover;
+  }
+
+  if (root.backcover !== undefined) {
+    const backcover = assertPlainObject(root.backcover, "backcover");
+    assertOnlyKeys(backcover, new Set(["logo", "copyright"]), "backcover");
+    result.backcover = {};
+    if (backcover.logo !== undefined) {
+      result.backcover.logo = parseImage(backcover.logo, "backcover.logo", {
+        altRequired: true,
+      });
+    }
+    if (backcover.copyright !== undefined) {
+      if (typeof backcover.copyright !== "string") {
+        throw new Error("backcover.copyright must be a string");
+      }
+      result.backcover.copyright = backcover.copyright;
+    }
+    if (Object.keys(result.backcover).length === 0) delete result.backcover;
+  }
+  return result;
+}
+
+export function themeMetadataAssetPaths(metadata) {
+  const paths = [];
+  const add = (entry) => {
+    if (entry?.image && !paths.includes(entry.image)) paths.push(entry.image);
+  };
+  add(metadata?.cover?.background);
+  add(metadata?.cover?.logo);
+  add(metadata?.backcover?.logo);
+  return paths;
+}
+
+export function mapThemeMetadataAssets(metadata, mapAsset) {
+  const mapImage = (entry) =>
+    entry ? { ...entry, image: mapAsset(entry.image) } : undefined;
+  return {
+    version: metadata.version,
+    ...(metadata.cover
+      ? {
+          cover: {
+            ...(metadata.cover.background
+              ? { background: mapImage(metadata.cover.background) }
+              : {}),
+            ...(metadata.cover.logo ? { logo: mapImage(metadata.cover.logo) } : {}),
+          },
+        }
+      : {}),
+    ...(metadata.backcover
+      ? {
+          backcover: {
+            ...(metadata.backcover.logo
+              ? { logo: mapImage(metadata.backcover.logo) }
+              : {}),
+            ...("copyright" in metadata.backcover
+              ? { copyright: metadata.backcover.copyright }
+              : {}),
+          },
+        }
+      : {}),
+  };
+}