@raspberrypifoundation/rpf-markdown-core 0.1.0

package/dist/index.js

@@ -0,0 +1,1181 @@
+// src/index.ts
+import { marked as marked2 } from "marked";
+import { gfmHeadingId } from "marked-gfm-heading-id";
+
+// src/block_renderers.ts
+import { marked } from "marked";
+
+// src/shared_utils.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/block_renderers.ts
+var CALLOUT_HEADINGS = {
+  debug: "Debugging",
+  tip: "Tip"
+};
+function renderMarkdown(input) {
+  return marked.parse(input);
+}
+function renderAccordion({
+  modifier,
+  heading,
+  body,
+  contentClass = "c-project-panel__content u-hidden",
+  bodyIsHtml = false
+}) {
+  const escapedHeading = escapeHtml(heading);
+  const renderedBody = bodyIsHtml ? normalizePreservedHtml(body) : renderMarkdown(body);
+  const normalizedBody = normalizePanelHtml(renderedBody);
+  return [
+    `<div class="c-project-panel c-project-panel--${modifier}">`,
+    '  <h3 class="c-project-panel__heading js-project-panel__toggle">',
+    `    ${escapedHeading}`,
+    "  </h3>",
+    "",
+    `  <div class="${contentClass}">`,
+    `    ${normalizedBody.trimEnd()}`,
+    "",
+    "  </div>",
+    "</div>"
+  ].join("\n");
+}
+function renderTaskBlock(body) {
+  const renderedBody = renderMarkdown(body);
+  return [
+    '<div class="c-project-task">',
+    '  <input class="c-project-task__checkbox" type="checkbox" aria-label="Mark this task as complete" />',
+    '  <div class="c-project-task__body">',
+    `    ${renderedBody.trimEnd()}`,
+    "",
+    "  </div>",
+    "</div>"
+  ].join("\n");
+}
+function renderHintsPanel(bodies) {
+  const slides = bodies.map(
+    (body) => [
+      '<div class="c-project-panel__swiper-slide">',
+      `  ${renderMarkdown(body).trimEnd()}`,
+      "",
+      "</div>"
+    ].join("\n")
+  ).join("\n\n");
+  return [
+    '<div class="c-project-panel c-project-panel--hints">',
+    '  <h3 class="c-project-panel__heading js-project-panel__toggle">',
+    "    I need a hint",
+    "  </h3>",
+    "",
+    '  <div class="c-project-panel__content js-project-panel--initialise-swiper u-hidden">',
+    '    <div class="c-project-panel__swiper">',
+    '      <div class="c-project-panel__swiper-wrapper">',
+    `        ${slides}`,
+    "      </div>",
+    "",
+    '      <div class="c-project-panel__swiper-pagination">',
+    '        <span class="c-project-panel__swiper-bullet"></span>',
+    '        <span class="c-project-panel__swiper-bullet"></span>',
+    '        <span class="c-project-panel__swiper-bullet"></span>',
+    "      </div>",
+    "",
+    '      <div class="c-project-panel__swiper-button c-project-panel__swiper-button--next"></div>',
+    '      <div class="c-project-panel__swiper-button c-project-panel__swiper-button--prev"></div>',
+    "    </div>",
+    "  </div>",
+    "</div>"
+  ].join("\n");
+}
+function renderHintSlide(body) {
+  return [
+    '<div class="c-project-panel__swiper-slide">',
+    `  ${renderMarkdown(body).trimEnd()}`,
+    "",
+    "</div>"
+  ].join("\n");
+}
+function renderCalloutBlock(type, body) {
+  const heading = CALLOUT_HEADINGS[type] ?? type;
+  return renderExistingCalloutBlock(type, `### ${heading}
+
+${body}`);
+}
+function renderExistingCalloutBlock(type, body) {
+  return [
+    `<div class="c-project-callout c-project-callout--${type}">`,
+    "",
+    renderMarkdown(body).trimEnd(),
+    "",
+    "</div>"
+  ].join("\n");
+}
+function renderSaveBlock() {
+  return [
+    '<div class="c-project-panel c-project-panel--save">',
+    '  <h3 class="c-project-panel__heading">',
+    "    Save your project",
+    "  </h3>",
+    "</div>"
+  ].join("\n");
+}
+function renderNoPrintBlock(body) {
+  return `<div class="u-no-print">
+
+  ${renderMarkdown(body).trimEnd()}
+</div>`;
+}
+function renderPrintOnlyBlock(body) {
+  return `<div class="u-print-only">
+
+  ${renderMarkdown(body).trimEnd()}
+</div>`;
+}
+function renderChallengeBlock(body, title = "") {
+  const content = title ? `## ${title}
+
+${body}` : body;
+  return renderMarkdown(content).trimEnd();
+}
+function renderInfoBlock(body) {
+  return [
+    '<div style="border-left: solid; border-width:10px; border-color: #0faeb0; background-color: aliceblue; padding: 10px;">',
+    renderMarkdown(body).trimEnd(),
+    "</div>"
+  ].join("\n");
+}
+function normalizePreservedHtml(body) {
+  return body.trim();
+}
+function normalizePanelHtml(body) {
+  return body.replace(
+    /<div class="c-code-filename">\s*([^<\n][\s\S]*?)\s*<\/div>/g,
+    (_match, filename) => `<div class="c-code-filename">
+  <p>${filename.trim()}</p>
+</div>`
+  );
+}
+
+// src/regex_constants.ts
+var SCRATCHBLOCKS_FENCED_BLOCK_REGEX = /^[ \t]*(`{3,}|~{3,})(blocks[23]?)[^\r\n]*\r?\n([\s\S]*?)\r?\n?[ \t]*\1[ \t]*$/;
+var RPF_CODE_OPEN_REGEX = /^---\s+code\s+---$/;
+var RPF_CODE_CLOSE_REGEX = /^---\s+\/code\s+---$/;
+var RPF_CODE_FRONTMATTER_WRAPPED_REGEX = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/;
+var RPF_CODE_FRONTMATTER_BARE_REGEX = /^((?:[^\n]+\n)*?)(\n[\s\S]*)$/;
+var RPF_CODE_KNOWN_KEYS_REGEX = /^(language|line_numbers|line_number_start|line_numbers_start|line_highlights)\s*:/;
+var CALLOUT_OPEN_REGEX = /^<div\s+class="(c-project-callout\s+c-project-callout--([a-z0-9-]+))">/;
+var TASK_OPEN_REGEX = /^---\s+task\s+---$/;
+var TASK_CLOSE_REGEX = /^---\s+\/task\s+---$/;
+var OUTPUT_OPEN_REGEX = /^<div\s+class="c-project-output">\s*$/;
+var MARKER_LINE_REGEX = /^\[!(ACCORDION|CHALLENGE|DEBUG|HINT|NOPRINT|PRINTONLY|SAVE|TASK|TIP|INFO)\](?:[ \t]+([^\n]*))?[ \t]*$/;
+
+// src/scratchblocks.ts
+import initScratchblocks from "scratchblocks/index.js";
+var SCRATCHBLOCKS_PARSE_ERROR = "Input does not appear to be a valid scratchblocks fenced code block. Expected opening fence with info string 'blocks', 'blocks2', or 'blocks3'.";
+var SCRATCHBLOCKS_NO_RUNTIME_ERROR = "Scratchblocks rendering requires a browser window or a Node runtime where happy-dom can be required.";
+var rendererCache;
+var warnedAboutHappyDomLoadFailure = false;
+function mapFenceInfoToStyle(info) {
+  const tag = info.trim().toLowerCase();
+  if (tag === "blocks2") return "scratch2";
+  return "scratch3";
+}
+function isCompatibleScratchblocksWindow(value) {
+  if (value == null || typeof value !== "object") {
+    return false;
+  }
+  const maybeWindow = value;
+  return maybeWindow.document != null && maybeWindow.DOMParser != null && maybeWindow.HTMLCanvasElement != null;
+}
+function getGlobalBrowserWindow() {
+  const maybeWindow = globalThis.window;
+  return isCompatibleScratchblocksWindow(maybeWindow) ? maybeWindow : void 0;
+}
+function resolveNodeRequire() {
+  const nodeProcess = globalThis.process;
+  const moduleBuiltin = nodeProcess?.getBuiltinModule?.("module");
+  const createRequire = moduleBuiltin?.createRequire;
+  if (typeof createRequire === "function") {
+    return createRequire(import.meta.url);
+  }
+  try {
+    const maybeRequire = (0, eval)("require");
+    if (typeof maybeRequire === "function") {
+      return maybeRequire;
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function createNodeRuntimeWindow() {
+  const requireFn = resolveNodeRequire();
+  if (requireFn == null) {
+    return void 0;
+  }
+  try {
+    const happyDomModule = requireFn("happy-dom");
+    const HappyDomWindow = happyDomModule.Window;
+    if (typeof HappyDomWindow !== "function") {
+      return void 0;
+    }
+    return new HappyDomWindow();
+  } catch (error) {
+    if (!warnedAboutHappyDomLoadFailure) {
+      warnedAboutHappyDomLoadFailure = true;
+      console.warn(
+        "Unable to load happy-dom for server-side scratchblocks rendering:",
+        error
+      );
+    }
+    return void 0;
+  }
+}
+function ensureXmlHasCreateCDATASection(xml) {
+  if (typeof xml.createCDATASection !== "function") {
+    xml.createCDATASection = (data) => xml.createTextNode(data);
+  }
+}
+function doesWindowNeedCDataSectionPolyfill(window) {
+  try {
+    const parserCtor = window.DOMParser;
+    const parser = new parserCtor();
+    const xml = parser.parseFromString("<xml/>", "application/xml");
+    return typeof xml.createCDATASection !== "function";
+  } catch {
+    return true;
+  }
+}
+function applyCDataSectionPolyfill(window) {
+  if (!doesWindowNeedCDataSectionPolyfill(window)) {
+    return;
+  }
+  const parserPrototype = window.DOMParser.prototype;
+  if (typeof parserPrototype.parseFromString === "function") {
+    try {
+      const originalParse = parserPrototype.parseFromString.bind(parserPrototype);
+      parserPrototype.parseFromString = (markup, mimeType) => {
+        const xml = originalParse(markup, mimeType);
+        ensureXmlHasCreateCDATASection(xml);
+        return xml;
+      };
+    } catch {
+    }
+  }
+  const createDocument = window.document.implementation?.createDocument;
+  if (typeof createDocument === "function") {
+    try {
+      const implementation = window.document.implementation;
+      if (implementation == null) {
+        return;
+      }
+      const originalCreateDocument = createDocument.bind(implementation);
+      implementation.createDocument = (namespace, qualifiedNameStr, documentType) => {
+        const xml = originalCreateDocument(
+          namespace,
+          qualifiedNameStr,
+          documentType
+        );
+        ensureXmlHasCreateCDATASection(xml);
+        return xml;
+      };
+    } catch {
+    }
+  }
+}
+function doesWindowNeedCanvasContextPolyfill(window) {
+  try {
+    const maybeCanvas = window.document.createElement?.("canvas");
+    return maybeCanvas == null || typeof maybeCanvas.getContext !== "function" || maybeCanvas.getContext("2d") == null;
+  } catch {
+    return true;
+  }
+}
+function applyCanvasContextPolyfill(window) {
+  if (!doesWindowNeedCanvasContextPolyfill(window)) {
+    return;
+  }
+  const canvasPrototype = window.HTMLCanvasElement.prototype;
+  if (canvasPrototype == null || typeof canvasPrototype.getContext !== "function") {
+    return;
+  }
+  const originalGetContext = canvasPrototype.getContext;
+  try {
+    canvasPrototype.getContext = function getContext(contextId) {
+      if (contextId !== "2d") {
+        return originalGetContext.call(this, contextId);
+      }
+      const context2d = originalGetContext.call(this, contextId);
+      if (context2d != null) {
+        return context2d;
+      }
+      return {
+        font: "",
+        measureText(value) {
+          return { width: value.length * 7 };
+        },
+        save() {
+        },
+        scale() {
+        },
+        drawImage() {
+        },
+        restore() {
+        }
+      };
+    };
+  } catch {
+  }
+}
+function extractInjectedScratchblocksStyles(headBefore, headAfter) {
+  if (headAfter.startsWith(headBefore)) {
+    const injected = headAfter.slice(headBefore.length).trim();
+    if (injected !== "") {
+      return injected;
+    }
+  }
+  const styleTags = headAfter.match(/<style[^>]*>[\s\S]*?<\/style>/g) ?? [];
+  const scratchblocksStyleTags = styleTags.filter(
+    (tag) => tag.includes(".sb2-") || tag.includes(".sb3-")
+  );
+  return scratchblocksStyleTags.join("");
+}
+function embedStylesIntoSvg(svg, stylesHtml) {
+  const styles = stylesHtml.trim();
+  if (styles === "") {
+    return svg;
+  }
+  const openTagEnd = svg.indexOf(">");
+  if (openTagEnd === -1) {
+    return `${styles}${svg}`;
+  }
+  return `${svg.slice(0, openTagEnd + 1)}${styles}${svg.slice(openTagEnd + 1)}`;
+}
+function createScratchblocksRenderer() {
+  const browserWindow = getGlobalBrowserWindow();
+  const renderWindow = browserWindow ?? createNodeRuntimeWindow();
+  if (renderWindow == null) {
+    throw new Error(SCRATCHBLOCKS_NO_RUNTIME_ERROR);
+  }
+  applyCDataSectionPolyfill(renderWindow);
+  applyCanvasContextPolyfill(renderWindow);
+  const headBefore = renderWindow.document.head.innerHTML;
+  const api = initScratchblocks(renderWindow);
+  api.appendStyles();
+  const headAfter = renderWindow.document.head.innerHTML;
+  const stylesHtml = extractInjectedScratchblocksStyles(headBefore, headAfter);
+  return { api, stylesHtml };
+}
+function getOrCreateScratchblocksRenderer() {
+  if (rendererCache === void 0) {
+    rendererCache = createScratchblocksRenderer();
+  }
+  return rendererCache;
+}
+function parseScratchblocksBlock(fencedBlock) {
+  const fenceMatch = fencedBlock.match(SCRATCHBLOCKS_FENCED_BLOCK_REGEX);
+  if (!fenceMatch) {
+    throw new Error(SCRATCHBLOCKS_PARSE_ERROR);
+  }
+  const infoString = fenceMatch[2] ?? "blocks3";
+  const code = fenceMatch[3] ?? "";
+  const style = mapFenceInfoToStyle(infoString);
+  try {
+    const renderer = getOrCreateScratchblocksRenderer();
+    const doc = renderer.api.parse(code, { languages: ["en"] });
+    const svgElement = renderer.api.render(doc, {
+      style,
+      languages: ["en"],
+      scale: 1
+    });
+    const svg = embedStylesIntoSvg(svgElement.outerHTML, renderer.stylesHtml);
+    const html = `<div class="c-project-scratchblocks" data-style="${style}">${svg}</div>`;
+    return { html, style, svg };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to render scratchblocks SVG: ${message}`);
+  }
+}
+
+// src/codeblocks.ts
+function renderStandardCodeBlock(text, language) {
+  const codeClass = language ? ` class="language-${language}"` : "";
+  return `<pre><code${codeClass}>${escapeCode(text)}
+</code></pre>`;
+}
+function hasProjectCodeOptions(info) {
+  return /\b(?:filename|line_numbers|line_numbers_start|line_number_start|line_highlights)=/.test(
+    info
+  );
+}
+function extractFenceBody(rawFence, fallback) {
+  if (rawFence === void 0) return fallback;
+  return parseFencedBlock(rawFence)?.code ?? fallback;
+}
+function extractListItemFenceBlocks(rawListItem) {
+  const lines = rawListItem.replace(/\r\n/g, "\n").split("\n");
+  const blocks = [];
+  for (let index = 0; index < lines.length; index++) {
+    const openingLine = lines[index] ?? "";
+    const openingMatch = openingLine.match(/^[ \t]*(`{3,}|~{3,})([^\n]*)$/);
+    if (!openingMatch) continue;
+    const fence = openingMatch[1] ?? "";
+    const blockLines = [openingLine];
+    const closingRegex = new RegExp(`^[ \\t]*${fence}[ \\t]*$`);
+    for (index++; index < lines.length; index++) {
+      const line = lines[index] ?? "";
+      blockLines.push(line);
+      if (closingRegex.test(line)) {
+        blocks.push(normalizeListItemFence(blockLines.join("\n")));
+        break;
+      }
+    }
+  }
+  return blocks;
+}
+function renderMarkedCodeToken(token, rawFenceOverride) {
+  const info = (token.info ?? token.lang ?? "").trim();
+  const tag = (info.split(/\s+/)[0] ?? "").toLowerCase();
+  const rawFence = rawFenceOverride ?? (typeof token.raw === "string" && /^[ \t]*(?:`{3,}|~{3,})/.test(token.raw) ? token.raw : void 0);
+  const codeText = extractFenceBody(rawFence, token.text);
+  const fenceBlock = rawFence ?? `\`\`\`${info}
+${token.text}
+\`\`\``;
+  if (["blocks", "blocks2", "blocks3"].includes(tag)) {
+    try {
+      return `${parseScratchblocksBlock(fenceBlock).html}
+`;
+    } catch {
+      return `${renderStandardCodeBlock(codeText, "")}
+`;
+    }
+  }
+  if (hasProjectCodeOptions(info)) {
+    try {
+      return `${highlightCodeBlock(fenceBlock).html}
+`;
+    } catch {
+      return `${renderStandardCodeBlock(codeText, tag)}
+`;
+    }
+  }
+  return `${renderStandardCodeBlock(codeText, tag)}
+`;
+}
+function applyInlineCodeClasses(html) {
+  return html.replace(
+    /<code>([\s\S]*?)<\/code>\{:\s*class=["”]([^"”]+)["”]\}/g,
+    (_match, codeContent, className) => `<code class="${escapeHtml(className)}">${codeContent}</code>`
+  );
+}
+function escapeCode(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function createInvalidBlockError(blockType, expected) {
+  if (expected === void 0) {
+    return new Error(`Input does not appear to be a valid ${blockType}.`);
+  }
+  return new Error(
+    `Input does not appear to be a valid ${blockType}. Expected ${expected}.`
+  );
+}
+function applyCodeBlockOption(key, value, options, allowSingularLineNumberStart) {
+  const normalizedValue = stripWrappingQuotes(value);
+  switch (key) {
+    case "filename":
+      options.filename = normalizedValue;
+      break;
+    case "line_numbers":
+      options.line_numbers = normalizedValue === "true";
+      break;
+    case "line_numbers_start":
+      options.line_numbers_start = parseInt(normalizedValue, 10);
+      break;
+    case "line_number_start":
+      if (allowSingularLineNumberStart) {
+        options.line_numbers_start = parseInt(normalizedValue, 10);
+      }
+      break;
+    case "line_highlights":
+      options.line_highlights = normalizeLineHighlights(normalizedValue);
+      break;
+  }
+}
+function stripWrappingQuotes(value) {
+  const trimmed = value.trim();
+  const first = trimmed[0];
+  const last = trimmed.at(-1);
+  if (first === '"' && last === '"' || first === "'" && last === "'") {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function normalizeLineHighlights(value) {
+  return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0).join(", ");
+}
+function parseFenceInfo(infoString) {
+  const parts = infoString.trim().match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+  const language = parts[0] ?? "";
+  const options = {};
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === void 0) continue;
+    const eqIdx = part.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = part.slice(0, eqIdx);
+    const value = part.slice(eqIdx + 1);
+    applyCodeBlockOption(key, value, options, true);
+  }
+  return { language, options };
+}
+function highlightCodeBlock(fencedBlock) {
+  const fence = parseFencedBlock(fencedBlock);
+  if (fence === void 0) {
+    throw createInvalidBlockError("fenced code block");
+  }
+  const infoString = fence.infoString.trim();
+  const code = fence.code;
+  const { language, options } = parseFenceInfo(infoString);
+  const html = buildCodeHtml(code, language, options);
+  return { html, language, options };
+}
+function parseFencedBlock(fencedBlock) {
+  const normalized = fencedBlock.replace(/\r\n/g, "\n").trimEnd();
+  const lines = normalized.split("\n");
+  const openingLine = lines[0] ?? "";
+  const closingLine = lines.at(-1) ?? "";
+  const openingMatch = openingLine.match(/^[ \t]*(`{3,}|~{3,})([^\n]*)$/);
+  if (!openingMatch) return void 0;
+  const fence = openingMatch[1] ?? "";
+  const closingRegex = new RegExp(`^[ \\t]*${fence}[ \\t]*$`);
+  if (!closingRegex.test(closingLine)) return void 0;
+  return {
+    infoString: openingMatch[2] ?? "",
+    code: lines.slice(1, -1).join("\n")
+  };
+}
+function normalizeListItemFence(rawFence) {
+  const normalized = rawFence.replace(/\r\n/g, "\n").trimEnd();
+  const lines = normalized.split("\n");
+  const openingIndent = lines[0]?.match(/^[ \t]*/)?.[0] ?? "";
+  const openingLine = lines[0]?.trimStart() ?? "";
+  const closingLine = lines.at(-1)?.trimStart() ?? "";
+  const codeLines = lines.slice(1, -1).map((line) => {
+    const stripped = line.startsWith(openingIndent) ? line.slice(openingIndent.length) : line;
+    return stripped.length > 0 ? ` ${stripped}` : stripped;
+  });
+  return [openingLine, ...codeLines, closingLine].join("\n");
+}
+function buildCodeHtml(code, language, options) {
+  const highlightedCode = escapeProjectCode(code);
+  const preClasses = [];
+  if (options.line_numbers === true) preClasses.push("line-numbers");
+  if (options.line_numbers === false) preClasses.push("no-line-numbers");
+  const preClass = preClasses.length > 0 ? ` class="${preClasses.join(" ")}"` : "";
+  const dataStart = options.line_numbers_start !== void 0 ? ` data-start="${options.line_numbers_start}"` : "";
+  const dataLine = options.line_highlights !== void 0 ? ` data-line="${options.line_highlights}"` : "";
+  const dataLineOffset = options.line_numbers_start !== void 0 && options.line_highlights !== void 0 ? ` data-line-offset="${options.line_numbers_start}"` : "";
+  const codeClass = language ? ` class="language-${language}"` : "";
+  const codeOutput = `<pre dir="ltr"${preClass}${dataStart}${dataLineOffset}${dataLine}><code${codeClass} dir="ltr">
+${highlightedCode}
+</code></pre>`;
+  return options.filename ? `<div class="c-code-filename">
+  ${escapeHtml(options.filename)}
+</div>
+${codeOutput}` : codeOutput;
+}
+function escapeProjectCode(code) {
+  return code.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function parseRpfCodeFrontmatter(frontmatter) {
+  let language = "";
+  const options = {};
+  for (const line of frontmatter.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "language") {
+      if (language === "") language = value;
+    } else {
+      applyCodeBlockOption(key, value, options, true);
+    }
+  }
+  return { language, options };
+}
+function parseRpfCodeBlock(input) {
+  const trimmed = input.trim();
+  const lines = trimmed.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  if (!RPF_CODE_OPEN_REGEX.test(firstLine)) {
+    throw createInvalidBlockError("RPF code block", "opening --- code ---");
+  }
+  const lastLine = lines.at(-1)?.trim() ?? "";
+  if (!RPF_CODE_CLOSE_REGEX.test(lastLine)) {
+    throw createInvalidBlockError("RPF code block", "closing --- /code ---");
+  }
+  const inner = lines.slice(1, -1).join("\n").trimStart();
+  let language = "";
+  let options = {};
+  let codeBody = inner;
+  const fmWrappedMatch = inner.match(RPF_CODE_FRONTMATTER_WRAPPED_REGEX);
+  const fmBareMatch = !fmWrappedMatch && inner.match(RPF_CODE_FRONTMATTER_BARE_REGEX);
+  if (fmWrappedMatch) {
+    ({ language, options } = parseRpfCodeFrontmatter(fmWrappedMatch[1] ?? ""));
+    codeBody = fmWrappedMatch[2] ?? "";
+  } else if (fmBareMatch && fmBareMatch[1] && fmBareMatch[1].split("\n").every((l) => l === "" || RPF_CODE_KNOWN_KEYS_REGEX.test(l))) {
+    ({ language, options } = parseRpfCodeFrontmatter(fmBareMatch[1]));
+    codeBody = fmBareMatch[2] ?? "";
+  }
+  const code = codeBody.replace(/^\n+/, "").replace(/\n+$/, "");
+  const html = buildCodeHtml(code, language, options);
+  return { html, language, options };
+}
+
+// src/marked-smartypants-lite.ts
+function smartenInlineText(value) {
+  return value.replace(/---/g, "\u2014").replace(/--/g, "\u2013").replace(/(^|[-\u2014/(\[{"\s])'/g, "$1\u2018").replace(/'/g, "\u2019").replace(/(^|[-\u2014/(\[{\u2018\s])"/g, "$1\u201C").replace(/"/g, "\u201D").replace(/\.{3}/g, "\u2026");
+}
+function markedSmartypantsLite() {
+  return {
+    tokenizer: {
+      inlineText(src) {
+        const cap = this.rules.inline.text.exec(src);
+        if (!cap) {
+          return void 0;
+        }
+        return {
+          type: "text",
+          raw: cap[0],
+          text: smartenInlineText(cap[0])
+        };
+      }
+    }
+  };
+}
+
+// src/rfm.ts
+function parseMarkerLine(line) {
+  const match = line.trim().match(MARKER_LINE_REGEX);
+  if (!match) {
+    throw new Error(
+      "Input does not appear to be a valid RFM block. Expected opening marker line such as [!TASK]."
+    );
+  }
+  return {
+    type: match[1],
+    title: (match[2] ?? "").trim()
+  };
+}
+function removeOneQuoteLevel(input) {
+  return input.split("\n").map((line) => line.replace(/^[ \t]*>[ \t]?/, "")).join("\n").trim();
+}
+function parseBlock(input) {
+  const inner = removeOneQuoteLevel(input);
+  const lines = inner.split("\n");
+  const marker = parseMarkerLine(lines[0] ?? "");
+  const body = lines.slice(1).join("\n").replace(/^\s*\n/, "").trim();
+  return { ...marker, body };
+}
+function matchRfmBlock(src) {
+  const firstLine = src.split("\n", 1)[0] ?? "";
+  const openingMarker = getRfmMarker(firstLine);
+  if (openingMarker === void 0) return void 0;
+  const lines = src.split("\n");
+  const collected = [firstLine];
+  for (let index = 1; index < lines.length; index++) {
+    const line = lines[index] ?? "";
+    const marker = getRfmMarker(line);
+    if (marker !== void 0 && marker.depth <= openingMarker.depth && !shouldGroupRfmMarkers(openingMarker, marker)) {
+      break;
+    }
+    if (line.trim() === "") {
+      const nextContentLine = lines.slice(index + 1).find((candidate) => candidate.trim() !== "");
+      const nextMarker = nextContentLine === void 0 ? void 0 : getRfmMarker(nextContentLine);
+      if (nextMarker !== void 0 && nextMarker.depth <= openingMarker.depth && !shouldGroupRfmMarkers(openingMarker, nextMarker)) {
+        break;
+      }
+      collected.push(line);
+      continue;
+    }
+    if (/^[ \t]*>/.test(line)) {
+      collected.push(line);
+      continue;
+    }
+    break;
+  }
+  while (collected.at(-1)?.trim() === "") collected.pop();
+  return collected.length > 0 ? collected.join("\n") : void 0;
+}
+function getRfmMarker(line) {
+  const match = line.match(/^[ \t]*(>+)[ \t]?\[!(\w+)\]/);
+  const type = match?.[2];
+  if (match?.[1] === void 0 || type === void 0) return void 0;
+  return { depth: match[1].length, type };
+}
+function shouldGroupRfmMarkers(openingMarker, nextMarker) {
+  return openingMarker.depth === nextMarker.depth && openingMarker.type === "HINT" && nextMarker.type === "HINT";
+}
+function splitTopLevelRfmHintBlocks(input) {
+  const blocks = [];
+  const lines = input.split("\n");
+  let current = [];
+  for (const line of lines) {
+    if (current.length > 0 && line.trim() !== "" && /^[ \t]*>+[ \t]?\[!/.test(line)) {
+      blocks.push(current.join("\n"));
+      current = [line];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.length > 0) blocks.push(current.join("\n"));
+  return blocks.filter(isRfmHintBlock);
+}
+function parseRfmBlock(input) {
+  const block = parseBlock(input);
+  let html;
+  switch (block.type) {
+    case "ACCORDION":
+      html = renderAccordion({
+        modifier: "ingredient",
+        heading: block.title,
+        body: block.body
+      });
+      break;
+    case "TASK":
+      html = renderTaskBlock(block.body);
+      break;
+    case "HINT":
+      html = renderHintsPanel([block.body]);
+      break;
+    case "TIP":
+    case "DEBUG":
+      html = renderCalloutBlock(block.type.toLowerCase(), block.body);
+      break;
+    case "SAVE":
+      html = renderSaveBlock();
+      break;
+    case "NOPRINT":
+      html = renderNoPrintBlock(block.body);
+      break;
+    case "PRINTONLY":
+      html = renderPrintOnlyBlock(block.body);
+      break;
+    case "CHALLENGE":
+      html = renderChallengeBlock(block.body, block.title);
+      break;
+    case "INFO":
+      html = renderInfoBlock(block.body);
+      break;
+  }
+  return { html, type: block.type, title: block.title };
+}
+function getRfmHintBody(input) {
+  const block = parseBlock(input);
+  if (block.type !== "HINT") {
+    throw new Error("Expected an RFM HINT block.");
+  }
+  return block.body;
+}
+function isRfmHintBlock(input) {
+  try {
+    return parseBlock(input).type === "HINT";
+  } catch {
+    return false;
+  }
+}
+
+// src/rpfblocks.ts
+function createInvalidBlockError2(blockType, expected) {
+  return new Error(
+    `Input does not appear to be a valid ${blockType}. Expected ${expected}.`
+  );
+}
+function matchLegacyBlock(src, blockName) {
+  return new RegExp(
+    `^[ \\t]*---\\s+${blockName}\\s+---[ \\t]*\\n[\\s\\S]*?\\n[ \\t]*---\\s+\\/${blockName}\\s+---[ \\t]*(?:\\n|$)`
+  ).exec(src);
+}
+function parseCalloutBlock(input) {
+  const trimmed = input.trim();
+  const lines = trimmed.split("\n");
+  const firstLine = lines[0] ?? "";
+  const openMatch = firstLine.match(CALLOUT_OPEN_REGEX);
+  if (!openMatch) {
+    throw createInvalidBlockError2(
+      "RPF callout block",
+      'opening <div class="c-project-callout c-project-callout--{type}">'
+    );
+  }
+  const type = openMatch[2] ?? "";
+  const lastLine = lines.at(-1)?.trim() ?? "";
+  if (lastLine !== "</div>") {
+    throw createInvalidBlockError2("RPF callout block", "closing </div>");
+  }
+  const inner = trimmed.slice(firstLine.length).slice(0, -"</div>".length).trim();
+  const html = renderExistingCalloutBlock(type, inner);
+  return { html, type };
+}
+function parseTaskBlock(input) {
+  const trimmed = input.trim();
+  const lines = trimmed.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  if (!TASK_OPEN_REGEX.test(firstLine)) {
+    throw createInvalidBlockError2("RPF task block", "opening --- task ---");
+  }
+  const lastLine = lines.at(-1)?.trim() ?? "";
+  if (!TASK_CLOSE_REGEX.test(lastLine)) {
+    throw createInvalidBlockError2("RPF task block", "closing --- /task ---");
+  }
+  const inner = lines.slice(1, -1).join("\n").trim();
+  const html = renderTaskBlock(inner);
+  return { html };
+}
+function stripOuterMarkerBlock(input, blockName) {
+  const dedented = dedentBlock(input.trim());
+  const lines = dedented.split("\n");
+  const openRegex = new RegExp(`^---\\s+${blockName}\\s+---$`);
+  const closeRegex = new RegExp(`^---\\s+\\/${blockName}\\s+---$`);
+  const firstLineIndex = lines.findIndex((line) => openRegex.test(line.trim()));
+  const lastLineIndex = lines.findLastIndex(
+    (line) => closeRegex.test(line.trim())
+  );
+  if (firstLineIndex === -1 || lastLineIndex === -1 || lastLineIndex <= firstLineIndex) {
+    throw createInvalidBlockError2(
+      `RPF ${blockName} block`,
+      `opening --- ${blockName} --- and closing --- /${blockName} ---`
+    );
+  }
+  return lines.slice(firstLineIndex + 1, lastLineIndex).join("\n").trim();
+}
+function dedentBlock(input) {
+  const indents = input.split("\n").filter((line) => line.trim().length > 0).map((line) => line.match(/^[ \t]*/)?.[0].length ?? 0);
+  const minIndent = Math.min(...indents);
+  if (!Number.isFinite(minIndent) || minIndent === 0) return input;
+  return input.split("\n").map((line) => line.slice(minIndent)).join("\n");
+}
+function parseLegacyFrontmatter(input) {
+  const match = input.trimStart().match(/^[ \t]*---[ \t]*\n([\s\S]*?)\n[ \t]*---[ \t]*\n?([\s\S]*)$/);
+  if (!match) {
+    return { attributes: {}, body: input.trim() };
+  }
+  const attributes = {};
+  for (const line of (match[1] ?? "").split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key.length > 0) attributes[key] = value;
+  }
+  return { attributes, body: (match[2] ?? "").trim() };
+}
+function parseCollapseBlock(input) {
+  const inner = stripOuterMarkerBlock(input, "collapse");
+  const { attributes, body } = parseLegacyFrontmatter(inner);
+  return renderAccordion({
+    modifier: "ingredient",
+    heading: attributes.title ?? "",
+    body,
+    bodyIsHtml: /^\s*</.test(body)
+  });
+}
+function parseChallengeBlock(input) {
+  return renderChallengeBlock(stripOuterMarkerBlock(input, "challenge"));
+}
+function parseNoPrintBlock(input) {
+  return renderNoPrintBlock(stripOuterMarkerBlock(input, "no-print"));
+}
+function parsePrintOnlyBlock(input) {
+  return renderPrintOnlyBlock(stripOuterMarkerBlock(input, "print-only"));
+}
+function parseSaveBlock() {
+  return renderSaveBlock();
+}
+function parseHintBlock(input) {
+  return renderHintSlide(stripOuterMarkerBlock(input, "hint"));
+}
+function parseHintsBlock(input) {
+  const inner = stripOuterMarkerBlock(input, "hints");
+  const bodies = [
+    ...inner.matchAll(/^---\s+hint\s+---$([\s\S]*?)^---\s+\/hint\s+---$/gm)
+  ].map((match) => (match[1] ?? "").trim());
+  return renderHintsPanel(bodies);
+}
+function parseOutputBlock(input) {
+  const trimmed = input.trim();
+  const lines = trimmed.split("\n");
+  const firstLine = lines[0]?.trim() ?? "";
+  if (!OUTPUT_OPEN_REGEX.test(firstLine)) {
+    createInvalidBlockError2(
+      "RPF output block",
+      'opening <div class="c-project-output">'
+    );
+  }
+  const lastLine = lines.at(-1)?.trim() ?? "";
+  if (lastLine !== "</div>") {
+    createInvalidBlockError2("RPF output block", "closing </div>");
+  }
+  const inner = trimmed.slice(firstLine.length).slice(0, -"</div>".length).trim();
+  return `<div class="c-project-output">${inner}</div>`;
+}
+
+// src/index.ts
+function createLegacyBlockExtension(name, blockName, render, appendNewline = true) {
+  const startRegex = new RegExp(`^[ \\t]*--- ${blockName} ---$`, "m");
+  return {
+    name,
+    level: "block",
+    start(src) {
+      return src.search(startRegex);
+    },
+    tokenizer(src) {
+      const match = matchLegacyBlock(src, blockName);
+      if (match) {
+        return { type: name, raw: match[0], text: match[0] };
+      }
+    },
+    renderer(token) {
+      const html = render(token.text);
+      return appendNewline ? `${html}
+` : html;
+    }
+  };
+}
+function processEditorProject(content) {
+  marked2.use(markedSmartypantsLite());
+  marked2.use({
+    extensions: [
+      {
+        name: "htmlLineBreak",
+        level: "block",
+        start(src) {
+          return src.search(/^[ \t]*\{\.page-break\}[ \t]*(?:\n|$)/m);
+        },
+        tokenizer(src) {
+          const match = /^[ \t]*\{\.page-break\}[ \t]*(?:\n|$)/.exec(src);
+          if (match) {
+            return { type: "htmlLineBreak", raw: match[0] };
+          }
+        },
+        renderer() {
+          return "<div class=page-break></div>\n";
+        }
+      },
+      {
+        name: "preservedFence",
+        level: "block",
+        start(src) {
+          return src.search(/^[ \t]*(`{3,}|~{3,})/m);
+        },
+        tokenizer(src) {
+          const match = src.match(
+            /^[ \t]*(`{3,}|~{3,})([^\r\n]*)\r?\n([\s\S]*?)\r?\n[ \t]*\1[ \t]*(?:\n|$)/
+          );
+          if (!match) return;
+          return {
+            type: "preservedFence",
+            raw: match[0],
+            text: match[3] ?? "",
+            info: (match[2] ?? "").trim()
+          };
+        },
+        renderer(token) {
+          return renderMarkedCodeToken(token, token.raw);
+        }
+      },
+      // RFM alert blocks: > [!TASK], > [!ACCORDION], etc.
+      {
+        name: "rfmBlock",
+        level: "block",
+        start(src) {
+          return src.search(/^[ \t]*>+[ \t]?\[!/m);
+        },
+        tokenizer(src) {
+          const raw = matchRfmBlock(src);
+          if (raw !== void 0) {
+            return { type: "rfmBlock", raw, text: raw };
+          }
+        },
+        renderer(token) {
+          const raw = token.text;
+          const hintBlocks = splitTopLevelRfmHintBlocks(raw);
+          if (hintBlocks.length > 1) {
+            return `${renderHintsPanel(hintBlocks.map(getRfmHintBody))}
+`;
+          }
+          return `${parseRfmBlock(raw).html}
+`;
+        }
+      },
+      // RPF callout blocks: <div class="c-project-callout c-project-callout--{type}">
+      {
+        name: "rpfCallout",
+        level: "block",
+        start(src) {
+          return src.search(
+            /<div\s+class="c-project-callout\s+c-project-callout--/
+          );
+        },
+        tokenizer(src) {
+          const match = /^<div\s+class="c-project-callout\s+c-project-callout--[a-z0-9-]+">[\s\S]*?<\/div>/.exec(
+            src
+          );
+          if (match) {
+            return { type: "rpfCallout", raw: match[0], text: match[0] };
+          }
+        },
+        renderer(token) {
+          return `${parseCalloutBlock(token.text).html}
+`;
+        }
+      },
+      // RPF task blocks: --- task --- ... --- /task ---
+      {
+        name: "rpfTask",
+        level: "block",
+        start(src) {
+          return src.search(/^--- task ---$/m);
+        },
+        tokenizer(src) {
+          const match = /^--- task ---\n[\s\S]*?\n--- \/task ---/.exec(src);
+          if (match) {
+            return { type: "rpfTask", raw: match[0], text: match[0] };
+          }
+        },
+        renderer(token) {
+          return `${parseTaskBlock(token.text).html}
+`;
+        }
+      },
+      // RPF collapse blocks: --- collapse --- ... --- /collapse ---
+      createLegacyBlockExtension("rpfCollapse", "collapse", parseCollapseBlock),
+      // RPF hints blocks: --- hints --- ... --- /hints ---
+      createLegacyBlockExtension("rpfHints", "hints", parseHintsBlock),
+      // RPF hint blocks: --- hint --- ... --- /hint ---
+      createLegacyBlockExtension("rpfHint", "hint", parseHintBlock),
+      // RPF challenge blocks: --- challenge --- ... --- /challenge ---
+      createLegacyBlockExtension(
+        "rpfChallenge",
+        "challenge",
+        parseChallengeBlock,
+        false
+      ),
+      // RPF print visibility blocks.
+      createLegacyBlockExtension("rpfNoPrint", "no-print", parseNoPrintBlock),
+      createLegacyBlockExtension(
+        "rpfPrintOnly",
+        "print-only",
+        parsePrintOnlyBlock
+      ),
+      // RPF save block: --- save ---
+      {
+        name: "rpfSave",
+        level: "block",
+        start(src) {
+          return src.search(/^[ \t]*--- save ---$/m);
+        },
+        tokenizer(src) {
+          const match = /^[ \t]*---\s+save\s+---[ \t]*(?:\n|$)/.exec(src);
+          if (match) {
+            return { type: "rpfSave", raw: match[0], text: match[0] };
+          }
+        },
+        renderer() {
+          return `${parseSaveBlock()}
+`;
+        }
+      },
+      // RPF code blocks: --- code --- ... --- /code ---
+      // Also handles the wrapped form: <div class="c-project-code">\n--- code ---\n...\n--- /code ---\n</div>
+      {
+        name: "rpfCode",
+        level: "block",
+        start(src) {
+          const bare = src.search(/^--- code ---$/m);
+          const wrapped = src.search(/^<div class="c-project-code">/m);
+          if (bare === -1) return wrapped;
+          if (wrapped === -1) return bare;
+          return Math.min(bare, wrapped);
+        },
+        tokenizer(src) {
+          const wrappedMatch = /^<div class="c-project-code">\n(--- code ---\n[\s\S]*?\n--- \/code ---)\n\s*<\/div>/.exec(
+            src
+          );
+          if (wrappedMatch) {
+            return {
+              type: "rpfCode",
+              raw: wrappedMatch[0],
+              text: wrappedMatch[1]
+            };
+          }
+          const match = /^--- code ---\n[\s\S]*?\n--- \/code ---/.exec(src);
+          if (match) {
+            return { type: "rpfCode", raw: match[0], text: match[0] };
+          }
+        },
+        renderer(token) {
+          return `${parseRpfCodeBlock(token.text).html}
+`;
+        }
+      },
+      // RPF output blocks: <div class="c-project-output"> ... </div>
+      {
+        name: "rpfOutput",
+        level: "block",
+        start(src) {
+          return src.search(/^<div\s+class="c-project-output">\s*$/m);
+        },
+        tokenizer(src) {
+          const match = /^<div\s+class="c-project-output">\s[\s\S]*?<\/div>/.exec(src);
+          if (match) {
+            return { type: "rpfOutput", raw: match[0], text: match[0] };
+          }
+        },
+        renderer(token) {
+          return `${parseOutputBlock(token.text)}
+`;
+        }
+      }
+    ],
+    renderer: {
+      // Override fenced code blocks to use Prism with our custom options.
+      code(token) {
+        return renderMarkedCodeToken(token);
+      },
+      listitem(item) {
+        const itemTokens = Array.isArray(item.tokens) ? item.tokens : [];
+        const raw = typeof item.raw === "string" ? item.raw : "";
+        const rawFenceBlocks = extractListItemFenceBlocks(raw);
+        let rawFenceIndex = 0;
+        const firstNewline = raw.indexOf("\n");
+        const hasBlankLineAfterMarker = firstNewline !== -1 && /^\n[ \t]*\n/.test(raw.slice(firstNewline));
+        let body = "";
+        for (let index = 0; index < itemTokens.length; index++) {
+          const token = itemTokens[index];
+          if (index === 0 && !item.task && !hasBlankLineAfterMarker && itemTokens.length > 1 && token?.type === "paragraph") {
+            body += this.parser.parseInline(token.tokens ?? []);
+            continue;
+          }
+          if (token?.type === "code" || token?.type === "preservedFence") {
+            body += renderMarkedCodeToken(token, rawFenceBlocks[rawFenceIndex]);
+            rawFenceIndex++;
+            continue;
+          }
+          body += this.parser.parse([token]).trimStart();
+        }
+        return `<li>${body}</li>
+`;
+      }
+    },
+    hooks: {
+      postprocess(html) {
+        return applyInlineCodeClasses(html);
+      }
+    }
+  });
+  marked2.use(gfmHeadingId({ prefix: "" }));
+  return marked2.parse(content);
+}
+export {
+  processEditorProject
+};