@seoengine.ai/next-llm-ready 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1609 @@
+'use strict';
+
+var React = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var server = require('next/server');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/components/CopyButton.tsx
+
+// src/utils/clipboard.ts
+async function copyToClipboard(text) {
+  if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch (err) {
+      console.warn("Clipboard API failed, using fallback:", err);
+    }
+  }
+  return fallbackCopyToClipboard(text);
+}
+function fallbackCopyToClipboard(text) {
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-9999px";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+  textarea.style.pointerEvents = "none";
+  textarea.style.fontSize = "16px";
+  document.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+  try {
+    const successful = document.execCommand("copy");
+    document.body.removeChild(textarea);
+    return successful;
+  } catch (err) {
+    console.error("Fallback copy failed:", err);
+    document.body.removeChild(textarea);
+    return false;
+  }
+}
+
+// src/utils/download.ts
+var defaultOptions = {
+  filename: "content",
+  extension: "md",
+  includeMetadata: false
+};
+function downloadAsFile(content, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const filename = sanitizeFilename(opts.filename || "content");
+  const fullFilename = `${filename}.${opts.extension}`;
+  const mimeType = opts.extension === "md" ? "text/markdown" : "text/plain";
+  const blob = new Blob([content], { type: `${mimeType};charset=utf-8` });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = fullFilename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function sanitizeFilename(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").substring(0, 100);
+}
+function generateFilename(title) {
+  const base = sanitizeFilename(title);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `${base}-${date}`;
+}
+
+// src/utils/html-to-markdown.ts
+var defaultOptions2 = {
+  preserveLineBreaks: true,
+  convertImages: true,
+  convertLinks: true,
+  stripScripts: true,
+  customHandlers: {}
+};
+function htmlToMarkdown(html, options = {}) {
+  const opts = { ...defaultOptions2, ...options };
+  if (typeof window === "undefined") {
+    return serverSideConvert(html, opts);
+  }
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  return convertNode(doc.body, opts);
+}
+function serverSideConvert(html, opts) {
+  let markdown = html;
+  if (opts.stripScripts) {
+    markdown = markdown.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
+    markdown = markdown.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+  }
+  markdown = markdown.replace(/<h1[^>]*>(.*?)<\/h1>/gi, "\n# $1\n");
+  markdown = markdown.replace(/<h2[^>]*>(.*?)<\/h2>/gi, "\n## $1\n");
+  markdown = markdown.replace(/<h3[^>]*>(.*?)<\/h3>/gi, "\n### $1\n");
+  markdown = markdown.replace(/<h4[^>]*>(.*?)<\/h4>/gi, "\n#### $1\n");
+  markdown = markdown.replace(/<h5[^>]*>(.*?)<\/h5>/gi, "\n##### $1\n");
+  markdown = markdown.replace(/<h6[^>]*>(.*?)<\/h6>/gi, "\n###### $1\n");
+  markdown = markdown.replace(/<(strong|b)[^>]*>(.*?)<\/\1>/gi, "**$2**");
+  markdown = markdown.replace(/<(em|i)[^>]*>(.*?)<\/\1>/gi, "*$2*");
+  if (opts.convertLinks) {
+    markdown = markdown.replace(/<a[^>]*href=["']([^"']*)["'][^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  }
+  if (opts.convertImages) {
+    markdown = markdown.replace(
+      /<img[^>]*src=["']([^"']*)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi,
+      "![$2]($1)"
+    );
+    markdown = markdown.replace(
+      /<img[^>]*alt=["']([^"']*)["'][^>]*src=["']([^"']*)["'][^>]*\/?>/gi,
+      "![$1]($2)"
+    );
+    markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*\/?>/gi, "![]($1)");
+  }
+  markdown = markdown.replace(/<ul[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ul>/gi, "\n");
+  markdown = markdown.replace(/<ol[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ol>/gi, "\n");
+  markdown = markdown.replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n");
+  markdown = markdown.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, (_, content) => {
+    return "\n> " + content.trim().replace(/\n/g, "\n> ") + "\n";
+  });
+  markdown = markdown.replace(/<pre[^>]*><code[^>]*>(.*?)<\/code><\/pre>/gis, "\n```\n$1\n```\n");
+  markdown = markdown.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  markdown = markdown.replace(/<p[^>]*>(.*?)<\/p>/gis, "\n$1\n");
+  markdown = markdown.replace(/<br\s*\/?>/gi, "\n");
+  markdown = markdown.replace(/<hr[^>]*\/?>/gi, "\n---\n");
+  markdown = markdown.replace(/<[^>]+>/g, "");
+  markdown = decodeHTMLEntities(markdown);
+  markdown = markdown.replace(/\n{3,}/g, "\n\n");
+  markdown = markdown.trim();
+  return markdown;
+}
+function convertNode(node, opts) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent || "";
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return "";
+  }
+  const element = node;
+  const tagName = element.tagName.toLowerCase();
+  if (opts.customHandlers?.[tagName]) {
+    return opts.customHandlers[tagName](element);
+  }
+  if (opts.stripScripts && (tagName === "script" || tagName === "style")) {
+    return "";
+  }
+  const childContent = Array.from(element.childNodes).map((child) => convertNode(child, opts)).join("");
+  switch (tagName) {
+    case "h1":
+      return `
+# ${childContent.trim()}
+`;
+    case "h2":
+      return `
+## ${childContent.trim()}
+`;
+    case "h3":
+      return `
+### ${childContent.trim()}
+`;
+    case "h4":
+      return `
+#### ${childContent.trim()}
+`;
+    case "h5":
+      return `
+##### ${childContent.trim()}
+`;
+    case "h6":
+      return `
+###### ${childContent.trim()}
+`;
+    case "p":
+      return `
+${childContent.trim()}
+`;
+    case "br":
+      return opts.preserveLineBreaks ? "\n" : " ";
+    case "strong":
+    case "b":
+      return `**${childContent}**`;
+    case "em":
+    case "i":
+      return `*${childContent}*`;
+    case "u":
+      return `_${childContent}_`;
+    case "s":
+    case "strike":
+    case "del":
+      return `~~${childContent}~~`;
+    case "a":
+      if (opts.convertLinks) {
+        const href = element.getAttribute("href") || "";
+        return `[${childContent}](${href})`;
+      }
+      return childContent;
+    case "img":
+      if (opts.convertImages) {
+        const src = element.getAttribute("src") || "";
+        const alt = element.getAttribute("alt") || "";
+        return `![${alt}](${src})`;
+      }
+      return "";
+    case "ul":
+      return `
+${childContent}
+`;
+    case "ol":
+      return `
+${childContent}
+`;
+    case "li":
+      return `- ${childContent.trim()}
+`;
+    case "blockquote":
+      return `
+> ${childContent.trim().replace(/\n/g, "\n> ")}
+`;
+    case "pre":
+      const codeElement = element.querySelector("code");
+      const lang = codeElement?.className.match(/language-(\w+)/)?.[1] || "";
+      const code = codeElement?.textContent || childContent;
+      return `
+\`\`\`${lang}
+${code.trim()}
+\`\`\`
+`;
+    case "code":
+      if (element.parentElement?.tagName.toLowerCase() === "pre") {
+        return childContent;
+      }
+      return `\`${childContent}\``;
+    case "hr":
+      return "\n---\n";
+    case "table":
+      return convertTable(element);
+    case "div":
+    case "section":
+    case "article":
+    case "main":
+    case "aside":
+    case "header":
+    case "footer":
+    case "nav":
+      return childContent;
+    default:
+      return childContent;
+  }
+}
+function convertTable(table) {
+  const rows = table.querySelectorAll("tr");
+  if (rows.length === 0) return "";
+  let markdown = "\n";
+  let headerProcessed = false;
+  rows.forEach((row, index) => {
+    const cells = row.querySelectorAll("th, td");
+    const rowContent = Array.from(cells).map((cell) => cell.textContent?.trim() || "").join(" | ");
+    markdown += `| ${rowContent} |
+`;
+    if (!headerProcessed && (row.querySelector("th") || index === 0)) {
+      const separator = Array.from(cells).map(() => "---").join(" | ");
+      markdown += `| ${separator} |
+`;
+      headerProcessed = true;
+    }
+  });
+  return markdown + "\n";
+}
+function decodeHTMLEntities(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&mdash;": "\u2014",
+    "&ndash;": "\u2013",
+    "&hellip;": "\u2026",
+    "&copy;": "\xA9",
+    "&reg;": "\xAE",
+    "&trade;": "\u2122"
+  };
+  let result = text;
+  for (const [entity, char] of Object.entries(entities)) {
+    result = result.replace(new RegExp(entity, "g"), char);
+  }
+  result = result.replace(/&#(\d+);/g, (_, num) => String.fromCharCode(parseInt(num, 10)));
+  result = result.replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+  return result;
+}
+function countWords(text) {
+  return text.replace(/[^\w\s]/g, "").split(/\s+/).filter((word) => word.length > 0).length;
+}
+function calculateReadingTime(text, wordsPerMinute = 200) {
+  const words = countWords(text);
+  return Math.ceil(words / wordsPerMinute);
+}
+
+// src/hooks/use-llm-copy.ts
+function generateMarkdownFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  if (content.promptPrefix?.trim()) {
+    parts.push(content.promptPrefix.trim());
+    parts.push("");
+  }
+  parts.push(`# ${content.title}`);
+  parts.push("");
+  if (content.excerpt) {
+    parts.push(`> ${content.excerpt}`);
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push(`- **Source**: ${content.url}`);
+  if (content.date) {
+    parts.push(`- **Date**: ${content.date}`);
+  }
+  if (content.author) {
+    parts.push(`- **Author**: ${content.author}`);
+  }
+  if (content.categories?.length) {
+    parts.push(`- **Categories**: ${content.categories.join(", ")}`);
+  }
+  if (content.tags?.length) {
+    parts.push(`- **Tags**: ${content.tags.join(", ")}`);
+  }
+  parts.push("---");
+  parts.push("");
+  if (content.content) {
+    const contentMarkdown = content.content.includes("<") && content.content.includes(">") ? htmlToMarkdown(content.content) : content.content;
+    parts.push(contentMarkdown);
+  }
+  return parts.join("\n").trim();
+}
+function useLLMCopy(options) {
+  const [isCopying, setIsCopying] = React.useState(false);
+  const [isSuccess, setIsSuccess] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const markdown = React.useMemo(() => {
+    return generateMarkdownFromContent(options.content);
+  }, [options.content]);
+  const trackEvent = React.useCallback(
+    (action) => {
+      if (options.onAnalytics) {
+        const contentId = typeof options.content === "string" ? void 0 : options.content.url;
+        options.onAnalytics({
+          action,
+          contentId,
+          url: typeof window !== "undefined" ? window.location.href : void 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    },
+    [options]
+  );
+  const copy = React.useCallback(async () => {
+    setIsCopying(true);
+    setError(null);
+    try {
+      const success = await copyToClipboard(markdown);
+      if (success) {
+        setIsSuccess(true);
+        trackEvent("copy");
+        options.onSuccess?.("copy");
+        setTimeout(() => setIsSuccess(false), 2e3);
+        return true;
+      } else {
+        throw new Error("Failed to copy to clipboard");
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Copy failed");
+      setError(error2);
+      options.onError?.(error2);
+      return false;
+    } finally {
+      setIsCopying(false);
+    }
+  }, [markdown, options, trackEvent]);
+  const view = React.useCallback(() => {
+    trackEvent("view");
+    options.onSuccess?.("view");
+    return markdown;
+  }, [markdown, options, trackEvent]);
+  const download = React.useCallback(
+    (filename) => {
+      const title = typeof options.content === "string" ? "content" : options.content.title;
+      downloadAsFile(markdown, {
+        filename: filename || generateFilename(title),
+        extension: "md"
+      });
+      trackEvent("download");
+      options.onSuccess?.("download");
+    },
+    [markdown, options, trackEvent]
+  );
+  return {
+    copy,
+    view,
+    download,
+    markdown,
+    isCopying,
+    isSuccess,
+    error
+  };
+}
+function CopyButton({
+  content,
+  text = "Copy",
+  position = "inline",
+  keyboardShortcut = true,
+  className = "",
+  toastMessage = "Copied!",
+  toastDuration = 2e3,
+  onCopy,
+  onError,
+  onAnalytics,
+  style,
+  disabled = false
+}) {
+  const [showToast, setShowToast] = React.useState(false);
+  const { copy, isCopying, isSuccess, error } = useLLMCopy({
+    content,
+    onSuccess: (action) => {
+      setShowToast(true);
+      setTimeout(() => setShowToast(false), toastDuration);
+      onCopy?.(action);
+    },
+    onError,
+    onAnalytics
+  });
+  React__default.default.useEffect(() => {
+    if (!keyboardShortcut) return;
+    const handleKeyDown = (e) => {
+      const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+      const modKey = isMac ? e.metaKey : e.ctrlKey;
+      if (modKey && e.shiftKey && e.key.toLowerCase() === "c") {
+        e.preventDefault();
+        copy();
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [keyboardShortcut, copy]);
+  const buttonClasses = [
+    "llm-ready-copy-btn",
+    `llm-ready-position-${position}`,
+    isCopying && "llm-ready-copying",
+    isSuccess && "llm-ready-success",
+    error && "llm-ready-error",
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-container", style, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: buttonClasses,
+        onClick: copy,
+        disabled: disabled || isCopying,
+        "aria-label": text,
+        title: keyboardShortcut ? `${text} (${navigator.platform.includes("Mac") ? "\u2318" : "Ctrl"}+Shift+C)` : text,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              width: "16",
+              height: "16",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              className: "llm-ready-icon",
+              children: isSuccess ? /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "20 6 9 17 4 12" }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+                /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+              ] })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-btn-text", children: isSuccess ? toastMessage : text })
+        ]
+      }
+    ),
+    showToast && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "llm-ready-toast llm-ready-toast--visible", role: "status", "aria-live": "polite", children: toastMessage })
+  ] });
+}
+var defaultMenuItems = [
+  {
+    id: "copy",
+    label: "Copy to clipboard",
+    action: "copy",
+    icon: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+    ] }),
+    shortcut: "\u2318+Shift+C"
+  },
+  {
+    id: "view",
+    label: "View markdown",
+    action: "view",
+    icon: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" }),
+      /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "3" })
+    ] })
+  },
+  {
+    id: "download",
+    label: "Download .md file",
+    action: "download",
+    icon: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" }),
+      /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "7 10 12 15 17 10" }),
+      /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", y1: "15", x2: "12", y2: "3" })
+    ] })
+  }
+];
+function CopyDropdown({
+  content,
+  text = "Copy",
+  menuItems = defaultMenuItems,
+  position = "inline",
+  keyboardShortcut = true,
+  className = "",
+  toastMessage = "Copied!",
+  toastDuration = 2e3,
+  onCopy,
+  onError,
+  onAnalytics,
+  style,
+  disabled = false
+}) {
+  const [isOpen, setIsOpen] = React.useState(false);
+  const [showToast, setShowToast] = React.useState(false);
+  const [showModal, setShowModal] = React.useState(false);
+  const containerRef = React.useRef(null);
+  const dropdownRef = React.useRef(null);
+  const { copy, view, download, markdown, isCopying, isSuccess } = useLLMCopy({
+    content,
+    onSuccess: (action) => {
+      if (action === "copy") {
+        setShowToast(true);
+        setTimeout(() => setShowToast(false), toastDuration);
+      }
+      onCopy?.(action);
+    },
+    onError,
+    onAnalytics
+  });
+  React.useEffect(() => {
+    const handleClickOutside = (e) => {
+      if (containerRef.current && !containerRef.current.contains(e.target)) {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("click", handleClickOutside);
+    return () => document.removeEventListener("click", handleClickOutside);
+  }, []);
+  React.useEffect(() => {
+    if (!keyboardShortcut) return;
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape" && isOpen) {
+        setIsOpen(false);
+        return;
+      }
+      const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+      const modKey = isMac ? e.metaKey : e.ctrlKey;
+      if (modKey && e.shiftKey && e.key.toLowerCase() === "c") {
+        e.preventDefault();
+        copy();
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [keyboardShortcut, copy, isOpen]);
+  const handleItemClick = React.useCallback(
+    (item) => {
+      setIsOpen(false);
+      if (typeof item.action === "function") {
+        item.action();
+        return;
+      }
+      switch (item.action) {
+        case "copy":
+          copy();
+          break;
+        case "view":
+          view();
+          setShowModal(true);
+          break;
+        case "download":
+          download();
+          break;
+      }
+    },
+    [copy, view, download]
+  );
+  const handleDropdownKeyDown = React.useCallback(
+    (e) => {
+      if (!isOpen) return;
+      const items = dropdownRef.current?.querySelectorAll("button");
+      if (!items) return;
+      const currentIndex = Array.from(items).indexOf(document.activeElement);
+      switch (e.key) {
+        case "ArrowDown":
+          e.preventDefault();
+          const nextIndex = currentIndex < items.length - 1 ? currentIndex + 1 : 0;
+          items[nextIndex]?.focus();
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          const prevIndex = currentIndex > 0 ? currentIndex - 1 : items.length - 1;
+          items[prevIndex]?.focus();
+          break;
+        case "Escape":
+          setIsOpen(false);
+          break;
+      }
+    },
+    [isOpen]
+  );
+  const containerClasses = [
+    "llm-ready-container",
+    `llm-ready-position-${position}`,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: containerRef, className: containerClasses, style, children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-btn-group", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "button",
+          {
+            type: "button",
+            className: `llm-ready-copy-btn ${isCopying ? "llm-ready-copying" : ""} ${isSuccess ? "llm-ready-success" : ""}`,
+            onClick: copy,
+            disabled: disabled || isCopying,
+            "aria-label": text,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "svg",
+                {
+                  width: "16",
+                  height: "16",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  className: "llm-ready-icon",
+                  children: isSuccess ? /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "20 6 9 17 4 12" }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                    /* @__PURE__ */ jsxRuntime.jsx("rect", { x: "9", y: "9", width: "13", height: "13", rx: "2", ry: "2" }),
+                    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" })
+                  ] })
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-btn-text", children: isSuccess ? toastMessage : text })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "llm-ready-dropdown-btn",
+            onClick: () => setIsOpen(!isOpen),
+            "aria-expanded": isOpen,
+            "aria-haspopup": "menu",
+            "aria-label": "More options",
+            disabled,
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "svg",
+              {
+                width: "16",
+                height: "16",
+                viewBox: "0 0 24 24",
+                fill: "none",
+                stroke: "currentColor",
+                strokeWidth: "2",
+                children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "6 9 12 15 18 9" })
+              }
+            )
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          ref: dropdownRef,
+          className: `llm-ready-dropdown ${isOpen ? "llm-ready-dropdown--open" : ""}`,
+          role: "menu",
+          "aria-hidden": !isOpen,
+          onKeyDown: handleDropdownKeyDown,
+          children: menuItems.map((item) => /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              type: "button",
+              className: "llm-ready-dropdown-item",
+              role: "menuitem",
+              onClick: () => handleItemClick(item),
+              tabIndex: isOpen ? 0 : -1,
+              children: [
+                item.icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-dropdown-icon", children: item.icon }),
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-dropdown-label", children: item.label }),
+                item.shortcut && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-dropdown-shortcut", children: item.shortcut })
+              ]
+            },
+            item.id
+          ))
+        }
+      ),
+      showToast && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "llm-ready-toast llm-ready-toast--visible", role: "status", children: toastMessage })
+    ] }),
+    showModal && /* @__PURE__ */ jsxRuntime.jsx(
+      MarkdownModal,
+      {
+        content: markdown,
+        onClose: () => setShowModal(false),
+        onCopy: copy,
+        onDownload: download
+      }
+    )
+  ] });
+}
+function MarkdownModal({
+  content,
+  onClose,
+  onCopy,
+  onDownload
+}) {
+  const modalRef = React.useRef(null);
+  React.useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [onClose]);
+  React.useEffect(() => {
+    const modal = modalRef.current;
+    if (!modal) return;
+    const focusable = modal.querySelectorAll(
+      'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+    );
+    const first = focusable[0];
+    const last = focusable[focusable.length - 1];
+    first?.focus();
+    const handleTab = (e) => {
+      if (e.key !== "Tab") return;
+      if (e.shiftKey && document.activeElement === first) {
+        e.preventDefault();
+        last?.focus();
+      } else if (!e.shiftKey && document.activeElement === last) {
+        e.preventDefault();
+        first?.focus();
+      }
+    };
+    modal.addEventListener("keydown", handleTab);
+    return () => modal.removeEventListener("keydown", handleTab);
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-modal", role: "dialog", "aria-modal": "true", "aria-label": "Markdown content", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "llm-ready-modal-backdrop", onClick: onClose }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { ref: modalRef, className: "llm-ready-modal-content", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-modal-header", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("h2", { className: "llm-ready-modal-title", children: "Markdown Content" }),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            className: "llm-ready-modal-close",
+            onClick: onClose,
+            "aria-label": "Close modal",
+            children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+              /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+            ] })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "llm-ready-modal-body", children: /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "llm-ready-markdown-content", children: content }) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-modal-footer", children: [
+        /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "llm-ready-btn-secondary", onClick: onClose, children: "Close" }),
+        /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "llm-ready-btn-secondary", onClick: onDownload, children: "Download" }),
+        /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", className: "llm-ready-btn-primary", onClick: onCopy, children: "Copy" })
+      ] })
+    ] })
+  ] });
+}
+function useTOC(options) {
+  const {
+    contentRef,
+    levels = ["h2", "h3", "h4"],
+    rootMargin = "-100px 0px -80% 0px",
+    threshold = 0
+  } = options;
+  const [headings, setHeadings] = React.useState([]);
+  const [activeId, setActiveId] = React.useState(null);
+  React.useEffect(() => {
+    if (!contentRef?.current) return;
+    const container = contentRef.current;
+    const selector = levels.join(", ");
+    const elements = container.querySelectorAll(selector);
+    const extracted = [];
+    let index = 0;
+    elements.forEach((el) => {
+      const tagName = el.tagName.toLowerCase();
+      const level = parseInt(tagName.charAt(1), 10);
+      const text = el.textContent?.trim() || "";
+      let id = el.id;
+      if (!id) {
+        id = generateHeadingId(text, index);
+        el.id = id;
+      }
+      extracted.push({ id, text, level });
+      index++;
+    });
+    setHeadings(extracted);
+  }, [contentRef, levels]);
+  React.useEffect(() => {
+    if (!contentRef?.current || headings.length === 0) return;
+    const container = contentRef.current;
+    const observerOptions = {
+      root: null,
+      rootMargin,
+      threshold
+    };
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          setActiveId(entry.target.id);
+        }
+      });
+    }, observerOptions);
+    headings.forEach((heading) => {
+      const element = container.querySelector(`#${CSS.escape(heading.id)}`);
+      if (element) {
+        observer.observe(element);
+      }
+    });
+    return () => observer.disconnect();
+  }, [contentRef, headings, rootMargin, threshold]);
+  const scrollTo = React.useCallback((id) => {
+    const element = document.getElementById(id);
+    if (element) {
+      element.scrollIntoView({ behavior: "smooth", block: "start" });
+      setActiveId(id);
+      if (typeof window !== "undefined") {
+        window.history.pushState(null, "", `#${id}`);
+      }
+    }
+  }, []);
+  return { headings, activeId, scrollTo };
+}
+function generateHeadingId(text, index) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").substring(0, 50);
+  return slug || `heading-${index}`;
+}
+function buildNestedTOC(headings) {
+  if (headings.length === 0) return [];
+  const result = [];
+  const stack = [];
+  for (const heading of headings) {
+    const item = { ...heading, children: [] };
+    while (stack.length > 0 && stack[stack.length - 1].level >= heading.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      result.push(item);
+    } else {
+      const parent = stack[stack.length - 1].heading;
+      if (!parent.children) parent.children = [];
+      parent.children.push(item);
+    }
+    stack.push({ heading: item, level: heading.level });
+  }
+  return result;
+}
+function useTOCKeyboard(headings, activeId, scrollTo) {
+  React.useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (headings.length === 0) return;
+      const currentIndex = headings.findIndex((h) => h.id === activeId);
+      if (e.key === "ArrowDown" && e.altKey) {
+        e.preventDefault();
+        const nextIndex = Math.min(currentIndex + 1, headings.length - 1);
+        scrollTo(headings[nextIndex].id);
+      } else if (e.key === "ArrowUp" && e.altKey) {
+        e.preventDefault();
+        const prevIndex = Math.max(currentIndex - 1, 0);
+        scrollTo(headings[prevIndex].id);
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [headings, activeId, scrollTo]);
+}
+function TOC({
+  content,
+  contentRef,
+  headings: providedHeadings,
+  position = "right",
+  levels = ["h2", "h3", "h4"],
+  title = "On This Page",
+  sticky = true,
+  stickyOffset = 80,
+  className = "",
+  smoothScroll = true,
+  highlightActive = true,
+  collapsible = true,
+  defaultCollapsed = false,
+  style
+}) {
+  const [isCollapsed, setIsCollapsed] = React.useState(defaultCollapsed);
+  const { headings: dynamicHeadings, activeId, scrollTo } = useTOC({
+    contentRef: contentRef || { current: null },
+    levels
+  });
+  const headings = providedHeadings || dynamicHeadings;
+  useTOCKeyboard(headings, activeId, scrollTo);
+  const handleClick = React.useCallback(
+    (e, id) => {
+      e.preventDefault();
+      if (smoothScroll) {
+        scrollTo(id);
+      } else {
+        const element = document.getElementById(id);
+        if (element) {
+          element.scrollIntoView();
+          window.history.pushState(null, "", `#${id}`);
+        }
+      }
+    },
+    [scrollTo, smoothScroll]
+  );
+  if (headings.length === 0) {
+    return null;
+  }
+  const tocClasses = [
+    "llm-ready-toc",
+    `llm-ready-toc-${position}`,
+    sticky && "llm-ready-toc-sticky",
+    isCollapsed && "llm-ready-toc-collapsed",
+    className
+  ].filter(Boolean).join(" ");
+  const tocStyle = {
+    ...style,
+    ...sticky && { top: stickyOffset }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs("nav", { className: tocClasses, style: tocStyle, "aria-label": "Table of contents", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-toc-header", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "llm-ready-toc-title", children: title }),
+      collapsible && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          className: "llm-ready-toc-toggle",
+          onClick: () => setIsCollapsed(!isCollapsed),
+          "aria-expanded": !isCollapsed,
+          "aria-label": isCollapsed ? "Expand table of contents" : "Collapse table of contents",
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            "svg",
+            {
+              width: "16",
+              height: "16",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              style: { transform: isCollapsed ? "rotate(180deg)" : "none" },
+              children: /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "6 9 12 15 18 9" })
+            }
+          )
+        }
+      )
+    ] }),
+    !isCollapsed && /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "llm-ready-toc-list", children: headings.map((heading) => /* @__PURE__ */ jsxRuntime.jsx(
+      TOCItem,
+      {
+        heading,
+        activeId,
+        highlightActive,
+        onClick: handleClick
+      },
+      heading.id
+    )) })
+  ] });
+}
+function TOCItem({
+  heading,
+  activeId,
+  highlightActive,
+  onClick
+}) {
+  const isActive = highlightActive && heading.id === activeId;
+  const itemClasses = [
+    "llm-ready-toc-item",
+    `llm-ready-toc-level-${heading.level}`,
+    isActive && "llm-ready-toc-active"
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs("li", { className: itemClasses, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "a",
+      {
+        href: `#${heading.id}`,
+        className: "llm-ready-toc-link",
+        onClick: (e) => onClick(e, heading.id),
+        "aria-current": isActive ? "location" : void 0,
+        children: heading.text
+      }
+    ),
+    heading.children && heading.children.length > 0 && /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "llm-ready-toc-nested", children: heading.children.map((child) => /* @__PURE__ */ jsxRuntime.jsx(
+      TOCItem,
+      {
+        heading: child,
+        activeId,
+        highlightActive,
+        onClick
+      },
+      child.id
+    )) })
+  ] });
+}
+function TOCMobile(props) {
+  const [isOpen, setIsOpen] = React.useState(false);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        className: "llm-ready-toc-mobile-toggle",
+        onClick: () => setIsOpen(true),
+        "aria-label": "Open table of contents",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "12", x2: "21", y2: "12" }),
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "6", x2: "21", y2: "6" }),
+            /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "3", y1: "18", x2: "21", y2: "18" })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Contents" })
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-toc-mobile-panel", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { className: "llm-ready-toc-mobile-backdrop", onClick: () => setIsOpen(false) }),
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-toc-mobile-content", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "llm-ready-toc-mobile-header", children: [
+          /* @__PURE__ */ jsxRuntime.jsx("h3", { children: "Contents" }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              className: "llm-ready-toc-mobile-close",
+              onClick: () => setIsOpen(false),
+              "aria-label": "Close",
+              children: /* @__PURE__ */ jsxRuntime.jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+                /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+              ] })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsx(TOC, { ...props, sticky: false, collapsible: false })
+      ] })
+    ] })
+  ] });
+}
+function LLMBadge({
+  text = "AI Ready",
+  showTooltip = true,
+  tooltipContent = "This content is optimized for AI assistants like ChatGPT and Claude",
+  size = "md",
+  className = ""
+}) {
+  const [isTooltipVisible, setIsTooltipVisible] = React.useState(false);
+  const badgeClasses = [
+    "llm-ready-badge",
+    `llm-ready-badge-${size}`,
+    className
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      className: badgeClasses,
+      onMouseEnter: () => showTooltip && setIsTooltipVisible(true),
+      onMouseLeave: () => setIsTooltipVisible(false),
+      onFocus: () => showTooltip && setIsTooltipVisible(true),
+      onBlur: () => setIsTooltipVisible(false),
+      tabIndex: showTooltip ? 0 : -1,
+      role: showTooltip ? "tooltip" : void 0,
+      "aria-describedby": showTooltip ? "llm-badge-tooltip" : void 0,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "svg",
+          {
+            width: size === "sm" ? 12 : size === "lg" ? 18 : 14,
+            height: size === "sm" ? 12 : size === "lg" ? 18 : 14,
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            className: "llm-ready-badge-icon",
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "3" }),
+              /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 2v4m0 12v4M2 12h4m12 0h4" }),
+              /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m4.93 4.93 2.83 2.83m8.48 8.48 2.83 2.83m0-14.14-2.83 2.83m-8.48 8.48-2.83 2.83" })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx("span", { className: "llm-ready-badge-text", children: text }),
+        showTooltip && isTooltipVisible && /* @__PURE__ */ jsxRuntime.jsx("div", { id: "llm-badge-tooltip", className: "llm-ready-badge-tooltip", role: "tooltip", children: tooltipContent })
+      ]
+    }
+  );
+}
+function useAnalytics(options = {}) {
+  const {
+    endpoint = "/api/llm-analytics",
+    includeUrl = true,
+    includeTimestamp = true,
+    metadata = {}
+  } = options;
+  const pendingRef = React.useRef(/* @__PURE__ */ new Set());
+  const track = React.useCallback(
+    async (event) => {
+      const key = `${event.action}-${event.contentId || ""}-${Date.now()}`;
+      if (pendingRef.current.has(key)) {
+        return;
+      }
+      pendingRef.current.add(key);
+      try {
+        const payload = {
+          ...event,
+          ...includeUrl && { url: event.url || window.location.href },
+          ...includeTimestamp && { timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString() },
+          metadata: { ...metadata, ...event.metadata }
+        };
+        if (navigator.sendBeacon) {
+          const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+          navigator.sendBeacon(endpoint, blob);
+        } else {
+          await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            keepalive: true
+          });
+        }
+      } catch (error) {
+        console.error("Analytics tracking failed:", error);
+      } finally {
+        pendingRef.current.delete(key);
+      }
+    },
+    [endpoint, includeUrl, includeTimestamp, metadata]
+  );
+  const trackCopy = React.useCallback(() => {
+    return track({ action: "copy" });
+  }, [track]);
+  const trackView = React.useCallback(() => {
+    return track({ action: "view" });
+  }, [track]);
+  const trackDownload = React.useCallback(() => {
+    return track({ action: "download" });
+  }, [track]);
+  return { track, trackCopy, trackView, trackDownload };
+}
+function createAnalyticsTracker(endpoint) {
+  return async function trackEvent(action, contentId, metadata) {
+    const payload = {
+      action,
+      contentId,
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    try {
+      if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+        const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+        navigator.sendBeacon(endpoint, blob);
+      } else if (typeof fetch !== "undefined") {
+        await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+          keepalive: true
+        });
+      }
+    } catch (error) {
+      console.error("Analytics tracking failed:", error);
+    }
+  };
+}
+
+// src/server/generate-markdown.ts
+function generateMarkdown(content) {
+  const parts = [];
+  if (content.promptPrefix?.trim()) {
+    parts.push(content.promptPrefix.trim());
+    parts.push("");
+  }
+  parts.push(`# ${content.title}`);
+  parts.push("");
+  if (content.excerpt) {
+    parts.push(`> ${content.excerpt}`);
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push(`- **Source**: ${content.url}`);
+  if (content.date) {
+    parts.push(`- **Date**: ${content.date}`);
+  }
+  if (content.modifiedDate) {
+    parts.push(`- **Modified**: ${content.modifiedDate}`);
+  }
+  if (content.author) {
+    parts.push(`- **Author**: ${content.author}`);
+  }
+  if (content.categories?.length) {
+    parts.push(`- **Categories**: ${content.categories.join(", ")}`);
+  }
+  if (content.tags?.length) {
+    parts.push(`- **Tags**: ${content.tags.join(", ")}`);
+  }
+  if (content.readingTime) {
+    parts.push(`- **Reading Time**: ${content.readingTime} min`);
+  }
+  parts.push("---");
+  parts.push("");
+  if (content.content) {
+    const contentMarkdown = isHTML(content.content) ? htmlToMarkdown(content.content) : content.content;
+    parts.push(contentMarkdown);
+  }
+  const markdown = parts.join("\n").trim();
+  const wordCount = countWords(markdown);
+  const readingTime = calculateReadingTime(markdown);
+  const headings = extractMarkdownHeadings(markdown);
+  return {
+    markdown,
+    wordCount,
+    readingTime,
+    headings
+  };
+}
+function generateMarkdownString(content) {
+  return generateMarkdown(content).markdown;
+}
+function isHTML(str) {
+  return /<[a-z][\s\S]*>/i.test(str);
+}
+function extractMarkdownHeadings(markdown) {
+  const headings = [];
+  const lines = markdown.split("\n");
+  let index = 0;
+  for (const line of lines) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (match) {
+      const level = match[1].length;
+      const text = match[2].trim();
+      const id = generateSlug(text, index);
+      headings.push({ id, text, level });
+      index++;
+    }
+  }
+  return headings;
+}
+function generateSlug(text, index) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || `heading-${index}`;
+}
+function contentToPlainText(content) {
+  const markdown = generateMarkdownString(content);
+  return markdown.replace(/^#+\s+/gm, "").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/\*([^*]+)\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/!\[([^\]]*)\]\([^)]+\)/g, "").replace(/^[-*+]\s+/gm, "").replace(/^>\s+/gm, "").replace(/^---$/gm, "").replace(/\n{2,}/g, "\n\n").trim();
+}
+
+// src/server/generate-llms-txt.ts
+function generateLLMsTxt(config) {
+  const parts = [];
+  parts.push(`# ${config.siteName}`);
+  parts.push("");
+  if (config.siteDescription) {
+    parts.push(`> ${config.siteDescription}`);
+    parts.push("");
+  }
+  if (config.headerText) {
+    parts.push(config.headerText);
+  } else {
+    parts.push("This file provides LLM-friendly access to the content on this website.");
+  }
+  parts.push("");
+  parts.push("---");
+  parts.push(`- **Site URL**: ${config.siteUrl}`);
+  parts.push("- **Format**: Append `?llm=1` to any page URL to get markdown");
+  parts.push("---");
+  parts.push("");
+  if (config.content.length > 0) {
+    parts.push("## Available Content");
+    parts.push("");
+    for (const item of config.content) {
+      const llmUrl = appendQueryParam(item.url, "llm", "1");
+      parts.push(`### [${item.title}](${llmUrl})`);
+      if (item.type) {
+        parts.push(`- **Type**: ${item.type}`);
+      }
+      if (item.date) {
+        parts.push(`- **Date**: ${item.date}`);
+      }
+      if (item.description) {
+        parts.push(`- **Description**: ${item.description}`);
+      }
+      parts.push(`- **Markdown URL**: ${llmUrl}`);
+      parts.push("");
+    }
+  }
+  parts.push("---");
+  parts.push("");
+  if (config.footerText) {
+    parts.push(config.footerText);
+  } else {
+    parts.push("*Generated by [next-llm-ready](https://seoengine.ai) - Make your content AI-ready*");
+  }
+  return parts.join("\n");
+}
+function appendQueryParam(url, key, value) {
+  const separator = url.includes("?") ? "&" : "?";
+  return `${url}${separator}${key}=${value}`;
+}
+function createLLMsTxtHandler(options) {
+  return async function handler(request) {
+    try {
+      const siteConfig = await options.getSiteConfig();
+      const content = await options.getContent();
+      const config = {
+        siteName: siteConfig.siteName,
+        siteDescription: siteConfig.siteDescription,
+        siteUrl: siteConfig.siteUrl,
+        content,
+        headerText: options.headerText,
+        footerText: options.footerText
+      };
+      const llmsTxt = generateLLMsTxt(config);
+      return new server.NextResponse(llmsTxt, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/plain; charset=utf-8",
+          "Cache-Control": options.cacheControl || "public, max-age=3600",
+          "X-Robots-Tag": "noindex"
+        }
+      });
+    } catch (error) {
+      console.error("Error generating llms.txt:", error);
+      return new server.NextResponse("Error generating llms.txt", { status: 500 });
+    }
+  };
+}
+function createLLMsTxtPageHandler(options) {
+  return async function handler(req, res) {
+    if (req.method !== "GET") {
+      res.status(405).end("Method Not Allowed");
+      return;
+    }
+    try {
+      const siteConfig = await options.getSiteConfig();
+      const content = await options.getContent();
+      const config = {
+        siteName: siteConfig.siteName,
+        siteDescription: siteConfig.siteDescription,
+        siteUrl: siteConfig.siteUrl,
+        content,
+        headerText: options.headerText,
+        footerText: options.footerText
+      };
+      const llmsTxt = generateLLMsTxt(config);
+      res.setHeader("Content-Type", "text/plain; charset=utf-8");
+      res.setHeader("Cache-Control", options.cacheControl || "public, max-age=3600");
+      res.setHeader("X-Robots-Tag", "noindex");
+      res.status(200).end(llmsTxt);
+    } catch (error) {
+      console.error("Error generating llms.txt:", error);
+      res.status(500).end("Error generating llms.txt");
+    }
+  };
+}
+function withLLMParam(options) {
+  return async function middleware(request) {
+    const url = new URL(request.url);
+    const llmParam = url.searchParams.get("llm");
+    if (llmParam !== "1") {
+      return void 0;
+    }
+    try {
+      const pathname = url.pathname;
+      const content = await options.getContent(pathname);
+      if (!content) {
+        return new server.NextResponse("Content not found", { status: 404 });
+      }
+      const markdown = generateMarkdownString(content);
+      return new server.NextResponse(markdown, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/markdown; charset=utf-8",
+          "Cache-Control": options.cacheControl || "public, max-age=3600",
+          "X-Robots-Tag": "noindex",
+          ...options.cors && {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET"
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Error generating markdown:", error);
+      return new server.NextResponse("Error generating markdown", { status: 500 });
+    }
+  };
+}
+function createMarkdownHandler(options) {
+  return async function handler(request, { params }) {
+    try {
+      const slug = params?.slug || "";
+      const content = await options.getContent(slug);
+      if (!content) {
+        return new server.NextResponse("Content not found", {
+          status: 404,
+          headers: { "Content-Type": "text/plain" }
+        });
+      }
+      const markdown = generateMarkdownString(content);
+      return new server.NextResponse(markdown, {
+        status: 200,
+        headers: {
+          "Content-Type": "text/markdown; charset=utf-8",
+          "Cache-Control": options.cacheControl || "public, max-age=3600",
+          "X-Robots-Tag": "noindex",
+          ...options.cors && {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET"
+          }
+        }
+      });
+    } catch (error) {
+      console.error("Error generating markdown:", error);
+      return new server.NextResponse("Error generating markdown", { status: 500 });
+    }
+  };
+}
+function hasLLMParam(request) {
+  const url = new URL(request.url);
+  return url.searchParams.get("llm") === "1";
+}
+function createInMemoryStorage() {
+  const events = [];
+  return {
+    save: async (event) => {
+      events.push(event);
+    },
+    getAll: async () => [...events],
+    clear: async () => {
+      events.length = 0;
+    }
+  };
+}
+function createAnalyticsHandler(options) {
+  const requestCounts = /* @__PURE__ */ new Map();
+  return async function handler(request) {
+    if (request.method === "OPTIONS") {
+      return new server.NextResponse(null, {
+        status: 204,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type"
+        }
+      });
+    }
+    if (request.method !== "POST") {
+      return new server.NextResponse("Method Not Allowed", { status: 405 });
+    }
+    if (options.rateLimit) {
+      const clientIp = request.headers.get("x-forwarded-for") || "unknown";
+      const now = Date.now();
+      const windowMs = 6e4;
+      const clientData = requestCounts.get(clientIp) || { count: 0, resetAt: now + windowMs };
+      if (now > clientData.resetAt) {
+        clientData.count = 0;
+        clientData.resetAt = now + windowMs;
+      }
+      clientData.count++;
+      requestCounts.set(clientIp, clientData);
+      if (clientData.count > options.rateLimit) {
+        return new server.NextResponse("Rate limit exceeded", {
+          status: 429,
+          headers: {
+            "Retry-After": Math.ceil((clientData.resetAt - now) / 1e3).toString()
+          }
+        });
+      }
+    }
+    try {
+      const body = await request.json();
+      const event = {
+        action: body.action || "copy",
+        contentId: body.contentId,
+        url: body.url || request.headers.get("referer"),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: body.metadata
+      };
+      await options.storage.save(event);
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (options.cors) {
+        headers["Access-Control-Allow-Origin"] = "*";
+      }
+      return server.NextResponse.json({ success: true, event }, { headers });
+    } catch (error) {
+      console.error("Analytics tracking error:", error);
+      return server.NextResponse.json({ success: false, error: "Failed to track event" }, { status: 500 });
+    }
+  };
+}
+function createAnalyticsPageHandler(options) {
+  return async function handler(req, res) {
+    if (req.method !== "POST") {
+      res.status(405).end("Method Not Allowed");
+      return;
+    }
+    try {
+      const body = req.body;
+      const event = {
+        action: body?.action || "copy",
+        contentId: body?.contentId,
+        url: body?.url || req.headers?.referer,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: body?.metadata
+      };
+      await options.storage.save(event);
+      if (options.cors) {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+      }
+      res.status(200).json({ success: true, event });
+    } catch (error) {
+      console.error("Analytics tracking error:", error);
+      res.status(500).json({ success: false, error: "Failed to track event" });
+    }
+  };
+}
+async function aggregateEvents(storage) {
+  const events = await storage.getAll();
+  const counts = {
+    copy: 0,
+    view: 0,
+    download: 0
+  };
+  for (const event of events) {
+    if (event.action in counts) {
+      counts[event.action]++;
+    }
+  }
+  return counts;
+}
+async function getEventsForContent(storage, contentId) {
+  const events = await storage.getAll();
+  return events.filter((event) => event.contentId === contentId);
+}
+
+exports.CopyButton = CopyButton;
+exports.CopyDropdown = CopyDropdown;
+exports.LLMBadge = LLMBadge;
+exports.TOC = TOC;
+exports.TOCMobile = TOCMobile;
+exports.aggregateEvents = aggregateEvents;
+exports.buildNestedTOC = buildNestedTOC;
+exports.contentToPlainText = contentToPlainText;
+exports.copyToClipboard = copyToClipboard;
+exports.createAnalyticsHandler = createAnalyticsHandler;
+exports.createAnalyticsPageHandler = createAnalyticsPageHandler;
+exports.createAnalyticsTracker = createAnalyticsTracker;
+exports.createInMemoryStorage = createInMemoryStorage;
+exports.createLLMsTxtHandler = createLLMsTxtHandler;
+exports.createLLMsTxtPageHandler = createLLMsTxtPageHandler;
+exports.createMarkdownHandler = createMarkdownHandler;
+exports.downloadAsFile = downloadAsFile;
+exports.generateLLMsTxt = generateLLMsTxt;
+exports.generateMarkdown = generateMarkdown;
+exports.generateMarkdownString = generateMarkdownString;
+exports.getEventsForContent = getEventsForContent;
+exports.hasLLMParam = hasLLMParam;
+exports.htmlToMarkdown = htmlToMarkdown;
+exports.useAnalytics = useAnalytics;
+exports.useLLMCopy = useLLMCopy;
+exports.useTOC = useTOC;
+exports.useTOCKeyboard = useTOCKeyboard;
+exports.withLLMParam = withLLMParam;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map