nizel-kit 0.1.9 → 0.1.11

package/dist/nizel-kit.js

@@ -32,8 +32,36 @@ var blockTags = /* @__PURE__ */ new Set([
 ]);
 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: [] };
@@ -135,25 +163,31 @@ function hasUnsupportedAttrs(node) {
 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")
@@ -175,13 +209,13 @@ function renderNode(node, options, depth) {
   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();
@@ -190,9 +224,9 @@ function renderNode(node, options, depth) {
   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;
@@ -225,19 +259,19 @@ function renderCodeBlock(node) {
 ${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);
@@ -334,6 +368,20 @@ function longestRun(value, char) {
   }
   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) {
@@ -2374,6 +2422,10 @@ function mergeOptions(left, right) {
       ...left.variables ?? {},
       ...right.variables ?? {}
     },
+    meta: {
+      ...left.meta ?? {},
+      ...right.meta ?? {}
+    },
     elements: {
       ...left.elements ?? {},
       ...right.elements ?? {}
@@ -4845,7 +4897,22 @@ var abbrPlugin = (options = {}) => {
       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) => {
@@ -4913,7 +4980,25 @@ var alertPlugin = (options = {}) => {
     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) => {
@@ -4998,9 +5083,21 @@ var autolinkPlugin = (options = {}) => {
     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 = {}) => {
@@ -5023,9 +5120,34 @@ var codeCopyPlugin = (options = {}) => {
     },
     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)
@@ -5102,7 +5224,28 @@ var citationsPlugin = (options = {}) => {
       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) => {
@@ -5204,9 +5347,28 @@ var deflistPlugin = (options = {}) => {
       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 = [];
@@ -5293,8 +5455,23 @@ var detailsPlugin = (options = {}) => ({
   },
   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, "::");
 };
@@ -5324,7 +5501,19 @@ var diagramsPlugin = (options = {}) => {
       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 = {}) => ({
@@ -5469,9 +5658,45 @@ var footnotesPlugin = (options = {}) => {
     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 = [];
@@ -5617,9 +5842,46 @@ var taskListPlugin = (options = {}) => {
       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)) };
 };
@@ -5701,8 +5963,17 @@ var headingAnchorsPlugin = (options = {}) => ({
     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) => {
@@ -5722,6 +5993,177 @@ var addHeadingAnchors = (ast, options = {}) => ({
 });
 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 {
@@ -5734,7 +6176,26 @@ var mathPlugin = (options = {}) => {
       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) => {
@@ -5820,7 +6281,7 @@ var transformText2 = (value, options) => {
       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;
   }
@@ -5828,7 +6289,7 @@ var transformText2 = (value, options) => {
     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 = {}) => ({
@@ -5837,8 +6298,26 @@ var mediaPlugin = (options = {}) => ({
     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;
@@ -5846,7 +6325,7 @@ var enhanceImages = (html, options = {}) => {
   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) => {
@@ -5857,7 +6336,7 @@ var enhanceImageTag = (img, options) => {
     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 = {}) => ({
@@ -5901,9 +6380,30 @@ var shikiPlugin = (options = {}) => {
           }
         }
       }
-    }
+    },
+    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>`;
@@ -5922,8 +6422,17 @@ var tocPlugin = (options = {}) => ({
     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;
@@ -5957,7 +6466,24 @@ var typographyPlugin = (options = {}) => {
       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 = {}) => {
@@ -6013,11 +6539,11 @@ var transformText3 = (value, options) => {
     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;
@@ -6026,7 +6552,7 @@ var transformText3 = (value, options) => {
     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 = [
@@ -6107,6 +6633,13 @@ var supportedPlugins = [
     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",
@@ -6185,6 +6718,7 @@ var factories = {
   "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),
@@ -6201,11 +6735,31 @@ var createPlugins = (enabledPlugins = defaultEnabledPlugins(), options = {}) =>
 };
 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);
 }