nizel-kit 0.1.9 → 0.1.11

package/dist/nizel-kit.iife.js

@@ -64,8 +64,36 @@ var NizelKit = (() => {
   ]);
   var passthroughInlineTags = /* @__PURE__ */ new Set(["abbr", "bdi", "bdo", "cite", "data", "dfn", "kbd", "mark", "q", "samp", "small", "sub", "sup", "time", "u", "var"]);
   function htmlToMarkdown(html, options = {}) {
+    const resolved = {
+      unsupported: options.unsupported ?? "preserve",
+      plugins: options.plugins ?? []
+    };
+    const handlers = resolved.plugins.flatMap((plugin) => {
+      const handler = plugin?.htmlToMarkdown;
+      return handler ? Array.isArray(handler) ? handler : [handler] : [];
+    });
+    const ctx = { options: resolved, handlers, epilogue: [] };
     const root = parseHtml(html);
-    return normalizeDocument(renderChildren(root.children, { unsupported: options.unsupported ?? "preserve" }, 0));
+    const body = normalizeDocument(renderChildren(root.children, ctx, 0));
+    return ctx.epilogue.length ? normalizeDocument(`${body}
+
+${ctx.epilogue.join("\n\n")}`) : body;
+  }
+  function buildHandlerContext(node, ctx, depth) {
+    return {
+      options: ctx.options,
+      inline: (target) => normalizeInline(renderChildren(childrenOf(target), ctx, depth)),
+      block: (target) => normalizeDocument(renderChildren(childrenOf(target), ctx, depth)),
+      text: (target) => textContent(target),
+      indent: (value, size) => indentContinuation(value, size),
+      epilogue: (value) => {
+        if (value)
+          ctx.epilogue.push(value);
+      }
+    };
+  }
+  function childrenOf(node) {
+    return node.type === "element" || node.type === "root" ? node.children : [];
   }
   function parseHtml(html) {
     const root = { type: "root", children: [] };
@@ -167,25 +195,31 @@ var NizelKit = (() => {
   function slugifyText(value) {
     return value.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "");
   }
-  function renderChildren(nodes, options, depth) {
-    return nodes.map((node) => renderNode(node, options, depth)).join("");
+  function renderChildren(nodes, ctx, depth) {
+    return nodes.map((node) => renderNode(node, ctx, depth)).join("");
   }
-  function renderNode(node, options, depth) {
+  function renderNode(node, ctx, depth) {
     if (node.type === "text")
       return collapseText(decodeEntities(node.value));
     if (node.type === "comment")
-      return options.unsupported === "preserve" ? node.value : " ";
+      return ctx.options.unsupported === "preserve" ? node.value : " ";
     if (node.type === "root")
-      return renderChildren(node.children, options, depth);
-    const inline = () => normalizeInline(renderChildren(node.children, options, depth));
-    const block = () => normalizeDocument(renderChildren(node.children, options, depth));
-    if (options.unsupported === "preserve" && hasUnsupportedAttrs(node)) {
+      return renderChildren(node.children, ctx, depth);
+    const inline = () => normalizeInline(renderChildren(node.children, ctx, depth));
+    const block = () => normalizeDocument(renderChildren(node.children, ctx, depth));
+    for (const handler of ctx.handlers) {
+      const result = handler(node, buildHandlerContext(node, ctx, depth));
+      if (result !== void 0) {
+        return blockTags.has(node.tag) ? blockWrap(result) : result;
+      }
+    }
+    if (ctx.options.unsupported === "preserve" && hasUnsupportedAttrs(node)) {
       return blockTags.has(node.tag) ? blockWrap(node.raw) : node.raw;
     }
     if (/^h[1-6]$/.test(node.tag))
       return blockWrap(`${"#".repeat(Number(node.tag[1]))} ${inline()}`);
     if (node.tag === "p")
-      return blockWrap(normalizeParagraph(renderChildren(node.children, options, depth)));
+      return blockWrap(normalizeParagraph(renderChildren(node.children, ctx, depth)));
     if (node.tag === "br")
       return "  \n";
     if (node.tag === "hr")
@@ -207,13 +241,13 @@ var NizelKit = (() => {
     if (node.tag === "blockquote")
       return blockWrap(prefixLines(block(), "> "));
     if (node.tag === "ul" || node.tag === "ol")
-      return blockWrap(renderList(node, options, depth));
+      return blockWrap(renderList(node, ctx, depth));
     if (node.tag === "li")
       return inline();
     if (node.tag === "table") {
-      if (options.unsupported === "preserve" && tableHasUnsupportedStructure(node))
+      if (ctx.options.unsupported === "preserve" && tableHasUnsupportedStructure(node))
         return blockWrap(node.raw);
-      return blockWrap(renderTable(node, options));
+      return blockWrap(renderTable(node, ctx));
     }
     if (node.tag === "thead" || node.tag === "tbody" || node.tag === "tr" || node.tag === "th" || node.tag === "td")
       return inline();
@@ -222,9 +256,9 @@ var NizelKit = (() => {
     if (node.tag === "span")
       return inline();
     if (passthroughInlineTags.has(node.tag) || blockTags.has(node.tag)) {
-      return options.unsupported === "preserve" ? node.raw : block();
+      return ctx.options.unsupported === "preserve" ? node.raw : block();
     }
-    return options.unsupported === "preserve" ? node.raw : inline();
+    return ctx.options.unsupported === "preserve" ? node.raw : inline();
   }
   function renderLink(node, text) {
     const href = node.attrs.href;
@@ -257,19 +291,19 @@ var NizelKit = (() => {
 ${code}
 ${fence}`;
   }
-  function renderList(node, options, depth) {
+  function renderList(node, ctx, depth) {
     return node.children.filter((child) => child.type === "element" && child.tag === "li").map((item, index) => {
       const marker = node.tag === "ol" ? `${Number(node.attrs.start ?? 1) + index}. ` : "- ";
-      const body = normalizeListItemBody(renderChildren(item.children, options, depth + 1));
+      const body = normalizeListItemBody(renderChildren(item.children, ctx, depth + 1));
       return indentContinuation(`${marker}${body}`, marker.length);
     }).join("\n");
   }
-  function renderTable(node, options) {
+  function renderTable(node, ctx) {
     const rows = collectRows(node).map((row) => row.children.filter((cell) => cell.type === "element" && (cell.tag === "th" || cell.tag === "td"))).filter((row) => row.length > 0);
     if (rows.length === 0)
       return "";
     const width = Math.max(...rows.map((row) => row.length));
-    const values = rows.map((row) => Array.from({ length: width }, (_, index) => normalizeInline(renderChildren(row[index]?.children ?? [], options, 0))));
+    const values = rows.map((row) => Array.from({ length: width }, (_, index) => normalizeInline(renderChildren(row[index]?.children ?? [], ctx, 0))));
     const header = values[0];
     const separator = Array.from({ length: width }, () => "---");
     const body = values.slice(1);
@@ -366,6 +400,20 @@ ${trimmed}
     }
     return longest;
   }
+  var htmlChildElements = (node) => node.type === "element" || node.type === "root" ? node.children.filter((child) => child.type === "element") : [];
+  var findHtmlElement = (node, predicate) => htmlChildElements(node).find(predicate);
+  var hasHtmlClass = (node, className) => node.type === "element" && (node.attrs.class ?? "").split(/\s+/).includes(className);
+  var findHtmlDescendant = (node, predicate) => {
+    for (const child of htmlChildElements(node)) {
+      if (predicate(child))
+        return child;
+      const nested = findHtmlDescendant(child, predicate);
+      if (nested)
+        return nested;
+    }
+    return void 0;
+  };
+  var htmlRoot = (children) => ({ type: "root", children });
 
   // ../nizel/dist/collect.js
   function collect(ast) {
@@ -2406,6 +2454,10 @@ ${trimmed}
         ...left.variables ?? {},
         ...right.variables ?? {}
       },
+      meta: {
+        ...left.meta ?? {},
+        ...right.meta ?? {}
+      },
       elements: {
         ...left.elements ?? {},
         ...right.elements ?? {}
@@ -4877,7 +4929,22 @@ ${body}
         afterParse(ast) {
           return replaceAbbreviations(ast, definitions);
         }
-      }
+      },
+      htmlToMarkdown: abbrToMarkdown()
+    };
+  };
+  var abbrToMarkdown = () => {
+    const seen = /* @__PURE__ */ new Set();
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "abbr")
+        return void 0;
+      const term = ctx.text(node).trim();
+      const title = node.attrs.title;
+      if (title !== void 0 && term && !seen.has(term)) {
+        seen.add(term);
+        ctx.epilogue(`*[${term}]: ${title}`);
+      }
+      return term;
     };
   };
   var extractAbbreviations = (markdown) => {
@@ -4945,7 +5012,25 @@ ${body}
       blocks,
       hooks: {
         beforeParse: transformGitHubAlerts
-      }
+      },
+      htmlToMarkdown: alertToMarkdown(options)
+    };
+  };
+  var alertToMarkdown = (options = {}) => {
+    const rootClass = options.className ?? "alert";
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "div")
+        return void 0;
+      const type = node.attrs["data-alert"];
+      if (!type)
+        return void 0;
+      const titleEl = findHtmlElement(node, (el) => el.tag === "p" && hasHtmlClass(el, `${rootClass}__title`));
+      const contentEl = findHtmlElement(node, (el) => hasHtmlClass(el, `${rootClass}__content`));
+      const title = titleEl ? ctx.text(titleEl).trim() : "";
+      const body = contentEl ? ctx.block(contentEl) : "";
+      return `${title ? `::${type} ${title}` : `::${type}`}
+${body}
+::`;
     };
   };
   var transformGitHubAlerts = (markdown) => {
@@ -5030,9 +5115,21 @@ ${body}
       name: "autolink",
       options: {
         autolinks: resolveAutolinkPluginOptions(options)
-      }
+      },
+      htmlToMarkdown: autolinkToMarkdown()
     });
   };
+  var autolinkToMarkdown = () => (node, ctx) => {
+    if (node.type !== "element" || node.tag !== "a")
+      return void 0;
+    const href = node.attrs.href;
+    if (!href)
+      return void 0;
+    const extras = Object.keys(node.attrs).filter((key) => key !== "href" && key !== "target" && key !== "rel");
+    if (extras.length > 0)
+      return void 0;
+    return ctx.text(node).trim() === href ? href : void 0;
+  };
 
   // ../plugin-code-copy/dist/index.js
   var codeCopyPlugin = (options = {}) => {
@@ -5055,9 +5152,34 @@ ${body}
       },
       hooks: {
         afterParse: wrapCodeBlocks
-      }
+      },
+      htmlToMarkdown: codeCopyToMarkdown()
     });
   };
+  var codeCopyToMarkdown = () => (node, ctx) => {
+    if (node.type !== "element" || node.tag !== "figure" || node.attrs["data-nizel-code-copy"] === void 0)
+      return void 0;
+    const source = findHtmlDescendant(node, (el) => el.tag === "textarea" && el.attrs["data-nizel-copy-source"] !== void 0);
+    if (!source) {
+      const body = htmlChildElements(node).filter((el) => !["figcaption", "textarea", "button"].includes(el.tag));
+      return ctx.block(htmlRoot(body));
+    }
+    const code = ctx.text(source).replace(/\n$/, "");
+    const pre = findHtmlDescendant(node, (el) => el.tag === "pre");
+    const codeEl = pre ? findHtmlElement(pre, (el) => el.tag === "code") : void 0;
+    const codeClass = codeEl?.attrs.class ?? "";
+    const langClass = codeClass.match(/\blanguage-([A-Za-z0-9_-]+)/)?.[1];
+    const isMermaid = findHtmlDescendant(node, (el) => el.tag === "div" && el.attrs.class === "mermaid") !== void 0;
+    const lang = langClass ?? pre?.attrs["data-language"] ?? (isMermaid ? "mermaid" : "");
+    const fence = fenceFor(code);
+    return `${fence}${lang}
+${code}
+${fence}`;
+  };
+  var fenceFor = (code) => {
+    const longest = Math.max(0, ...(code.match(/`+/g) ?? []).map((run) => run.length));
+    return "`".repeat(Math.max(3, longest + 1));
+  };
   var wrapCodeBlocks = (ast) => ({
     ...ast,
     children: ast.children.map(wrapCodeBlock)
@@ -5134,7 +5256,28 @@ ${body}
         afterParse(ast) {
           return appendBibliography(replaceCitationRefs(ast, citations), citations);
         }
+      },
+      htmlToMarkdown: citationsToMarkdown(options)
+    };
+  };
+  var citationsToMarkdown = (options = {}) => {
+    const className = options.className ?? "citations";
+    return (node, ctx) => {
+      if (node.type !== "element")
+        return void 0;
+      if (node.tag === "a" && hasHtmlClass(node, "citation")) {
+        const match = /^#cite-(.+)$/.exec(node.attrs.href ?? "");
+        return match ? `[@${match[1]}]` : void 0;
+      }
+      if (node.tag === "section" && hasHtmlClass(node, className)) {
+        const list = findHtmlElement(node, (el) => el.tag === "ol");
+        const items = list ? htmlChildElements(list).filter((el) => el.tag === "li") : [];
+        return items.map((li) => {
+          const id = /^cite-(.+)$/.exec(li.attrs.id ?? "")?.[1] ?? "";
+          return `[@${id}]: ${ctx.block(htmlRoot(li.children)).trim()}`;
+        }).join("\n");
       }
+      return void 0;
     };
   };
   var extractCitations = (markdown) => {
@@ -5236,9 +5379,28 @@ ${body}
         beforeParse(markdown) {
           return transformDefinitionLists(markdown, options);
         }
-      }
+      },
+      htmlToMarkdown: deflistToMarkdown(options)
     };
   };
+  var deflistToMarkdown = (options = {}) => (node, ctx) => {
+    if (node.type !== "element" || node.tag !== "dl")
+      return void 0;
+    if (options.className) {
+      if (node.attrs.class !== options.className)
+        return void 0;
+    } else if (node.attrs.class !== void 0) {
+      return void 0;
+    }
+    const lines = [];
+    for (const el of htmlChildElements(node)) {
+      if (el.tag === "dt")
+        lines.push(ctx.inline(el));
+      else if (el.tag === "dd")
+        lines.push(`: ${ctx.inline(el)}`);
+    }
+    return lines.join("\n");
+  };
   var transformDefinitionLists = (markdown, _options = {}) => {
     const lines = markdown.split("\n");
     const result = [];
@@ -5325,8 +5487,23 @@ ${body}
     },
     hooks: {
       beforeParse: transformDetails
-    }
+    },
+    htmlToMarkdown: detailsToMarkdown(options)
   });
+  var detailsToMarkdown = (options = {}) => {
+    const className = options.className ?? "details";
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "details" || node.attrs.class !== className)
+        return void 0;
+      const summaryEl = findHtmlElement(node, (el) => el.tag === "summary");
+      const summary = summaryEl ? ctx.text(summaryEl).trim() : "Details";
+      const body = ctx.block(htmlRoot(htmlChildElements(node).filter((el) => el.tag !== "summary"))).trim();
+      return body ? `::details ${summary}
+${body}
+::` : `::details ${summary}
+::`;
+    };
+  };
   var transformDetails = (markdown) => {
     return markdown.replace(/^:::details\s*(.*?)\s*$/gm, (_match, summary) => `::details ${summary || "Details"}`).replace(/^:::\s*$/gm, "::");
   };
@@ -5356,7 +5533,19 @@ ${body}
         afterParse(ast) {
           return transformDiagramCodes(ast, options);
         }
-      }
+      },
+      htmlToMarkdown: diagramsToMarkdown(options)
+    };
+  };
+  var diagramsToMarkdown = (options = {}) => {
+    const className = options.className ?? "mermaid";
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "div" || node.attrs.class !== className)
+        return void 0;
+      const code = ctx.text(node).trim();
+      return `\`\`\`mermaid
+${code}
+\`\`\``;
     };
   };
   var transformDiagramCodes = (ast, options = {}) => ({
@@ -5501,9 +5690,45 @@ ${body}
       hooks: {
         beforeParse: transformFootnotes,
         afterParse: transformFootnoteRefs
+      },
+      htmlToMarkdown: footnotesToMarkdown(options)
+    };
+  };
+  var footnotesToMarkdown = (options = {}) => {
+    const className = options.className ?? "footnotes";
+    return (node, ctx) => {
+      if (node.type !== "element")
+        return void 0;
+      if (node.tag === "sup") {
+        const anchor = findHtmlElement(node, (el) => el.tag === "a" && hasHtmlClass(el, "footnote-ref"));
+        const match = anchor ? /^#fn-(.+)$/.exec(anchor.attrs.href ?? "") : void 0;
+        return match ? `[^${match[1]}]` : void 0;
+      }
+      if (node.tag === "section" && hasHtmlClass(node, className)) {
+        const list = findHtmlElement(node, (el) => el.tag === "ol");
+        const items = list ? htmlChildElements(list).filter((el) => el.tag === "li") : [];
+        return items.map((li) => {
+          const id = /^fn-(.+)$/.exec(li.attrs.id ?? "")?.[1] ?? "";
+          const body = ctx.block(htmlRoot(stripBackrefs(li.children, className))).trim();
+          return `[^${id}]: ${body}`;
+        }).join("\n");
       }
+      return void 0;
     };
   };
+  var stripBackrefs = (nodes, className) => {
+    const result = [];
+    for (const node of nodes) {
+      if (node.type === "element") {
+        if (hasHtmlClass(node, `${className}__backref`))
+          continue;
+        result.push({ ...node, children: stripBackrefs(node.children, className) });
+      } else {
+        result.push(node);
+      }
+    }
+    return result;
+  };
   var transformFootnotes = (markdown) => {
     const lines = markdown.split("\n");
     const body = [];
@@ -5649,9 +5874,46 @@ ${body}
         afterParse(ast) {
           return transformTaskLists(ast, mode);
         }
-      }
+      },
+      htmlToMarkdown: taskListToMarkdown()
     };
   };
+  var CHECKBOX_ATTR = "data-nizel-task-checkbox";
+  var isCheckbox = (node) => node.type === "element" && node.tag === "input" && node.attrs?.[CHECKBOX_ATTR] !== void 0;
+  var taskListToMarkdown = () => (node, ctx) => {
+    if (node.type !== "element" || node.tag !== "ul" && node.tag !== "ol")
+      return void 0;
+    const items = htmlChildElements(node).filter((el) => el.tag === "li");
+    if (!items.some((item) => findHtmlDescendant(item, isCheckbox)))
+      return void 0;
+    const ordered = node.tag === "ol";
+    const start = Number(node.attrs.start ?? 1);
+    return items.map((item, index) => {
+      const checkbox = findHtmlDescendant(item, isCheckbox);
+      const body = ctx.block(htmlRoot(cleanTaskChildren(item.children))).trim();
+      const baseMarker = ordered ? `${start + index}. ` : "- ";
+      const marker = checkbox ? `${baseMarker}${checkbox.attrs.checked !== void 0 ? "[x] " : "[ ] "}` : baseMarker;
+      return ctx.indent(`${marker}${body}`, marker.length);
+    }).join("\n");
+  };
+  var cleanTaskChildren = (nodes) => {
+    const result = [];
+    for (const node of nodes) {
+      if (node.type === "element") {
+        if (isCheckbox(node))
+          continue;
+        const cleaned = { ...node, children: cleanTaskChildren(node.children) };
+        if (hasHtmlClass(cleaned, "nizel-task-list__label") || hasHtmlClass(cleaned, "nizel-task-list__content")) {
+          result.push(...cleaned.children);
+        } else {
+          result.push(cleaned);
+        }
+      } else {
+        result.push(node);
+      }
+    }
+    return result;
+  };
   var transformTaskLists = (ast, mode = "view") => {
     return { ...ast, children: ast.children.map((node) => transformBlock5(node, mode)) };
   };
@@ -5733,8 +5995,17 @@ ${body}
       afterParse(ast) {
         return addHeadingAnchors(ast, options);
       }
-    }
+    },
+    htmlToMarkdown: headingAnchorsToMarkdown(options)
   });
+  var headingAnchorsToMarkdown = (options = {}) => {
+    const className = options.className ?? "heading-anchor";
+    return (node) => {
+      if (node.type !== "element" || node.tag !== "a" || !hasHtmlClass(node, className))
+        return void 0;
+      return "";
+    };
+  };
   var addHeadingAnchors = (ast, options = {}) => ({
     ...ast,
     children: ast.children.map((node) => {
@@ -5754,6 +6025,177 @@ ${body}
   });
   var escapeHtml8 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 
+  // ../nizel-plugin-hidden-comments/dist/index.js
+  var hiddenCommentsPlugin = (options = {}) => {
+    const normalized = normalizeOptions(options);
+    let comments = /* @__PURE__ */ new Map();
+    let nextIndex = 0;
+    return {
+      name: "hidden-comments",
+      hooks: {
+        beforeParse(markdown) {
+          comments = /* @__PURE__ */ new Map();
+          nextIndex = 0;
+          return transformMarkdownComments(markdown, normalized, (comment) => {
+            const token = `NIZEL_HIDDEN_COMMENT_${nextIndex}_${Math.random().toString(36).slice(2)}`;
+            nextIndex += 1;
+            comments.set(token, comment);
+            return token;
+          });
+        },
+        afterRender(html) {
+          let nextHtml = restoreCommentTokens(html, comments, normalized);
+          if (normalized.injectCss && normalized.mode !== "remove") {
+            nextHtml = `${hiddenCommentsStyleTag(normalized.className)}
+${nextHtml}`;
+          }
+          return nextHtml;
+        }
+      },
+      htmlToMarkdown: hiddenCommentsToMarkdown(normalized)
+    };
+  };
+  var transformMarkdownComments = (markdown, options = {}, createToken = (comment) => renderCommentElement(comment, normalizeOptions(options))) => {
+    const normalized = normalizeOptions(options);
+    if (typeof markdown !== "string" || markdown.indexOf("<!--") === -1)
+      return markdown;
+    return replaceMarkdownCommentsOutsideFences(markdown, (comment) => {
+      if (normalized.mode === "remove")
+        return "";
+      return createToken(comment);
+    });
+  };
+  var hiddenCommentsToMarkdown = (options = {}) => {
+    const normalized = normalizeOptions(options);
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "span")
+        return void 0;
+      if (!isHiddenCommentElement(node.attrs, normalized.className))
+        return void 0;
+      const text = ctx.text(node).trim();
+      if (/^<!--[\s\S]*-->$/.test(text))
+        return text;
+      return `<!-- ${text.replace(/^<!--|-->$/g, "").trim()} -->`;
+    };
+  };
+  var isHiddenCommentElement = (attrs, className) => {
+    if ("data-nizel-hidden-comment" in attrs)
+      return true;
+    return (attrs.class ?? "").split(/\s+/).includes(className);
+  };
+  var normalizeOptions = (options) => ({
+    mode: options.mode ?? "hide",
+    injectCss: options.injectCss ?? false,
+    className: options.className ?? "nizel-hidden-comment"
+  });
+  var replaceMarkdownCommentsOutsideFences = (markdown, replacer) => {
+    const lines = markdown.split(/(\n)/);
+    let result = "";
+    let line = "";
+    let fence;
+    for (const part of lines) {
+      line += part;
+      if (part !== "\n")
+        continue;
+      const next = processLine(line, fence, replacer);
+      result += next.line;
+      fence = next.fence;
+      line = "";
+    }
+    if (line) {
+      const next = processLine(line, fence, replacer);
+      result += next.line;
+    }
+    return result;
+  };
+  var processLine = (line, fence, replacer) => {
+    if (fence) {
+      return {
+        line,
+        fence: isClosingFenceLine(line, fence) ? void 0 : fence
+      };
+    }
+    const openingFence = getOpeningFenceLine(line);
+    if (openingFence)
+      return { line, fence: openingFence };
+    return {
+      line: line.replace(/<!--[\s\S]*?-->/g, replacer),
+      fence
+    };
+  };
+  var getOpeningFenceLine = (line) => {
+    const match = /^( {0,3})(`{3,}|~{3,})/.exec(line);
+    if (!match)
+      return void 0;
+    return { marker: match[2].charAt(0), length: match[2].length };
+  };
+  var isClosingFenceLine = (line, fence) => {
+    const lineText = line.replace(/\r?\n$/, "");
+    const escapedMarker = fence.marker.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^ {0,3}${escapedMarker}{${fence.length},} *$`);
+    return pattern.test(lineText);
+  };
+  var renderCommentElement = (comment, options) => {
+    const classes = [
+      options.className,
+      `${options.className}--${options.mode}`,
+      "print-hidden-comment"
+    ];
+    const mode = escapeHtml9(options.mode);
+    return `<span class="${classes.map(escapeHtml9).join(" ")}" data-nizel-hidden-comment="" data-hidden-comment-mode="${mode}">${escapeHtml9(comment)}</span>`;
+  };
+  var restoreCommentTokens = (html, comments, options) => {
+    if (!comments.size || options.mode === "remove")
+      return html;
+    let nextHtml = html;
+    for (const [token, comment] of comments) {
+      const tokenPattern = new RegExp(escapeRegExp2(token), "g");
+      const blockPattern = new RegExp(`<p>\\s*${escapeRegExp2(token)}\\s*</p>`, "g");
+      const rendered = renderCommentElement(comment, options);
+      nextHtml = nextHtml.replace(blockPattern, rendered).replace(tokenPattern, rendered);
+    }
+    return nextHtml;
+  };
+  var hiddenCommentsStyleTag = (className) => {
+    return `<style data-nizel-plugin="hidden-comments">${hiddenCommentsCss(className)}</style>`;
+  };
+  var hiddenCommentsCss = (className) => {
+    const selector = `.${className.replace(/[^A-Za-z0-9_-]/g, "")}`;
+    return `${selector} {
+  user-select: text;
+}
+${selector}--hide {
+  border: 0;
+  color: rgba(255, 255, 255, 0);
+  display: inline-block;
+  font-size: 1px;
+  height: 0;
+  line-height: 0;
+  margin: 0;
+  max-height: 0;
+  max-width: 0;
+  overflow: hidden;
+  padding: 0;
+  vertical-align: baseline;
+  width: 0;
+}
+${selector}--small {
+  color: color-mix(in srgb, currentColor 60%, transparent);
+  display: inline;
+  font-size: 0.75em;
+  line-height: 1;
+}
+${selector}--render {
+  display: inline;
+}`;
+  };
+  var escapeHtml9 = (value) => {
+    return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  };
+  var escapeRegExp2 = (value) => {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  };
+
   // ../plugin-math/dist/index.js
   var mathPlugin = (options = {}) => {
     return {
@@ -5766,7 +6208,26 @@ ${body}
         afterParse(ast) {
           return transformInlineMath(ast, options);
         }
+      },
+      htmlToMarkdown: mathToMarkdown(options)
+    };
+  };
+  var mathToMarkdown = (options = {}) => {
+    const inlineTokens = (options.inlineClassName ?? "math math-inline").split(/\s+/);
+    const blockTokens = (options.blockClassName ?? "math math-display").split(/\s+/);
+    return (node, ctx) => {
+      if (node.type !== "element")
+        return void 0;
+      const tokens = node.attrs.class ? node.attrs.class.split(/\s+/) : [];
+      if (node.tag === "span" && inlineTokens.every((token) => tokens.includes(token))) {
+        return `$${ctx.text(node)}$`;
+      }
+      if (node.tag === "div" && blockTokens.every((token) => tokens.includes(token))) {
+        return `$$
+${ctx.text(node).trim()}
+$$`;
       }
+      return void 0;
     };
   };
   var transformBlockMath = (markdown) => {
@@ -5852,7 +6313,7 @@ ${body}
         nodes.push({ type: "text", value: value.slice(lastIndex, match.index) });
       nodes.push({
         type: "inlineHtml",
-        value: `<span class="${escapeHtml9(options.inlineClassName ?? "math math-inline")}">${escapeHtml9(match[1])}</span>`
+        value: `<span class="${escapeHtml10(options.inlineClassName ?? "math math-inline")}">${escapeHtml10(match[1])}</span>`
       });
       lastIndex = pattern.lastIndex;
     }
@@ -5860,7 +6321,7 @@ ${body}
       nodes.push({ type: "text", value: value.slice(lastIndex) });
     return nodes;
   };
-  var escapeHtml9 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  var escapeHtml10 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 
   // ../plugin-media/dist/index.js
   var mediaPlugin = (options = {}) => ({
@@ -5869,8 +6330,26 @@ ${body}
       afterRender(html) {
         return enhanceImages(html, options);
       }
-    }
+    },
+    htmlToMarkdown: mediaToMarkdown(options)
   });
+  var mediaToMarkdown = (options = {}) => {
+    const className = options.figureClassName ?? "media-figure";
+    return (node, ctx) => {
+      if (node.type !== "element" || node.tag !== "figure" || node.attrs.class !== className)
+        return void 0;
+      const img = findHtmlElement(node, (el) => el.tag === "img");
+      if (!img)
+        return void 0;
+      const attrs = { src: img.attrs.src ?? "" };
+      if (img.attrs.alt !== void 0)
+        attrs.alt = img.attrs.alt;
+      if (img.attrs.title !== void 0)
+        attrs.title = img.attrs.title;
+      const cleanImg = { type: "element", tag: "img", attrs, children: [], raw: "" };
+      return ctx.inline({ type: "root", children: [cleanImg] });
+    };
+  };
   var enhanceImages = (html, options = {}) => {
     const lazy = options.lazy !== false;
     const responsive = options.responsive !== false;
@@ -5878,7 +6357,7 @@ ${body}
     return html.replace(/<p>(<img\b[^>]*>)<\/p>/g, (_match, img) => {
       const enhanced = enhanceImageTag(img, { lazy, responsive });
       const caption = /alt="([^"]+)"/.exec(enhanced)?.[1];
-      return `<figure class="${escapeHtml10(className)}">${enhanced}${caption ? `<figcaption>${caption}</figcaption>` : ""}</figure>`;
+      return `<figure class="${escapeHtml11(className)}">${enhanced}${caption ? `<figcaption>${caption}</figcaption>` : ""}</figure>`;
     });
   };
   var enhanceImageTag = (img, options) => {
@@ -5889,7 +6368,7 @@ ${body}
       next = next.replace(/\/?>$/, ' decoding="async" />');
     return next;
   };
-  var escapeHtml10 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  var escapeHtml11 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 
   // ../plugin-sanitize/dist/index.js
   var sanitizePlugin = (options = {}) => ({
@@ -5933,9 +6412,30 @@ ${body}
             }
           }
         }
-      }
+      },
+      htmlToMarkdown: shikiToMarkdown()
     });
   };
+  var shikiToMarkdown = () => (node, ctx) => {
+    if (node.type !== "element" || node.tag !== "pre")
+      return void 0;
+    const isShiki = hasHtmlClass(node, "shiki") || node.attrs.style !== void 0 || node.attrs["data-language"] !== void 0;
+    if (!isShiki)
+      return void 0;
+    const codeEl = findHtmlElement(node, (el) => el.tag === "code");
+    const codeClass = codeEl?.attrs.class ?? "";
+    const langClass = codeClass.match(/\blanguage-([A-Za-z0-9_-]+)/)?.[1];
+    const lang = node.attrs["data-language"] ?? langClass ?? "";
+    const code = ctx.text(node).replace(/\n$/, "");
+    const fence = fenceFor2(code);
+    return `${fence}${lang}
+${code}
+${fence}`;
+  };
+  var fenceFor2 = (code) => {
+    const longest = Math.max(0, ...(code.match(/`+/g) ?? []).map((run) => run.length));
+    return "`".repeat(Math.max(3, longest + 1));
+  };
   var fallback = (node, ctx) => {
     const language = node.lang ? ` class="language-${ctx.escape(node.lang)}"` : "";
     return `<pre><code${language}>${ctx.escape(node.code)}</code></pre>`;
@@ -5954,8 +6454,17 @@ ${body}
       afterParse(ast) {
         return fillTocBlocks(ast, options);
       }
-    }
+    },
+    htmlToMarkdown: tocToMarkdown(options)
   });
+  var tocToMarkdown = (options = {}) => {
+    const className = options.className ?? "toc";
+    return (node) => {
+      if (node.type !== "element" || node.tag !== "nav" || !hasHtmlClass(node, className))
+        return void 0;
+      return "[[toc]]";
+    };
+  };
   var fillTocBlocks = (ast, options = {}) => {
     const minDepth = options.minDepth ?? 2;
     const maxDepth = options.maxDepth ?? 6;
@@ -5989,7 +6498,24 @@ ${body}
         afterParse(ast) {
           return transformTypography(ast, options);
         }
-      }
+      },
+      htmlToMarkdown: typographyToMarkdown(options)
+    };
+  };
+  var typographyToMarkdown = (options = {}) => {
+    const mark = options.mark !== false;
+    const subscript = options.subscript !== false;
+    const superscript = options.superscript !== false;
+    return (node, ctx) => {
+      if (node.type !== "element" || Object.keys(node.attrs).length > 0)
+        return void 0;
+      if (node.tag === "mark" && mark)
+        return `==${ctx.inline(node)}==`;
+      if (node.tag === "sub" && subscript)
+        return `~${ctx.inline(node)}~`;
+      if (node.tag === "sup" && superscript)
+        return `^${ctx.inline(node)}^`;
+      return void 0;
     };
   };
   var transformTypography = (ast, options = {}) => {
@@ -6045,11 +6571,11 @@ ${body}
       if (match.index > lastIndex)
         nodes.push({ type: "text", value: value.slice(lastIndex, match.index) });
       if (match[1] !== void 0 && mark)
-        nodes.push({ type: "inlineHtml", value: `<mark>${escapeHtml11(match[1])}</mark>` });
+        nodes.push({ type: "inlineHtml", value: `<mark>${escapeHtml12(match[1])}</mark>` });
       else if (match[2] !== void 0 && subscript)
-        nodes.push({ type: "inlineHtml", value: `<sub>${escapeHtml11(match[2])}</sub>` });
+        nodes.push({ type: "inlineHtml", value: `<sub>${escapeHtml12(match[2])}</sub>` });
       else if (match[3] !== void 0 && superscript)
-        nodes.push({ type: "inlineHtml", value: `<sup>${escapeHtml11(match[3])}</sup>` });
+        nodes.push({ type: "inlineHtml", value: `<sup>${escapeHtml12(match[3])}</sup>` });
       else
         nodes.push({ type: "text", value: match[0] });
       lastIndex = pattern.lastIndex;
@@ -6058,7 +6584,7 @@ ${body}
       nodes.push({ type: "text", value: value.slice(lastIndex) });
     return nodes;
   };
-  var escapeHtml11 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  var escapeHtml12 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 
   // src/index.ts
   var supportedPlugins = [
@@ -6139,6 +6665,13 @@ ${body}
       defaultEnabled: false,
       category: "block"
     },
+    {
+      id: "hidden-comments",
+      label: "Hidden Comments",
+      description: "Control how Markdown HTML comments render in documents.",
+      defaultEnabled: false,
+      category: "core-behavior"
+    },
     {
       id: "media",
       label: "Media",
@@ -6217,6 +6750,7 @@ ${body}
     "frontmatter-ui": (options) => frontmatterUiPlugin(options["frontmatter-ui"]),
     gfm: (options) => gfmPlugins(options.gfm),
     "heading-anchors": (options) => headingAnchorsPlugin(options["heading-anchors"]),
+    "hidden-comments": (options) => hiddenCommentsPlugin(options["hidden-comments"]),
     math: (options) => mathPlugin(options.math),
     media: (options) => mediaPlugin(options.media),
     sanitize: (options) => sanitizePlugin(options.sanitize),
@@ -6233,11 +6767,31 @@ ${body}
   };
   function useNizelKit(options = {}) {
     const { enabledPlugins, pluginOptions, plugins = [], ...nizelOptions } = options;
-    return useBrowserNizel({
+    const resolvedPlugins = [...createPlugins(enabledPlugins, pluginOptions), ...plugins];
+    const processor = useBrowserNizel({
       ...nizelOptions,
-      plugins: [...createPlugins(enabledPlugins, pluginOptions), ...plugins]
+      plugins: resolvedPlugins
     });
+    const htmlToMarkdown3 = processor.htmlToMarkdown.bind(processor);
+    processor.htmlToMarkdown = (source, reverseOptions) => {
+      return htmlToMarkdown3(source, withKitHtmlToMarkdownPlugins(reverseOptions, resolvedPlugins));
+    };
+    const nodeToMarkdown2 = processor.nodeToMarkdown.bind(processor);
+    processor.nodeToMarkdown = (source, reverseOptions) => {
+      return nodeToMarkdown2(source, withKitHtmlToMarkdownPlugins(reverseOptions, resolvedPlugins));
+    };
+    const selectionToMarkdown2 = processor.selectionToMarkdown.bind(processor);
+    processor.selectionToMarkdown = (selection, reverseOptions) => {
+      return selectionToMarkdown2(selection, withKitHtmlToMarkdownPlugins(reverseOptions, resolvedPlugins));
+    };
+    return processor;
   }
+  var withKitHtmlToMarkdownPlugins = (options, plugins) => {
+    return {
+      ...options,
+      plugins: [...plugins, ...options?.plugins ?? []]
+    };
+  };
   async function markdownToHtml(markdown, options) {
     return useNizelKit(options).html(markdown);
   }