@asteroidcms/core-utils 0.1.2 → 0.1.4

package/dist/client.js

@@ -0,0 +1,1669 @@
+"use client";
+import { createContext, useContext, useMemo, useRef, useEffect, createElement, useState } from 'react';
+import { ApolloProvider, useQuery, useMutation } from '@apollo/client/react';
+import { gql, HttpLink, ApolloClient, InMemoryCache, ApolloLink, CombinedGraphQLErrors, CombinedProtocolErrors } from '@apollo/client';
+import { SetContextLink } from '@apollo/client/link/context';
+import { ErrorLink } from '@apollo/client/link/error';
+import { jsx } from 'react/jsx-runtime';
+import hljs from 'highlight.js/lib/common';
+import 'highlight.js/styles/tokyo-night-dark.css';
+
+var AsteroidCMSContext = createContext(null);
+function useAsteroidCMSConfig() {
+  const ctx = useContext(AsteroidCMSContext);
+  if (!ctx) {
+    throw new Error(
+      "useAsteroidCMSConfig must be used inside <AsteroidCMSProvider>. Wrap your app with <AsteroidCMSProvider cmsUrl=... apiKey=... />."
+    );
+  }
+  return ctx;
+}
+function createErrorLink(onError) {
+  return new ErrorLink(({ error }) => {
+    if (!onError) return;
+    if (CombinedGraphQLErrors.is(error)) {
+      error.errors.forEach((e) => onError(e));
+    } else if (CombinedProtocolErrors.is(error)) {
+      error.errors.forEach((e) => onError(e));
+    } else {
+      onError(error);
+    }
+  });
+}
+
+// src/apollo/createApolloClient.ts
+var trimTrailingSlash = (s) => s.replace(/\/+$/, "");
+var ensureLeadingSlash = (s) => s.startsWith("/") ? s : `/${s}`;
+function resolveConfig(config) {
+  if (!config.cmsUrl) throw new Error("AsteroidCMSProvider: `cmsUrl` is required.");
+  if (!config.apiKey) throw new Error("AsteroidCMSProvider: `apiKey` is required.");
+  return {
+    cmsUrl: trimTrailingSlash(config.cmsUrl),
+    apiKey: config.apiKey,
+    graphqlPath: ensureLeadingSlash(config.graphqlPath ?? "/graphql"),
+    mediaPath: ensureLeadingSlash(config.mediaPath ?? "/media/canonical"),
+    headers: config.headers ?? {},
+    onError: config.onError
+  };
+}
+function createApolloClient(config) {
+  if (config.client) return config.client;
+  const resolved = resolveConfig(config);
+  const uri = `${resolved.cmsUrl}${resolved.graphqlPath}`;
+  const authLink = new SetContextLink((_op, prevContext) => {
+    const prevHeaders = prevContext.headers ?? {};
+    return {
+      ...prevContext,
+      headers: {
+        ...prevHeaders,
+        "x-api-key": resolved.apiKey,
+        ...resolved.headers
+      }
+    };
+  });
+  const httpLink = new HttpLink({ uri });
+  return new ApolloClient({
+    link: ApolloLink.from([createErrorLink(resolved.onError), authLink, httpLink]),
+    cache: new InMemoryCache(config.cacheConfig),
+    defaultOptions: {
+      watchQuery: {
+        fetchPolicy: "cache-and-network",
+        errorPolicy: "all",
+        returnPartialData: false
+      },
+      query: { fetchPolicy: "network-only", errorPolicy: "all" },
+      mutate: { errorPolicy: "none" }
+    },
+    ...config.apolloOptions
+  });
+}
+function AsteroidCMSProvider({ children, ...config }) {
+  const resolved = useMemo(() => resolveConfig(config), [
+    config.cmsUrl,
+    config.apiKey,
+    config.graphqlPath,
+    config.mediaPath,
+    config.headers,
+    config.onError
+  ]);
+  const client = useMemo(
+    () => createApolloClient(config),
+    // The client is intentionally rebuilt only when the identity-shaping props change.
+    [
+      config.client,
+      resolved.cmsUrl,
+      resolved.apiKey,
+      resolved.graphqlPath,
+      config.cacheConfig,
+      config.apolloOptions
+    ]
+  );
+  return /* @__PURE__ */ jsx(AsteroidCMSContext.Provider, { value: resolved, children: /* @__PURE__ */ jsx(ApolloProvider, { client, children }) });
+}
+function useCmsContent({
+  schema_slug,
+  entrySlug,
+  select = [],
+  fullData = false,
+  limit,
+  offset,
+  status = "PUBLISHED",
+  filter,
+  search,
+  variables = {}
+}) {
+  const isSingle = !!entrySlug;
+  const buildSelection = (items = []) => {
+    const lines = [];
+    items.forEach((item) => {
+      if (typeof item === "string") {
+        lines.push(`${item}: dataField(slug: "${item}")`);
+      } else if ("field" in item && typeof item.field === "string") {
+        if (!("select" in item)) {
+          const alias2 = item.as || item.field;
+          lines.push(`${alias2}: dataField(slug: "${item.field}")`);
+          return;
+        }
+        const alias = item.as || item.field;
+        const resolver = item.single ? "expandedReferenceObject" : "expandedReference";
+        const subSelection = item.select?.length ? buildSelection(item.select) : "data { ... }";
+        lines.push(`
+          ${alias}: ${resolver}(slug: "${item.field}") {
+            ${subSelection}
+          }
+        `);
+      }
+    });
+    return lines.join("\n      ").trim();
+  };
+  const selectionParts = [];
+  if (fullData) selectionParts.push("data");
+  if (select.length > 0) {
+    const userSelection = buildSelection(select);
+    if (userSelection) selectionParts.push(userSelection);
+  }
+  const selection = selectionParts.join("\n      ").trim() || "id";
+  const queryVariables = {
+    schema_slug,
+    ...entrySlug && { slug: entrySlug },
+    ...variables
+  };
+  const fieldArgParts = ["schema_slug: $schema_slug"];
+  if (!isSingle) {
+    if (typeof limit === "number" && limit >= 0) {
+      fieldArgParts.push("limit: $limit");
+      queryVariables.limit = limit;
+    }
+    if (typeof offset === "number" && offset >= 0) {
+      fieldArgParts.push("offset: $offset");
+      queryVariables.offset = offset;
+    }
+    if (status) {
+      fieldArgParts.push("status: $status");
+      queryVariables.status = status;
+    }
+    const hasSearch = Array.isArray(search) && search.length > 0;
+    const hasFilter = filter && typeof filter === "object" && Object.keys(filter).length > 0;
+    if (hasSearch || hasFilter) {
+      const mergedFilter = hasFilter ? { ...filter } : {};
+      if (hasSearch) {
+        for (const condition of search) {
+          mergedFilter[condition.field] = {
+            regex: true,
+            value: condition.value,
+            mode: condition.mode ?? "i"
+          };
+        }
+      }
+      fieldArgParts.push("data: $filter");
+      queryVariables.filter = mergedFilter;
+    }
+  }
+  const varDecls = ["$schema_slug: String!"];
+  if ("limit" in queryVariables) varDecls.push("$limit: Float");
+  if ("offset" in queryVariables) varDecls.push("$offset: Float");
+  if ("status" in queryVariables) varDecls.push("$status: ContentStatus");
+  if ("filter" in queryVariables) varDecls.push("$filter: JSONObject");
+  const varBlock = varDecls.length > 0 ? `(
+  ${varDecls.join("\n  ")}
+)` : "";
+  const contentFieldArgs = fieldArgParts.join(", ");
+  const queryStr = isSingle ? `
+      query Get${schema_slug}Entry($schema_slug: String!, $slug: String!) {
+        entry: contentEntry(schema_slug: $schema_slug, slug: $slug) {
+          ${selection}
+        }
+      }
+    ` : `
+      query Get${schema_slug}Entries${varBlock} {
+        entries: contentEntries(${contentFieldArgs}) {
+          ${selection}
+        }
+      }
+    `;
+  const GET_CONTENT = gql(queryStr);
+  const { loading, error, data, ...rest } = useQuery(GET_CONTENT, {
+    variables: queryVariables,
+    skip: !schema_slug || isSingle && !entrySlug
+  });
+  const typed = data;
+  const result = isSingle ? typed?.entry : typed?.entries;
+  return {
+    loading,
+    error,
+    data: result,
+    ...rest
+  };
+}
+function useCmsMutate({
+  schema_slug,
+  select = [],
+  fullData = false,
+  mutationType = "create",
+  entryId,
+  variables: inputVariables = {}
+}) {
+  const buildSelection = (items = []) => {
+    const lines = [];
+    for (const item of items) {
+      if (typeof item === "string") {
+        lines.push(`${item}: dataField(slug: "${item}")`);
+        continue;
+      }
+      const { field, as, single, select: subSelect } = item;
+      const alias = as || field;
+      if (!subSelect?.length) {
+        lines.push(`${alias}: dataField(slug: "${field}")`);
+        continue;
+      }
+      const resolver = single ? "expandedReferenceObject" : "expandedReference";
+      const sub = buildSelection(subSelect) || "id slug";
+      lines.push(`
+        ${alias}: ${resolver}(slug: "${field}") {
+          id
+          slug
+          ${sub}
+        }
+      `);
+    }
+    return lines.join("\n      ").trim();
+  };
+  const userSelection = buildSelection(select);
+  let selection = fullData ? "data" : "";
+  if (userSelection) {
+    selection = selection ? `${selection}
+      ${userSelection}` : userSelection;
+  }
+  if (!selection) {
+    selection = "id slug status version created_at updated_at";
+  }
+  const operation = mutationType;
+  const mutationName = `${operation}ContentEntry`;
+  const varDecls = ["$schema_slug: String!"];
+  const callArgs = ["schema_slug: $schema_slug"];
+  if (operation === "create" || operation === "update") {
+    varDecls.unshift("$data: JSONObject!");
+    callArgs.unshift("data: $data");
+  }
+  if (operation === "update" || operation === "delete") {
+    varDecls.push("$id: ID!");
+    callArgs.push("id: $id");
+  }
+  const returnFields = selection.includes("data") ? selection : `${selection}
+        data`;
+  const MUTATION = gql`
+    mutation ${mutationName}(${varDecls.join(", ")}) {
+      result: ${mutationName}(${callArgs.join(", ")}) {
+        id
+        status
+        version
+        created_at
+        updated_at
+        schema {
+          id
+          slug
+        }
+        ${returnFields}
+      }
+    }
+  `;
+  const mutationVariables = {
+    schema_slug,
+    ...operation === "update" || operation === "delete" ? { id: entryId } : {},
+    ...inputVariables
+  };
+  if ((operation === "update" || operation === "delete") && !entryId) {
+    console.warn(`useCmsMutate: entryId is required for ${operation}`);
+  }
+  const [mutateFn, mutationResult] = useMutation(MUTATION, {
+    variables: mutationVariables
+  });
+  const resultData = mutationResult.data?.result;
+  return {
+    mutate: mutateFn,
+    ...mutationResult,
+    data: resultData
+  };
+}
+
+// src/utils/cmsImage.ts
+function cmsImage(id, options) {
+  if (!id) return "";
+  const base = options.cmsUrl.replace(/\/+$/, "");
+  const path = (options.mediaPath ?? "/media/canonical").replace(/^\/?/, "/");
+  return `${base}${path}/${id}`;
+}
+function useCmsImage() {
+  const { cmsUrl, mediaPath } = useAsteroidCMSConfig();
+  return (id) => cmsImage(id, { cmsUrl, mediaPath });
+}
+
+// src/components/richTextParser.ts
+var DEFAULT_ALLOWLIST = [
+  "p",
+  "br",
+  "hr",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "ul",
+  "ol",
+  "li",
+  "blockquote",
+  "pre",
+  "code",
+  "kbd",
+  "a",
+  "strong",
+  "em",
+  "u",
+  "b",
+  "i",
+  "s",
+  "strike",
+  "del",
+  "mark",
+  "small",
+  "sub",
+  "sup",
+  "table",
+  "thead",
+  "tbody",
+  "tfoot",
+  "tr",
+  "th",
+  "td",
+  "colgroup",
+  "col",
+  "figure",
+  "figcaption",
+  "img",
+  "aside",
+  "section",
+  "article",
+  "div",
+  "span"
+];
+var ALLOWED_ATTRS = {
+  a: ["href", "title", "target", "rel"],
+  img: ["src", "alt", "title", "width", "height", "loading"],
+  th: ["colspan", "rowspan", "scope"],
+  td: ["colspan", "rowspan"],
+  col: ["span", "width"],
+  colgroup: ["span"],
+  table: ["border", "cellpadding", "cellspacing"],
+  span: ["style"]
+};
+var ALLOWED_STYLE_PROPS = {
+  span: ["font-size"]
+};
+var STYLE_VALUE_VALIDATORS = {
+  "font-size": (v) => /^\d{1,3}(?:\.\d+)?(?:px|rem|em|%)$/.test(v.trim())
+};
+function sanitizeStyle(tag, style) {
+  const allowed = ALLOWED_STYLE_PROPS[tag];
+  if (!allowed || !style) return "";
+  const out = [];
+  for (const decl of style.split(";")) {
+    const idx = decl.indexOf(":");
+    if (idx === -1) continue;
+    const name = decl.slice(0, idx).trim().toLowerCase();
+    const value = decl.slice(idx + 1).trim();
+    if (!allowed.includes(name)) continue;
+    const validate = STYLE_VALUE_VALIDATORS[name];
+    if (!validate || !validate(value)) continue;
+    out.push(`${name}: ${value}`);
+  }
+  return out.join("; ");
+}
+var GLOBAL_ALLOWED_ATTRS = [
+  "id",
+  "class",
+  "lang",
+  "dir",
+  "data-variant",
+  "data-callout",
+  "data-title",
+  "data-callout-title",
+  "data-language",
+  "data-filename"
+];
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "src"]);
+function parseRichText(html, options = {}) {
+  if (!html || typeof html !== "string") return "";
+  let working = isLegacyFormat(html) ? migrateLegacyToHtml(html) : html;
+  working = removeEmptyParagraphs(working);
+  working = upgradeStandaloneImages(working);
+  working = upgradeAuthoredBlockquotes(working);
+  working = flattenTableCellParagraphs(working);
+  working = sanitizeAndStyle(working, options);
+  if (options.autoHeadingIds !== false) {
+    working = injectHeadingIds(working);
+  }
+  return working;
+}
+function injectHeadingIds(html) {
+  const used = /* @__PURE__ */ new Map();
+  const existingRe = /<h[1-6]\b[^>]*\bid\s*=\s*("([^"]*)"|'([^']*)'|(\S+))/gi;
+  let em;
+  while ((em = existingRe.exec(html)) !== null) {
+    const id = em[2] ?? em[3] ?? em[4] ?? "";
+    if (id) used.set(id, (used.get(id) ?? 0) + 1);
+  }
+  return html.replace(
+    /<(h[1-6])\b([^>]*)>([\s\S]*?)<\/\1>/gi,
+    (full, tag, attrs, inner) => {
+      if (/\bid\s*=/i.test(attrs)) return full;
+      const text = inner.replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s+/g, " ").trim();
+      if (!text) return full;
+      const base = slugifyHeading(text) || tag;
+      const n = used.get(base) ?? 0;
+      used.set(base, n + 1);
+      const id = n === 0 ? base : `${base}-${n}`;
+      return `<${tag}${attrs} id="${id}">${inner}</${tag}>`;
+    }
+  );
+}
+function slugifyHeading(text) {
+  return text.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function flattenTableCellParagraphs(html) {
+  return html.replace(
+    /<(th|td)\b([^>]*)>([\s\S]*?)<\/\1>/gi,
+    (_full, tag, attrs, inner) => {
+      let flat = inner;
+      flat = flat.replace(/<p\b[^>]*>/gi, "");
+      flat = flat.replace(/<\/p>(\s*)(?=\S)/gi, "<br />$1");
+      flat = flat.replace(/<\/p>\s*$/i, "");
+      return `<${tag}${attrs}>${flat.trim()}</${tag}>`;
+    }
+  );
+}
+function removeEmptyParagraphs(html) {
+  return html.replace(/<p\b[^>]*>(?:\s|&nbsp;|<br\s*\/?>)*<\/p>/gi, "");
+}
+function upgradeStandaloneImages(html) {
+  return html.replace(
+    /<p\b[^>]*>\s*(<img\b[^>]*?>)\s*<\/p>/gi,
+    (_full, img) => {
+      const altMatch = img.match(/\balt\s*=\s*(?:"([^"]*)"|'([^']*)')/i);
+      const titleMatch = img.match(/\btitle\s*=\s*(?:"([^"]*)"|'([^']*)')/i);
+      const alt = altMatch ? altMatch[1] ?? altMatch[2] ?? "" : "";
+      const title = titleMatch ? titleMatch[1] ?? titleMatch[2] ?? "" : "";
+      const caption = title || alt;
+      const captionHtml = caption ? `<figcaption data-variant="image">${escapeHtml(caption)}</figcaption>` : "";
+      return `<figure data-variant="image">${img}${captionHtml}</figure>`;
+    }
+  );
+}
+function injectQuoteSpans(inner) {
+  const trimmed = inner.trim();
+  if (!trimmed) return trimmed;
+  const openSpan = `<span data-variant="quote-open">\u201C</span>`;
+  const closeSpan = `<span data-variant="quote-close">\u201D</span>`;
+  let result = trimmed.replace(
+    /^(\s*<p\b[^>]*>)/,
+    (_m, tag) => `${tag}${openSpan}`
+  );
+  if (result === trimmed) {
+    result = `${openSpan}${result}`;
+  }
+  const replaced = result.replace(
+    /(<\/p>\s*)$/,
+    (_m, tag) => `${closeSpan}${tag}`
+  );
+  if (replaced === result) {
+    result = `${result}${closeSpan}`;
+  } else {
+    result = replaced;
+  }
+  return result;
+}
+function upgradeAuthoredBlockquotes(html) {
+  const figureRanges = [];
+  const figRe = /<figure\b[\s\S]*?<\/figure>/gi;
+  let fm;
+  while ((fm = figRe.exec(html)) !== null) {
+    figureRanges.push([fm.index, fm.index + fm[0].length]);
+  }
+  const insideFigure = (pos) => figureRanges.some(([s, e]) => pos >= s && pos < e);
+  return html.replace(
+    /<blockquote\b[^>]*>([\s\S]*?)<\/blockquote>/gi,
+    (full, inner, offset) => {
+      if (typeof offset === "number" && insideFigure(offset)) return full;
+      const lastP = inner.match(/<p\b[^>]*>([\s\S]*?)<\/p>\s*$/i);
+      if (!lastP) return full;
+      const text = stripInlineTags(decodeEntities(lastP[1])).trim();
+      const authorMatch = text.match(/^(?:[—–]+|--)\s+(.+)$/);
+      if (!authorMatch) return full;
+      const author = authorMatch[1].trim();
+      const rest = inner.slice(0, inner.length - lastP[0].length).trim();
+      if (!rest) return full;
+      const wrapped = injectQuoteSpans(rest);
+      return `<figure data-variant="pullquote"><blockquote data-variant="pullquote">${wrapped}</blockquote><figcaption data-variant="pullquote">\u2014 <span data-variant="author">${escapeHtml(author)}</span></figcaption></figure>`;
+    }
+  );
+}
+function isLegacyFormat(html) {
+  if (!/<div\b/i.test(html)) return false;
+  return /<div[^>]*>\s*(?:&gt;|```|\|)/i.test(html);
+}
+function decodeEntities(input) {
+  return input.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function extractLegacyLines(html) {
+  const normalized = html.replace(/\r\n?/g, "\n").replace(/<\/div>\s*<div[^>]*>/gi, "\n").replace(/<div[^>]*>/gi, "").replace(/<\/div>/gi, "\n").replace(/<br\s*\/?>(\s*)/gi, "\n").replace(/<\/p>\s*<p[^>]*>/gi, "\n\n").replace(/<p[^>]*>/gi, "").replace(/<\/p>/gi, "\n");
+  return normalized.split("\n").map((line) => line.replace(/\s+$/g, ""));
+}
+function stripInlineTags(input) {
+  return input.replace(/<[^>]+>/g, "");
+}
+function renderInline(raw) {
+  let out = decodeEntities(raw);
+  out = out.replace(
+    /`([^`]+)`/g,
+    (_m, code) => `<code>${escapeHtml(decodeEntities(code))}</code>`
+  );
+  out = out.replace(
+    /!\[([^\]]*)\]\(([^)]+)\)/g,
+    (_m, alt, src) => `<img src="${escapeHtml(String(src).trim())}" alt="${escapeHtml(String(alt))}" />`
+  );
+  out = out.replace(
+    /\[([^\]]+)\]\(([^)]+)\)/g,
+    (_m, text, href) => `<a href="${escapeHtml(String(href).trim())}" target="_blank" rel="noreferrer noopener">${text}</a>`
+  );
+  out = out.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  out = out.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+  out = out.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  out = out.replace(/(^|[^_])_([^_]+)_(?!_)/g, "$1<em>$2</em>");
+  return out;
+}
+function isCodeFence(line) {
+  return /^\s*```/.test(stripInlineTags(decodeEntities(line)).trim());
+}
+function isBlockquoteLine(line) {
+  return stripInlineTags(decodeEntities(line)).trim().startsWith(">");
+}
+function calloutHeaderOf(line) {
+  const text = stripInlineTags(decodeEntities(line)).trim();
+  const m = text.match(/^>\s*\[!\s*([^\]]+?)\s*\]\s*$/);
+  if (!m) return null;
+  const raw = m[1];
+  const lower = raw.toLowerCase();
+  const knownVariants = [
+    "info",
+    "warning",
+    "success",
+    "danger",
+    "note",
+    "tip",
+    "caution",
+    "important"
+  ];
+  const variant = knownVariants.includes(lower) ? lower === "note" ? "info" : lower === "tip" ? "success" : lower === "caution" || lower === "important" ? "warning" : lower : "info";
+  return { title: raw, variant };
+}
+function stripBlockquoteMarker(line) {
+  return stripInlineTags(decodeEntities(line)).replace(/^\s*>\s?/, "");
+}
+function isTableLine(line) {
+  return /^\|.*\|$/.test(stripInlineTags(decodeEntities(line)).trim());
+}
+function isTableDivider(line) {
+  return /^\|\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)+\|?$/.test(
+    stripInlineTags(decodeEntities(line)).trim()
+  );
+}
+function splitTableRow(line) {
+  return stripInlineTags(decodeEntities(line)).trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
+}
+function renderTable(rows) {
+  if (rows.length === 0) return "";
+  let headerCells = [];
+  let bodyStart = 0;
+  if (rows.length >= 2 && isTableDivider(rows[1])) {
+    headerCells = splitTableRow(rows[0]);
+    bodyStart = 2;
+  }
+  const bodyRows = rows.slice(bodyStart).map(splitTableRow);
+  const head = headerCells.length ? `<thead><tr>${headerCells.map((c) => `<th>${renderInline(c)}</th>`).join("")}</tr></thead>` : "";
+  const body = bodyRows.length ? `<tbody>${bodyRows.map((cells) => `<tr>${cells.map((c) => `<td>${renderInline(c)}</td>`).join("")}</tr>`).join("")}</tbody>` : "";
+  return `<table>${head}${body}</table>`;
+}
+function renderCallout(title, variant, bodyLines) {
+  const body = bodyLines.map((l) => renderInline(l)).join("<br />");
+  return `<aside data-callout data-variant="${escapeHtml(variant)}" data-title="${escapeHtml(title)}">${body ? `<p>${body}</p>` : ""}</aside>`;
+}
+function renderBlockquote(lines) {
+  if (lines.length > 0) {
+    const last = stripInlineTags(
+      decodeEntities(lines[lines.length - 1])
+    ).trim();
+    const authorMatch = last.match(/^(?:[—–]+|--)\s+(.+)$/);
+    if (authorMatch && lines.length > 1) {
+      const author = authorMatch[1].trim();
+      const quoteLines = lines.slice(0, -1);
+      const body = quoteLines.map((l) => renderInline(l)).join("<br />");
+      return `<figure data-variant="pullquote"><blockquote data-variant="pullquote"><p><span data-variant="quote-open">\u201C</span>${body}<span data-variant="quote-close">\u201D</span></p></blockquote><figcaption data-variant="pullquote">\u2014 <span data-variant="author">${escapeHtml(author)}</span></figcaption></figure>`;
+    }
+  }
+  return `<blockquote><p>${lines.map((l) => renderInline(l)).join("<br />")}</p></blockquote>`;
+}
+function isImageOnlyLine(line) {
+  const text = stripInlineTags(decodeEntities(line)).trim();
+  return /^!\[[^\]]*\]\([^)]+\)$/.test(text);
+}
+function renderImageFigure(line) {
+  const m = stripInlineTags(decodeEntities(line)).trim().match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
+  if (!m) return "";
+  const alt = m[1];
+  const src = m[2].trim();
+  const img = `<img src="${escapeHtml(src)}" alt="${escapeHtml(alt)}" />`;
+  const cap = alt ? `<figcaption data-variant="image">${escapeHtml(alt)}</figcaption>` : "";
+  return `<figure data-variant="image">${img}${cap}</figure>`;
+}
+function renderParagraph(lines) {
+  const body = lines.map((l) => renderInline(l)).join("<br />");
+  return body.length === 0 ? "" : `<p>${body}</p>`;
+}
+function migrateLegacyToHtml(html) {
+  const lines = extractLegacyLines(html);
+  const blocks = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const trimmed = stripInlineTags(decodeEntities(line)).trim();
+    if (trimmed.length === 0) {
+      i++;
+      continue;
+    }
+    if (isCodeFence(line)) {
+      const codeLines = [];
+      i++;
+      while (i < lines.length && !isCodeFence(lines[i])) {
+        codeLines.push(stripInlineTags(decodeEntities(lines[i])));
+        i++;
+      }
+      if (i < lines.length) i++;
+      blocks.push(
+        `<pre><code>${escapeHtml(codeLines.join("\n"))}</code></pre>`
+      );
+      continue;
+    }
+    const callout = calloutHeaderOf(line);
+    if (callout) {
+      const bodyLines = [];
+      i++;
+      while (i < lines.length && isBlockquoteLine(lines[i])) {
+        bodyLines.push(stripBlockquoteMarker(lines[i]));
+        i++;
+      }
+      blocks.push(renderCallout(callout.title, callout.variant, bodyLines));
+      continue;
+    }
+    if (isBlockquoteLine(line)) {
+      const quoteLines = [];
+      while (i < lines.length && isBlockquoteLine(lines[i])) {
+        quoteLines.push(stripBlockquoteMarker(lines[i]));
+        i++;
+      }
+      blocks.push(renderBlockquote(quoteLines));
+      continue;
+    }
+    if (isTableLine(line)) {
+      const tableLines = [];
+      while (i < lines.length && isTableLine(lines[i])) {
+        tableLines.push(lines[i]);
+        i++;
+      }
+      blocks.push(renderTable(tableLines));
+      continue;
+    }
+    if (isImageOnlyLine(line)) {
+      blocks.push(renderImageFigure(line));
+      i++;
+      continue;
+    }
+    const paragraphLines = [];
+    while (i < lines.length && stripInlineTags(decodeEntities(lines[i])).trim().length > 0 && !isCodeFence(lines[i]) && !isBlockquoteLine(lines[i]) && !isTableLine(lines[i]) && !isImageOnlyLine(lines[i])) {
+      paragraphLines.push(lines[i]);
+      i++;
+    }
+    const p = renderParagraph(paragraphLines);
+    if (p) blocks.push(p);
+  }
+  return blocks.join("");
+}
+var VOID_TAGS = /* @__PURE__ */ new Set([
+  "br",
+  "hr",
+  "img",
+  "input",
+  "meta",
+  "link",
+  "source",
+  "wbr",
+  "col"
+]);
+function tokenize(html) {
+  const tokens = [];
+  let i = 0;
+  while (i < html.length) {
+    const lt = html.indexOf("<", i);
+    if (lt === -1) {
+      tokens.push({ type: "text", value: html.slice(i) });
+      break;
+    }
+    if (lt > i) tokens.push({ type: "text", value: html.slice(i, lt) });
+    if (html.startsWith("<!--", lt)) {
+      const end2 = html.indexOf("-->", lt + 4);
+      if (end2 === -1) {
+        i = html.length;
+        break;
+      }
+      tokens.push({ type: "comment" });
+      i = end2 + 3;
+      continue;
+    }
+    let end = lt + 1;
+    let inQuote = null;
+    while (end < html.length) {
+      const ch = html[end];
+      if (inQuote) {
+        if (ch === inQuote) inQuote = null;
+      } else {
+        if (ch === '"' || ch === "'") inQuote = ch;
+        else if (ch === ">") break;
+      }
+      end++;
+    }
+    if (end >= html.length) {
+      tokens.push({ type: "text", value: html.slice(lt) });
+      break;
+    }
+    const tagContent = html.slice(lt + 1, end).trim();
+    if (tagContent.startsWith("/")) {
+      tokens.push({
+        type: "close",
+        tag: tagContent.slice(1).trim().toLowerCase()
+      });
+    } else {
+      const selfClosingMark = tagContent.endsWith("/");
+      const inner = selfClosingMark ? tagContent.slice(0, -1).trim() : tagContent;
+      const spaceIdx = inner.search(/\s/);
+      const tag = (spaceIdx === -1 ? inner : inner.slice(0, spaceIdx)).toLowerCase();
+      const attrStr = spaceIdx === -1 ? "" : inner.slice(spaceIdx + 1);
+      const attrs = parseAttrs(attrStr);
+      tokens.push({
+        type: "open",
+        tag,
+        attrs,
+        selfClosing: selfClosingMark || VOID_TAGS.has(tag)
+      });
+    }
+    i = end + 1;
+  }
+  return tokens;
+}
+function parseAttrs(str) {
+  const out = {};
+  const re = /([a-zA-Z_][a-zA-Z0-9_:-]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+  let m;
+  while ((m = re.exec(str)) !== null) {
+    const name = m[1].toLowerCase();
+    const value = m[2] ?? m[3] ?? m[4] ?? "";
+    out[name] = decodeEntities(value);
+  }
+  return out;
+}
+function isAttrAllowed(tag, attr) {
+  if (attr.startsWith("on")) return false;
+  if (GLOBAL_ALLOWED_ATTRS.includes(attr)) return true;
+  const list = ALLOWED_ATTRS[tag];
+  return Boolean(list && list.includes(attr));
+}
+function isSafeUrl(value) {
+  const v = value.trim().toLowerCase();
+  if (v.startsWith("javascript:") || v.startsWith("data:") && !v.startsWith("data:image/"))
+    return false;
+  if (v.startsWith("vbscript:") || v.startsWith("file:")) return false;
+  return true;
+}
+function escapeAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function classKeyForTag(tag, attrs, openStack) {
+  if (tag === "aside" && "data-callout" in attrs) return "callout";
+  if (tag === "p" && "data-callout-title" in attrs) return "calloutTitle";
+  if (tag === "code" && openStack[openStack.length - 1] !== "pre")
+    return "inlineCode";
+  const known = [
+    "p",
+    "br",
+    "hr",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "pre",
+    "code",
+    "kbd",
+    "a",
+    "strong",
+    "em",
+    "u",
+    "s",
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "th",
+    "td",
+    "figure",
+    "figcaption",
+    "img",
+    "span"
+  ];
+  return known.includes(tag) ? tag : null;
+}
+function variantClass(classMap, matchKey, variant) {
+  if (!classMap?.variants || !matchKey || !variant) return void 0;
+  return classMap.variants[`${matchKey}:${variant}`];
+}
+function sanitizeAndStyle(html, options) {
+  const allowlist = options.allowlist ?? DEFAULT_ALLOWLIST;
+  const classMap = options.classMap;
+  const tokens = tokenize(html);
+  const out = [];
+  const openStack = [];
+  const skipStack = [];
+  const tableWrapperStack = [];
+  for (let tokenIdx = 0; tokenIdx < tokens.length; tokenIdx++) {
+    const token = tokens[tokenIdx];
+    if (token.type === "comment") continue;
+    if (token.type === "text") {
+      if (skipStack.length > 0 && skipStack[skipStack.length - 1].dropChildren)
+        continue;
+      out.push(token.value);
+      continue;
+    }
+    if (token.type === "open") {
+      const allowed = allowlist.includes(token.tag);
+      const dropChildren = token.tag === "script" || token.tag === "style";
+      if (!allowed) {
+        if (!token.selfClosing)
+          skipStack.push({ tag: token.tag, dropChildren });
+        continue;
+      }
+      const safeAttrs = {};
+      for (const [name, value] of Object.entries(token.attrs)) {
+        if (!isAttrAllowed(token.tag, name)) continue;
+        if (URL_ATTRS.has(name) && !isSafeUrl(value)) continue;
+        if (name === "style") {
+          const cleaned = sanitizeStyle(token.tag, value);
+          if (cleaned) safeAttrs.style = cleaned;
+          continue;
+        }
+        safeAttrs[name] = value;
+      }
+      const matchKey = classKeyForTag(token.tag, token.attrs, openStack);
+      const variant = token.attrs["data-variant"];
+      const classes = [];
+      if (safeAttrs.class) classes.push(safeAttrs.class);
+      if (matchKey && classMap?.[matchKey])
+        classes.push(classMap[matchKey]);
+      const variantCls = variantClass(classMap, matchKey, variant);
+      if (variantCls) classes.push(variantCls);
+      if (token.tag === "a") {
+        if (safeAttrs.target === "_blank" && !safeAttrs.rel)
+          safeAttrs.rel = "noreferrer noopener";
+      }
+      const merged = classes.join(" ").trim();
+      if (merged) safeAttrs.class = merged;
+      else delete safeAttrs.class;
+      const attrStr = Object.entries(safeAttrs).map(([k, v]) => `${k}="${escapeAttr(v)}"`).join(" ");
+      if (token.tag === "table") {
+        const wrapperClass = classMap?.tableWrapper;
+        if (wrapperClass) {
+          out.push(`<div class="${escapeAttr(wrapperClass)}">`);
+          tableWrapperStack.push(true);
+        } else {
+          tableWrapperStack.push(false);
+        }
+      }
+      out.push(
+        `<${token.tag}${attrStr ? " " + attrStr : ""}${token.selfClosing ? " /" : ""}>`
+      );
+      if (!token.selfClosing) openStack.push(token.tag);
+      if (token.tag === "aside" && "data-callout" in token.attrs && token.attrs["data-title"]) {
+        const title = token.attrs["data-title"];
+        let lookahead = tokenIdx + 1;
+        while (lookahead < tokens.length) {
+          const next2 = tokens[lookahead];
+          if (next2.type === "comment") {
+            lookahead++;
+            continue;
+          }
+          if (next2.type === "text" && next2.value.trim() === "") {
+            lookahead++;
+            continue;
+          }
+          break;
+        }
+        const next = tokens[lookahead];
+        const alreadyHasTitle = next && next.type === "open" && next.tag === "p" && "data-callout-title" in next.attrs;
+        if (!alreadyHasTitle) {
+          const titleClasses = [];
+          if (classMap?.calloutTitle) titleClasses.push(classMap.calloutTitle);
+          const titleVariantCls = variantClass(
+            classMap,
+            "calloutTitle",
+            token.attrs["data-variant"]
+          );
+          if (titleVariantCls) titleClasses.push(titleVariantCls);
+          const titleClassAttr = titleClasses.length ? ` class="${escapeAttr(titleClasses.join(" "))}"` : "";
+          out.push(
+            `<p data-callout-title="true"${titleClassAttr}>${escapeHtml(title)}</p>`
+          );
+        }
+      }
+      continue;
+    }
+    if (token.type === "close") {
+      if (skipStack.length > 0 && skipStack[skipStack.length - 1].tag === token.tag) {
+        skipStack.pop();
+        continue;
+      }
+      if (!allowlist.includes(token.tag)) continue;
+      const idx = openStack.lastIndexOf(token.tag);
+      if (idx === -1) continue;
+      while (openStack.length > idx + 1) {
+        const orphan = openStack.pop();
+        out.push(`</${orphan}>`);
+      }
+      openStack.pop();
+      out.push(`</${token.tag}>`);
+      if (token.tag === "table" && tableWrapperStack.pop()) {
+        out.push(`</div>`);
+      }
+    }
+  }
+  while (openStack.length > 0) {
+    const tag = openStack.pop();
+    out.push(`</${tag}>`);
+    if (tag === "table" && tableWrapperStack.pop()) {
+      out.push(`</div>`);
+    }
+  }
+  return out.join("");
+}
+
+// src/components/RichTextContent.tsx
+var DEFAULT_CLASS_MAP = {
+  variants: {
+    "figure:pullquote": "relative my-8",
+    "blockquote:pullquote": "relative italic text-lg leading-snug tracking-[-0.01em] sm:text-xl",
+    "figcaption:pullquote": "mt-4 pt-3 border-t border-current/15 not-italic text-xs uppercase tracking-[0.14em] opacity-80",
+    "span:quote-open": "mr-1 font-serif text-[1.4em] leading-none align-[-0.15em] opacity-60 select-none",
+    "span:quote-close": "ml-1 font-serif text-[1.4em] leading-none align-[-0.15em] opacity-60 select-none",
+    "span:author": "ml-1 font-semibold not-italic tracking-[0.16em] text-current"
+  }
+};
+function mergeClassMap(defaults, user) {
+  if (!user) return defaults;
+  return {
+    ...defaults,
+    ...user,
+    variants: { ...defaults.variants, ...user.variants }
+  };
+}
+var COPY_ICON_SVG = `<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
+var CHECK_ICON_SVG = `<svg viewBox="0 0 24 24" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><polyline points="20 6 9 17 4 12"></polyline></svg>`;
+var ATTRIBUTION_RE = /^(?:[—–-]+|--)\s+\S/;
+function isAttributionEl(el) {
+  if (!el) return false;
+  if (el.getAttribute("data-variant") === "attribution") return true;
+  return ATTRIBUTION_RE.test((el.textContent ?? "").trim());
+}
+function findQuoteBody(bq) {
+  const children = Array.from(bq.children);
+  if (children.length === 0) return { first: null, last: null };
+  let lastIdx = children.length - 1;
+  while (lastIdx >= 0 && isAttributionEl(children[lastIdx])) lastIdx--;
+  if (lastIdx < 0) return { first: null, last: null };
+  return { first: children[0], last: children[lastIdx] };
+}
+function enhanceBlockquotes(root) {
+  const quotes = root.querySelectorAll("blockquote");
+  quotes.forEach((bq) => {
+    if (bq.dataset.rtQuoted === "1") return;
+    if (bq.closest('figure[data-variant="pullquote"]')) return;
+    bq.dataset.rtQuoted = "1";
+    const { first, last } = findQuoteBody(bq);
+    if (!first || !last) return;
+    const open = document.createElement("span");
+    open.className = "rt-quote-open";
+    open.setAttribute("aria-hidden", "true");
+    open.textContent = "\u201C";
+    const close = document.createElement("span");
+    close.className = "rt-quote-close";
+    close.setAttribute("aria-hidden", "true");
+    close.textContent = "\u201D";
+    first.prepend(open);
+    last.append(close);
+  });
+}
+function escapeHtml2(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function preserveSpaces(html) {
+  return html.replace(/ {2,}/g, (m) => "&nbsp;".repeat(m.length));
+}
+function highlightSource(src, lang) {
+  if (lang && hljs.getLanguage(lang)) {
+    try {
+      return hljs.highlight(src, { language: lang, ignoreIllegals: true }).value;
+    } catch {
+    }
+  }
+  return escapeHtml2(src);
+}
+function highlightLine(line, lang) {
+  if (!line) return "";
+  return preserveSpaces(highlightSource(line, lang));
+}
+function highlightCodeBlock(pre) {
+  const lang = pre.dataset.language;
+  if (!lang) return;
+  const code = pre.querySelector("code");
+  if (!code) return;
+  if (code.dataset.rtHighlighted === "1") return;
+  const source = code.textContent ?? "";
+  code.innerHTML = highlightSource(source, lang);
+  code.classList.add("hljs");
+  code.dataset.rtHighlighted = "1";
+}
+var DIFF_SEPARATOR_RE = /\n?@@---@@\n?/;
+function diffLines(a, b) {
+  const n = a.length;
+  const m = b.length;
+  const dp = Array.from(
+    { length: n + 1 },
+    () => new Array(m + 1).fill(0)
+  );
+  for (let i2 = 1; i2 <= n; i2++) {
+    for (let j2 = 1; j2 <= m; j2++) {
+      dp[i2][j2] = a[i2 - 1] === b[j2 - 1] ? dp[i2 - 1][j2 - 1] + 1 : Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+    }
+  }
+  const ops = [];
+  let i = n;
+  let j = m;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      ops.unshift({ t: "eq", line: a[i - 1] });
+      i--;
+      j--;
+    } else if (dp[i - 1][j] >= dp[i][j - 1]) {
+      ops.unshift({ t: "rem", line: a[i - 1] });
+      i--;
+    } else {
+      ops.unshift({ t: "add", line: b[j - 1] });
+      j--;
+    }
+  }
+  while (i > 0) ops.unshift({ t: "rem", line: a[--i] });
+  while (j > 0) ops.unshift({ t: "add", line: b[--j] });
+  return ops;
+}
+function renderDiff(before, after, lang) {
+  const ops = diffLines(before.split("\n"), after.split("\n"));
+  const rows = [];
+  let aNo = 0;
+  let bNo = 0;
+  let k = 0;
+  while (k < ops.length) {
+    const op = ops[k];
+    if (op.t === "eq") {
+      aNo++;
+      bNo++;
+      rows.push({
+        left: { n: aNo, line: op.line, cls: "" },
+        right: { n: bNo, line: op.line, cls: "" }
+      });
+      k++;
+      continue;
+    }
+    const rems = [];
+    while (k < ops.length && ops[k].t === "rem") {
+      rems.push(ops[k].line);
+      k++;
+    }
+    const adds = [];
+    while (k < ops.length && ops[k].t === "add") {
+      adds.push(ops[k].line);
+      k++;
+    }
+    const len = Math.max(rems.length, adds.length);
+    for (let x = 0; x < len; x++) {
+      const remLine = x < rems.length ? rems[x] : null;
+      const addLine = x < adds.length ? adds[x] : null;
+      rows.push({
+        left: {
+          n: remLine !== null ? ++aNo : null,
+          line: remLine,
+          cls: remLine !== null ? "rt-diff-rem" : "rt-diff-empty"
+        },
+        right: {
+          n: addLine !== null ? ++bNo : null,
+          line: addLine,
+          cls: addLine !== null ? "rt-diff-add" : "rt-diff-empty"
+        }
+      });
+    }
+  }
+  const cell = (c, side) => {
+    const sign = side === "l" ? "-" : "+";
+    const showSign = c.cls === "rt-diff-rem" || c.cls === "rt-diff-add";
+    return `<td class="rt-diff-num">${c.n ?? ""}</td><td class="rt-diff-sign">${showSign ? sign : ""}</td><td class="rt-diff-line ${c.cls}">${c.line === null ? "" : highlightLine(c.line, lang) || "&nbsp;"}</td>`;
+  };
+  const body = rows.map((r) => `<tr>${cell(r.left, "l")}${cell(r.right, "r")}</tr>`).join("");
+  return `<table class="rt-diff-table"><tbody>${body}</tbody></table>`;
+}
+function makeCopyButton(getText, opts = {}) {
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = opts.className ?? "rt-codeblock__copy";
+  btn.setAttribute("aria-label", opts.label ?? "Copy code");
+  btn.innerHTML = COPY_ICON_SVG;
+  btn.addEventListener("click", async () => {
+    try {
+      await navigator.clipboard.writeText(getText());
+      btn.innerHTML = CHECK_ICON_SVG;
+      btn.classList.add("is-copied");
+      window.setTimeout(() => {
+        btn.innerHTML = COPY_ICON_SVG;
+        btn.classList.remove("is-copied");
+      }, 1500);
+    } catch {
+    }
+  });
+  return btn;
+}
+function buildCodeBlockLabel(pre) {
+  const filename = pre.dataset.filename;
+  if (!filename) return null;
+  const tag = document.createElement("span");
+  tag.className = "rt-codeblock__label";
+  const file = document.createElement("span");
+  file.className = "rt-codeblock__filename rt-codeblock__language";
+  file.textContent = filename;
+  tag.appendChild(file);
+  return tag;
+}
+function enhanceCodeBlocks(root) {
+  const blocks = root.querySelectorAll("pre");
+  blocks.forEach((pre) => {
+    if (pre.dataset.rtEnhanced === "1") return;
+    pre.dataset.rtEnhanced = "1";
+    pre.classList.add("rt-codeblock");
+    const variant = pre.dataset.variant;
+    if (variant === "diff") {
+      const codeEl = pre.querySelector("code");
+      const src = codeEl?.textContent ?? "";
+      const [beforeSrc = "", afterSrc = ""] = src.split(DIFF_SEPARATOR_RE);
+      pre.innerHTML = renderDiff(beforeSrc, afterSrc, pre.dataset.language);
+      const bar = document.createElement("div");
+      bar.className = "rt-diff-copy-bar";
+      const leftHalf = document.createElement("div");
+      leftHalf.className = "rt-diff-copy-half";
+      leftHalf.appendChild(
+        makeCopyButton(() => beforeSrc, {
+          className: "rt-diff-copy",
+          label: "Copy before"
+        })
+      );
+      const rightHalf = document.createElement("div");
+      rightHalf.className = "rt-diff-copy-half";
+      rightHalf.appendChild(
+        makeCopyButton(() => afterSrc, {
+          className: "rt-diff-copy",
+          label: "Copy after"
+        })
+      );
+      bar.appendChild(leftHalf);
+      bar.appendChild(rightHalf);
+      pre.prepend(bar);
+      const label2 = buildCodeBlockLabel(pre);
+      if (label2) pre.prepend(label2);
+      return;
+    }
+    if (variant === "terminal") {
+      pre.classList.add("rt-terminal");
+      const codeEl = pre.querySelector("code");
+      const source = codeEl?.textContent ?? "";
+      if (codeEl) {
+        const lang = pre.dataset.language || "sh";
+        const lines = source.split("\n");
+        codeEl.innerHTML = lines.map(
+          (line) => `<span class="rt-term-line"><span class="rt-term-prompt" aria-hidden="true">$</span> ${highlightLine(line, lang) || "&nbsp;"}</span>`
+        ).join("");
+      }
+      pre.appendChild(makeCopyButton(() => source, { label: "Copy commands" }));
+      return;
+    }
+    const label = buildCodeBlockLabel(pre);
+    if (label) pre.prepend(label);
+    pre.appendChild(
+      makeCopyButton(
+        () => pre.querySelector("code")?.textContent ?? pre.innerText
+      )
+    );
+    highlightCodeBlock(pre);
+  });
+}
+var CODEBLOCK_STYLE = `
+.rt-codeblock { position: relative; }
+.rt-codeblock[data-filename]:not([data-filename=""]) { padding-top: 2rem; }
+.rt-codeblock__label {
+  position: absolute; top: 0.45rem; left: 0.85rem;
+  display: inline-flex; align-items: center; gap: 0.5rem;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  pointer-events: none;
+}
+.rt-codeblock__filename {
+  font-size: 0.72rem; letter-spacing: 0.02em;
+  color: #d1d5db;
+}
+.rt-codeblock__sep {
+  color: #6b7280;
+  font-size: 0.72rem;
+}
+.rt-codeblock__language {
+  font-size: 0.6rem; letter-spacing: 0.08em;
+  text-transform: lowercase;
+  color: #9ca3af;
+  padding: 0.05rem 0.35rem;
+  border: 1px solid rgba(255,255,255,0.12);
+  border-radius: 0.25rem;
+}
+.rt-codeblock__copy {
+  position: absolute; top: 0.4rem; right: 0.4rem;
+  display: inline-flex; align-items: center; justify-content: center;
+  width: 1.75rem; height: 1.75rem; padding: 0;
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 0.375rem;
+  background: rgba(255,255,255,0.04);
+  color: #d1d5db;
+  cursor: pointer;
+  opacity: 0; transition: opacity 120ms ease, background 120ms ease, color 120ms ease;
+}
+.rt-codeblock:hover .rt-codeblock__copy,
+.rt-codeblock:focus-within .rt-codeblock__copy { opacity: 1; }
+.rt-codeblock__copy:hover { background: rgba(255,255,255,0.1); color: #fff; }
+.rt-codeblock__copy.is-copied { color: #34d399; opacity: 1; }
+@media (hover: none) { .rt-codeblock__copy { opacity: 1; } }
+.rt-quote-open, .rt-quote-close {
+  font-family: Georgia, "Times New Roman", serif;
+  font-size: 1.4em;
+  line-height: 0;
+  vertical-align: -0.15em;
+  opacity: 0.6;
+  user-select: none;
+}
+.rt-quote-open { margin-right: 0.15em; }
+.rt-quote-close { margin-left: 0.15em; }
+/* highlight.js theme handles .hljs-* color classes; we only override the
+   default .hljs background so the per-block chrome (dark bg, terminal,
+   diff red/green rows) wins. */
+.rt-codeblock .hljs,
+.rt-codeblock code.hljs { background: transparent; padding: 0; }
+
+/* Terminal variant ------------------------------------------------------- */
+.rt-codeblock.rt-terminal,
+.rt-codeblock[data-variant="terminal"] {
+  position: relative;
+  padding-top: 2.25rem;
+  background: #0b0b0d;
+  border: 1px solid rgba(255,255,255,0.08);
+  border-radius: 0.65rem;
+  box-shadow: 0 1px 0 rgba(255,255,255,0.04) inset,
+              0 10px 30px -10px rgba(0,0,0,0.6);
+}
+.rt-codeblock.rt-terminal::before,
+.rt-codeblock[data-variant="terminal"]::before {
+  content: "";
+  position: absolute; top: 0; left: 0; right: 0; height: 1.75rem;
+  background: linear-gradient(#1a1a1d, #141417);
+  border-bottom: 1px solid rgba(255,255,255,0.06);
+  border-radius: 0.65rem 0.65rem 0 0;
+}
+.rt-codeblock.rt-terminal::after,
+.rt-codeblock[data-variant="terminal"]::after {
+  content: "";
+  position: absolute; top: 0.55rem; left: 0.75rem;
+  width: 0.65rem; height: 0.65rem; border-radius: 50%;
+  background: #ff5f57;
+  box-shadow:
+    1.1rem 0 0 0 #febc2e,
+    2.2rem 0 0 0 #28c840;
+}
+.rt-codeblock.rt-terminal code,
+.rt-codeblock[data-variant="terminal"] code {
+  color: #d4d4d8;
+  display: block;
+}
+.rt-term-line { display: block; white-space: pre-wrap; }
+.rt-term-prompt {
+  color: #28c840;
+  font-weight: 600;
+  margin-right: 0.35em;
+  user-select: none;
+}
+
+/* Diff variant ----------------------------------------------------------- */
+.rt-codeblock[data-variant="diff"] {
+  padding: 0;
+  overflow: hidden;
+  background: #0b0b0d;
+  border: 1px solid rgba(255,255,255,0.08);
+}
+.rt-codeblock[data-variant="diff"][data-filename]:not([data-filename=""]) {
+  padding-top: 2rem;
+}
+.rt-diff-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  font-size: 0.78rem;
+  line-height: 1.55;
+  color: #e5e7eb;
+  table-layout: fixed;
+}
+.rt-diff-table colgroup { display: none; }
+.rt-diff-table td {
+  padding: 0 0.5rem;
+  vertical-align: top;
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+.rt-diff-table td.rt-diff-num {
+  width: 2.25rem;
+  text-align: right;
+  color: rgba(156,163,175,0.55);
+  user-select: none;
+  background: rgba(255,255,255,0.02);
+}
+.rt-diff-table td.rt-diff-sign {
+  width: 0.85rem;
+  text-align: center;
+  user-select: none;
+  color: rgba(255,255,255,0.45);
+}
+.rt-diff-table td.rt-diff-line.rt-diff-rem {
+  background: rgba(248,113,113,0.12);
+  color: #fecaca;
+}
+.rt-diff-table tr:has(td.rt-diff-rem) td.rt-diff-sign:first-of-type {
+  color: #f87171;
+}
+.rt-diff-table td.rt-diff-line.rt-diff-add {
+  background: rgba(74,222,128,0.12);
+  color: #bbf7d0;
+}
+.rt-diff-table tr:has(td.rt-diff-add) td.rt-diff-sign + td + td + td.rt-diff-sign {
+  color: #4ade80;
+}
+.rt-diff-table td.rt-diff-line.rt-diff-empty {
+  background: rgba(255,255,255,0.025);
+}
+.rt-diff-table tr td:nth-child(4) { border-left: 1px solid rgba(255,255,255,0.06); }
+.rt-diff-copy-bar {
+  position: absolute; top: 0.4rem; left: 0; right: 0; z-index: 2;
+  display: grid; grid-template-columns: 1fr 1fr;
+  pointer-events: none;
+}
+.rt-diff-copy-half {
+  display: flex;
+  justify-content: flex-end;
+  padding-right: 0.4rem;
+}
+.rt-diff-copy {
+  pointer-events: auto;
+  display: inline-flex; align-items: center; justify-content: center;
+  width: 1.6rem; height: 1.6rem; padding: 0;
+  border: 1px solid rgba(255,255,255,0.1);
+  border-radius: 0.375rem;
+  background: rgba(20,20,23,0.85);
+  color: #d1d5db;
+  cursor: pointer;
+  opacity: 0; transition: opacity 120ms ease, background 120ms ease, color 120ms ease;
+}
+.rt-codeblock[data-variant="diff"]:hover .rt-diff-copy,
+.rt-codeblock[data-variant="diff"]:focus-within .rt-diff-copy { opacity: 1; }
+.rt-diff-copy:hover { background: rgba(0,0,0,0.92); color: #fff; }
+.rt-diff-copy.is-copied { color: #34d399; opacity: 1; }
+@media (hover: none) { .rt-diff-copy { opacity: 1; } }
+`;
+var styleInjected = false;
+function ensureCodeBlockStyles() {
+  if (styleInjected || typeof document === "undefined") return;
+  if (document.getElementById("rt-codeblock-style")) {
+    styleInjected = true;
+    return;
+  }
+  const tag = document.createElement("style");
+  tag.id = "rt-codeblock-style";
+  tag.textContent = CODEBLOCK_STYLE;
+  document.head.appendChild(tag);
+  styleInjected = true;
+}
+function RichTextContent({
+  html,
+  classMap,
+  as = "div",
+  className,
+  onReady,
+  contentRef
+}) {
+  const merged = useMemo(
+    () => mergeClassMap(DEFAULT_CLASS_MAP, classMap),
+    [classMap]
+  );
+  const safe = useMemo(
+    () => parseRichText(html, { classMap: merged }),
+    [html, merged]
+  );
+  const ref = useRef(null);
+  useEffect(() => {
+    ensureCodeBlockStyles();
+    const root = ref.current;
+    if (!root) return;
+    if (contentRef) contentRef.current = root;
+    const apply = () => {
+      mo.disconnect();
+      enhanceCodeBlocks(root);
+      enhanceBlockquotes(root);
+      onReady?.(root);
+      mo.observe(root, { childList: true, subtree: true });
+    };
+    let raf = 0;
+    const mo = new MutationObserver(() => {
+      if (raf) return;
+      raf = requestAnimationFrame(() => {
+        raf = 0;
+        apply();
+      });
+    });
+    apply();
+    return () => {
+      mo.disconnect();
+      if (raf) cancelAnimationFrame(raf);
+    };
+  }, [safe, onReady, contentRef]);
+  return createElement(as, {
+    ref,
+    className,
+    dangerouslySetInnerHTML: { __html: safe }
+  });
+}
+
+// src/utils/extractHeadings.ts
+var DEFAULT_LEVELS = [2, 3];
+function slugify(text) {
+  return text.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function decodeBasicEntities(s) {
+  return s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'");
+}
+function stripTags(s) {
+  return decodeBasicEntities(s.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+}
+function uniqueId(base, used) {
+  const seed = base || "section";
+  const n = used.get(seed) ?? 0;
+  used.set(seed, n + 1);
+  return n === 0 ? seed : `${seed}-${n}`;
+}
+function extractHeadingsFromHtml(html, options = {}) {
+  if (!html) return [];
+  const levels = options.levels ?? DEFAULT_LEVELS;
+  const slug = options.slugify ?? slugify;
+  const used = /* @__PURE__ */ new Map();
+  const out = [];
+  const re = /<h([1-6])\b([^>]*)>([\s\S]*?)<\/h\1>/gi;
+  let m;
+  let i = 0;
+  while ((m = re.exec(html)) !== null) {
+    const level = Number(m[1]);
+    if (!levels.includes(level)) continue;
+    const attrs = m[2] ?? "";
+    const inner = m[3] ?? "";
+    const text = stripTags(inner);
+    if (!text) continue;
+    const explicitIdMatch = attrs.match(/\bid\s*=\s*("([^"]*)"|'([^']*)'|(\S+))/i);
+    let id;
+    if (explicitIdMatch) {
+      id = explicitIdMatch[2] ?? explicitIdMatch[3] ?? explicitIdMatch[4] ?? "";
+      if (id) used.set(id, (used.get(id) ?? 0) + 1);
+    } else {
+      id = uniqueId(slug(text, i), used);
+    }
+    out.push({ id, text, level });
+    i++;
+  }
+  return out;
+}
+function extractHeadingsFromElement(root, options = {}) {
+  const levels = options.levels ?? DEFAULT_LEVELS;
+  const slug = options.slugify ?? slugify;
+  const selector = levels.map((l) => `h${l}`).join(",");
+  const nodes = root.querySelectorAll(selector);
+  const used = /* @__PURE__ */ new Map();
+  nodes.forEach((n) => {
+    if (n.id) used.set(n.id, (used.get(n.id) ?? 0) + 1);
+  });
+  const out = [];
+  let i = 0;
+  nodes.forEach((node) => {
+    const level = Number(node.tagName.slice(1));
+    const text = (node.textContent ?? "").replace(/\s+/g, " ").trim();
+    if (!text) return;
+    if (!node.id) {
+      node.id = uniqueId(slug(text, i), used);
+    }
+    if (options.scrollMarginTop != null) {
+      node.style.scrollMarginTop = `${options.scrollMarginTop}px`;
+    }
+    out.push({ id: node.id, text, level });
+    i++;
+  });
+  return out;
+}
+
+// src/hooks/useTableOfContents.tsx
+function useTableOfContents(ref, options = {}) {
+  const {
+    levels,
+    contentKey = null,
+    scrollMarginTop = 24,
+    activationOffset = 96
+  } = options;
+  const [items, setItems] = useState([]);
+  const [activeId, setActiveId] = useState("");
+  useEffect(() => {
+    const root = ref.current;
+    if (!root) {
+      setItems([]);
+      setActiveId("");
+      return;
+    }
+    let raf = 0;
+    const collect = () => {
+      const next = extractHeadingsFromElement(root, {
+        levels,
+        scrollMarginTop
+      });
+      setItems(next);
+      setActiveId(
+        (prev) => next.some((h) => h.id === prev) ? prev : next[0]?.id ?? ""
+      );
+    };
+    raf = requestAnimationFrame(collect);
+    const mo = new MutationObserver(() => {
+      if (raf) cancelAnimationFrame(raf);
+      raf = requestAnimationFrame(collect);
+    });
+    mo.observe(root, { childList: true, subtree: true, characterData: true });
+    return () => {
+      mo.disconnect();
+      if (raf) cancelAnimationFrame(raf);
+    };
+  }, [ref, contentKey, levels, scrollMarginTop]);
+  useEffect(() => {
+    if (items.length === 0) return;
+    const targets = items.map((it) => document.getElementById(it.id)).filter((el) => el !== null);
+    if (targets.length === 0) return;
+    let raf = 0;
+    const compute = () => {
+      raf = 0;
+      let activeIdx = 0;
+      for (let i = 0; i < items.length; i++) {
+        const el = document.getElementById(items[i].id);
+        if (!el) continue;
+        if (el.getBoundingClientRect().top - activationOffset <= 0) {
+          activeIdx = i;
+        } else {
+          break;
+        }
+      }
+      const scroller = document.scrollingElement || document.documentElement;
+      const scrollY = window.scrollY;
+      const viewportH = window.innerHeight;
+      const atBottom = scrollY + viewportH >= scroller.scrollHeight - 2;
+      if (atBottom) {
+        for (let i = items.length - 1; i > activeIdx; i--) {
+          const el = document.getElementById(items[i].id);
+          if (el && el.getBoundingClientRect().top < viewportH) {
+            activeIdx = i;
+            break;
+          }
+        }
+      }
+      setActiveId(items[activeIdx].id);
+    };
+    const schedule = () => {
+      if (raf) return;
+      raf = requestAnimationFrame(compute);
+    };
+    const io = new IntersectionObserver(schedule, {
+      rootMargin: `-${activationOffset}px 0px -${Math.max(0, window.innerHeight - activationOffset - 1)}px 0px`,
+      threshold: 0
+    });
+    targets.forEach((t) => io.observe(t));
+    window.addEventListener("resize", schedule, { passive: true });
+    compute();
+    return () => {
+      io.disconnect();
+      window.removeEventListener("resize", schedule);
+      if (raf) cancelAnimationFrame(raf);
+    };
+  }, [items, activationOffset]);
+  return { items, activeId };
+}
+
+export { AsteroidCMSProvider, RichTextContent, extractHeadingsFromElement, extractHeadingsFromHtml, slugify, useAsteroidCMSConfig, useCmsContent, useCmsImage, useCmsMutate, useTableOfContents };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map