@anweb/nuxt-aneditor 0.1.1

package/dist/runtime/composables/useList.js

@@ -0,0 +1,116 @@
+export const useList = (refContent, sel, syncToModel, ensureBlockWrapped, isInsideCodeBlock) => {
+  const findParentLi = () => {
+    const s = sel.getSelection();
+    if (!s) return null;
+    let node = s.range.commonAncestorContainer;
+    if (node.nodeType === Node.TEXT_NODE) node = node.parentNode;
+    while (node && node !== refContent.value) {
+      if (node instanceof HTMLElement && node.tagName.toLowerCase() === "li") {
+        return node;
+      }
+      node = node.parentNode;
+    }
+    return null;
+  };
+  const indentListItem = (li) => {
+    const prevLi = li.previousElementSibling;
+    if (!prevLi || prevLi.tagName.toLowerCase() !== "li") return;
+    const parentList = li.parentElement;
+    const listTag = parentList.tagName.toLowerCase();
+    const offset = sel.getCaretOffset(li);
+    let nestedList = prevLi.querySelector(`:scope > ${listTag}`);
+    if (!nestedList) {
+      nestedList = document.createElement(listTag);
+      prevLi.appendChild(nestedList);
+    }
+    nestedList.appendChild(li);
+    sel.restoreCaretOffset(li, offset);
+    syncToModel();
+  };
+  const outdentListItem = (li) => {
+    const parentList = li.parentElement;
+    if (!parentList) return;
+    const parentLi = parentList.parentElement;
+    if (!parentLi || parentLi.tagName.toLowerCase() !== "li") return;
+    const grandparentList = parentLi.parentElement;
+    if (!grandparentList) return;
+    const offset = sel.getCaretOffset(li);
+    const siblings = [];
+    let sibling = li.nextElementSibling;
+    while (sibling) {
+      siblings.push(sibling);
+      sibling = sibling.nextElementSibling;
+    }
+    grandparentList.insertBefore(li, parentLi.nextSibling);
+    if (siblings.length > 0) {
+      const newNested = document.createElement(parentList.tagName.toLowerCase());
+      for (const s of siblings) {
+        newNested.appendChild(s);
+      }
+      li.appendChild(newNested);
+    }
+    if (parentList.children.length === 0) {
+      parentList.remove();
+    }
+    sel.restoreCaretOffset(li, offset);
+    syncToModel();
+  };
+  const convertToList = (tagName) => {
+    if (isInsideCodeBlock()) return;
+    const block = ensureBlockWrapped();
+    if (!block) return;
+    const offset = sel.getCaretOffset(block);
+    if (block.tagName.toLowerCase() === tagName) {
+      const items = block.querySelectorAll(":scope > li");
+      const fragment = document.createDocumentFragment();
+      let cursorTarget = null;
+      items.forEach((li2) => {
+        const p = document.createElement("p");
+        let content = "";
+        for (const node of li2.childNodes) {
+          if (node instanceof HTMLElement) {
+            const t = node.tagName.toLowerCase();
+            if (t === "ul" || t === "ol") continue;
+          }
+          content += node.outerHTML ?? node.textContent ?? "";
+        }
+        p.innerHTML = content.trim() || "<br>";
+        fragment.appendChild(p);
+        if (!cursorTarget) cursorTarget = p;
+      });
+      if (!fragment.childNodes.length) {
+        const p = document.createElement("p");
+        p.innerHTML = block.innerHTML || "<br>";
+        fragment.appendChild(p);
+        cursorTarget = p;
+      }
+      block.replaceWith(fragment);
+      if (cursorTarget) sel.restoreCaretOffset(cursorTarget, offset);
+      syncToModel();
+      return;
+    }
+    const list = document.createElement(tagName);
+    const li = document.createElement("li");
+    if (block.tagName.toLowerCase() === "ul" || block.tagName.toLowerCase() === "ol") {
+      for (const existingLi of block.querySelectorAll(":scope > li")) {
+        const newLi = document.createElement("li");
+        for (const node of existingLi.childNodes) {
+          newLi.appendChild(node.cloneNode(true));
+        }
+        list.appendChild(newLi);
+      }
+    } else {
+      li.innerHTML = block.innerHTML;
+      list.appendChild(li);
+    }
+    block.replaceWith(list);
+    sel.restoreCaretOffset(list, offset);
+    syncToModel();
+  };
+  return {
+    findParentLi,
+    indentListItem,
+    outdentListItem,
+    convertToList
+  };
+};

package/dist/runtime/composables/useSelection.d.ts

@@ -0,0 +1,20 @@
+import type { Ref } from 'vue';
+export declare const useSelection: (refContent: Ref<HTMLDivElement | null>) => {
+    getSelection: () => {
+        selection: Selection;
+        range: Range;
+    } | null;
+    getTextOffset: (root: Node, targetNode: Node, targetOffset: number) => number;
+    getCaretOffset: (root: Node) => number;
+    getCaretOffsetInContent: () => number;
+    getSelectionOffsets: (root: Node) => {
+        start: number;
+        end: number;
+    };
+    findTextPosition: (root: Node, offset: number) => {
+        node: Node;
+        offset: number;
+    } | null;
+    restoreCaretOffset: (root: Node, offset: number) => void;
+    restoreSelectionOffsets: (root: Node, start: number, end: number) => void;
+};

package/dist/runtime/composables/useSelection.js

@@ -0,0 +1,92 @@
+export const useSelection = (refContent) => {
+  const getSelection = () => {
+    const selection = window.getSelection();
+    if (!selection || selection.rangeCount === 0) return null;
+    if (!refContent.value?.contains(selection.anchorNode)) return null;
+    return { selection, range: selection.getRangeAt(0) };
+  };
+  const getTextOffset = (root, targetNode, targetOffset) => {
+    const range = document.createRange();
+    range.selectNodeContents(root);
+    range.setEnd(targetNode, targetOffset);
+    return range.toString().length;
+  };
+  const getCaretOffset = (root) => {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0) return 0;
+    return getTextOffset(root, sel.anchorNode, sel.anchorOffset);
+  };
+  const getCaretOffsetInContent = () => {
+    if (!refContent.value) return 0;
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0) return 0;
+    if (!refContent.value.contains(sel.anchorNode)) return 0;
+    return getTextOffset(refContent.value, sel.anchorNode, sel.anchorOffset);
+  };
+  const getSelectionOffsets = (root) => {
+    const sel = window.getSelection();
+    if (!sel || sel.rangeCount === 0) return { start: 0, end: 0 };
+    const range = sel.getRangeAt(0);
+    const start = getTextOffset(root, range.startContainer, range.startOffset);
+    const end = getTextOffset(root, range.endContainer, range.endOffset);
+    return { start, end };
+  };
+  const findTextPosition = (root, offset) => {
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    let remaining = offset;
+    while (walker.nextNode()) {
+      const textNode = walker.currentNode;
+      const len = textNode.textContent?.length ?? 0;
+      if (remaining <= len) {
+        return { node: textNode, offset: remaining };
+      }
+      remaining -= len;
+    }
+    return null;
+  };
+  const restoreCaretOffset = (root, offset) => {
+    const pos = findTextPosition(root, offset);
+    const selection = window.getSelection();
+    if (pos) {
+      const range = document.createRange();
+      range.setStart(pos.node, pos.offset);
+      range.collapse(true);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    } else {
+      const range = document.createRange();
+      range.selectNodeContents(root);
+      range.collapse(false);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    }
+  };
+  const restoreSelectionOffsets = (root, start, end) => {
+    const startPos = findTextPosition(root, start);
+    const endPos = findTextPosition(root, end);
+    const selection = window.getSelection();
+    if (startPos && endPos) {
+      const range = document.createRange();
+      range.setStart(startPos.node, startPos.offset);
+      range.setEnd(endPos.node, endPos.offset);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    } else if (startPos) {
+      const range = document.createRange();
+      range.setStart(startPos.node, startPos.offset);
+      range.collapse(true);
+      selection?.removeAllRanges();
+      selection?.addRange(range);
+    }
+  };
+  return {
+    getSelection,
+    getTextOffset,
+    getCaretOffset,
+    getCaretOffsetInContent,
+    getSelectionOffsets,
+    findTextPosition,
+    restoreCaretOffset,
+    restoreSelectionOffsets
+  };
+};

package/dist/runtime/composables/useTable.d.ts

@@ -0,0 +1,29 @@
+import { type Ref } from 'vue';
+export declare const useTable: (refContent: Ref<HTMLDivElement | null>, syncToModel: () => void) => {
+    activeTable: Ref<{
+        table: HTMLElement;
+        cell: HTMLElement;
+    } | null, {
+        table: HTMLElement;
+        cell: HTMLElement;
+    } | {
+        table: HTMLElement;
+        cell: HTMLElement;
+    } | null>;
+    createTableElement: (rows: number, cols: number) => HTMLElement;
+    tableAddRow: (position: "above" | "below") => void;
+    tableAddColumn: (position: "left" | "right") => void;
+    tableDelete: () => void;
+    tableDeleteRow: () => void;
+    tableDeleteColumn: () => void;
+    isHeaderCell: import("vue").ComputedRef<boolean>;
+    canAddHeader: import("vue").ComputedRef<boolean>;
+    tableAddHeader: () => void;
+    tableActionsStyle: import("vue").ComputedRef<{
+        top?: undefined;
+        left?: undefined;
+    } | {
+        top: string;
+        left: string;
+    }>;
+};

package/dist/runtime/composables/useTable.js

@@ -0,0 +1,175 @@
+import { ref, computed } from "vue";
+export const useTable = (refContent, syncToModel) => {
+  const activeTable = ref(null);
+  const createTableElement = (rows, cols) => {
+    const table = document.createElement("table");
+    table.className = "an-editor__table";
+    const thead = document.createElement("thead");
+    const headerRow = document.createElement("tr");
+    for (let c = 0; c < cols; c++) {
+      const th = document.createElement("th");
+      th.innerHTML = "<br>";
+      headerRow.appendChild(th);
+    }
+    thead.appendChild(headerRow);
+    table.appendChild(thead);
+    const tbody = document.createElement("tbody");
+    for (let r = 0; r < rows; r++) {
+      const tr = document.createElement("tr");
+      for (let c = 0; c < cols; c++) {
+        const td = document.createElement("td");
+        td.innerHTML = "<br>";
+        tr.appendChild(td);
+      }
+      tbody.appendChild(tr);
+    }
+    table.appendChild(tbody);
+    return table;
+  };
+  const tableAddRow = (position) => {
+    if (!activeTable.value) return;
+    const { cell } = activeTable.value;
+    const row = cell.parentElement;
+    const isHeader = row.parentElement?.tagName.toLowerCase() === "thead";
+    const colCount = row.cells.length;
+    const newRow = document.createElement("tr");
+    for (let i = 0; i < colCount; i++) {
+      const td = document.createElement("td");
+      td.innerHTML = "<br>";
+      newRow.appendChild(td);
+    }
+    if (isHeader) {
+      const tbody = row.closest("table")?.querySelector("tbody");
+      if (tbody) {
+        tbody.insertBefore(newRow, tbody.firstChild);
+      }
+    } else {
+      if (position === "above") {
+        row.parentNode.insertBefore(newRow, row);
+      } else {
+        row.parentNode.insertBefore(newRow, row.nextSibling);
+      }
+    }
+    activeTable.value = null;
+    syncToModel();
+  };
+  const tableAddColumn = (position) => {
+    if (!activeTable.value) return;
+    const { table, cell } = activeTable.value;
+    const colIndex = Array.from(cell.parentElement.children).indexOf(cell);
+    for (const row of table.querySelectorAll("tr")) {
+      const cells = row.children;
+      const isHeader = row.parentElement?.tagName.toLowerCase() === "thead";
+      const newCell = document.createElement(isHeader ? "th" : "td");
+      newCell.innerHTML = "<br>";
+      const refCell = cells[colIndex];
+      if (position === "left") {
+        row.insertBefore(newCell, refCell || null);
+      } else {
+        row.insertBefore(newCell, refCell?.nextSibling ?? null);
+      }
+    }
+    activeTable.value = null;
+    syncToModel();
+  };
+  const tableDelete = () => {
+    if (!activeTable.value) return;
+    const { table } = activeTable.value;
+    const next = table.nextElementSibling;
+    table.remove();
+    if (next && next.tagName === "P" && (!next.textContent || next.textContent.trim() === "") && next.innerHTML === "<br>") {
+      next.remove();
+    }
+    activeTable.value = null;
+    syncToModel();
+  };
+  const tableDeleteRow = () => {
+    if (!activeTable.value) return;
+    const { table, cell } = activeTable.value;
+    const row = cell.parentElement;
+    const isHeader = row.parentElement?.tagName.toLowerCase() === "thead";
+    if (isHeader) {
+      const thead = row.parentElement;
+      thead.remove();
+      activeTable.value = null;
+      syncToModel();
+      return;
+    }
+    const tbody = table.querySelector("tbody");
+    if (tbody && tbody.querySelectorAll("tr").length <= 1) {
+      tableDelete();
+      return;
+    }
+    row.remove();
+    activeTable.value = null;
+    syncToModel();
+  };
+  const tableDeleteColumn = () => {
+    if (!activeTable.value) return;
+    const { table, cell } = activeTable.value;
+    const colIndex = Array.from(cell.parentElement.children).indexOf(cell);
+    const allRows = table.querySelectorAll("tr");
+    const colCount = allRows[0]?.children.length ?? 0;
+    if (colCount <= 1) {
+      tableDelete();
+      return;
+    }
+    for (const row of allRows) {
+      const cellToRemove = row.children[colIndex];
+      if (cellToRemove) cellToRemove.remove();
+    }
+    activeTable.value = null;
+    syncToModel();
+  };
+  const isHeaderCell = computed(() => {
+    if (!activeTable.value) return false;
+    const row = activeTable.value.cell.parentElement;
+    return row?.parentElement?.tagName.toLowerCase() === "thead";
+  });
+  const canAddHeader = computed(() => {
+    if (!activeTable.value) return false;
+    const { table } = activeTable.value;
+    return !table.querySelector("thead");
+  });
+  const tableAddHeader = () => {
+    if (!activeTable.value) return;
+    const { table } = activeTable.value;
+    if (table.querySelector("thead")) return;
+    const firstRow = table.querySelector("tbody > tr");
+    const colCount = firstRow?.children.length ?? 1;
+    const thead = document.createElement("thead");
+    const tr = document.createElement("tr");
+    for (let i = 0; i < colCount; i++) {
+      const th = document.createElement("th");
+      th.innerHTML = "<br>";
+      tr.appendChild(th);
+    }
+    thead.appendChild(tr);
+    table.insertBefore(thead, table.firstChild);
+    activeTable.value = null;
+    syncToModel();
+  };
+  const tableActionsStyle = computed(() => {
+    if (!activeTable.value) return {};
+    const rect = activeTable.value.cell.getBoundingClientRect();
+    const editorRect = refContent.value?.getBoundingClientRect();
+    if (!editorRect) return {};
+    return {
+      top: `${rect.bottom - editorRect.top + 4}px`,
+      left: `${rect.left - editorRect.left}px`
+    };
+  });
+  return {
+    activeTable,
+    createTableElement,
+    tableAddRow,
+    tableAddColumn,
+    tableDelete,
+    tableDeleteRow,
+    tableDeleteColumn,
+    isHeaderCell,
+    canAddHeader,
+    tableAddHeader,
+    tableActionsStyle
+  };
+};

package/dist/runtime/types/global.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleOptions } from '../../module'
+
+
+declare module 'nuxt/schema' {
+	interface NuxtConfig {
+		aneditor?: ModuleOptions
+	}
+}

package/dist/runtime/types/index.d.ts

@@ -0,0 +1 @@
+export * from './global.js';

package/dist/runtime/types/index.js

@@ -0,0 +1 @@
+export * from "./global";

package/dist/runtime/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './parseMarkdown.js';
+export * from './toMarkdown.js';
+export * from './youtube.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,3 @@
+export * from "./parseMarkdown.js";
+export * from "./toMarkdown.js";
+export * from "./youtube.js";

package/dist/runtime/utils/parseMarkdown.d.ts

@@ -0,0 +1 @@
+export declare const parseMarkdown: (md: string) => string;

package/dist/runtime/utils/parseMarkdown.js

@@ -0,0 +1,184 @@
+import { extractYouTubeId } from "./youtube.js";
+export const parseMarkdown = (md) => {
+  if (!md || !md.trim()) return "";
+  const placeholders = /* @__PURE__ */ new Map();
+  let idx = 0;
+  const ph = (html) => {
+    const key = `\0PH${idx++}\0`;
+    placeholders.set(key, html);
+    return key;
+  };
+  let text = md.replace(/```(\w*)\n([\s\S]*?)```/g, (_match, lang, code) => {
+    const cls = lang ? ` class="language-${escapeHtml(lang)}"` : "";
+    return ph(`<pre class="an-editor__codeblock"><code${cls}>${escapeHtml(code.replace(/\n$/, ""))}</code></pre>`);
+  });
+  text = text.replace(/`([^`]+)`/g, (_match, code) => {
+    return ph(`<code class="an-editor__code">${escapeHtml(code)}</code>`);
+  });
+  const blocks = text.split(/\n{2,}/);
+  const output = [];
+  for (let i = 0; i < blocks.length; i++) {
+    const block = blocks[i].trim();
+    if (!block) continue;
+    if (/^(-{3,}|\*{3,}|_{3,})$/.test(block)) {
+      output.push("<hr>");
+      continue;
+    }
+    const headingMatch = block.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch) {
+      const level = headingMatch[1].length;
+      output.push(`<h${level}>${processInline(headingMatch[2])}</h${level}>`);
+      continue;
+    }
+    const blockLines = block.split("\n");
+    if (isListLine(blockLines[0])) {
+      const allList = blockLines.every((l) => isListLine(l));
+      if (allList) {
+        const { items } = parseListBlock(blockLines, 0);
+        output.push(renderList(items));
+        continue;
+      }
+    }
+    if (blockLines.every((l) => /^>\s?/.test(l))) {
+      const content = blockLines.map((l) => l.replace(/^>\s?/, "")).join("\n");
+      output.push(`<blockquote>${processInline(content)}</blockquote>`);
+      continue;
+    }
+    const tableHtml = parseTable(block);
+    if (tableHtml) {
+      output.push(tableHtml);
+      continue;
+    }
+    const ytId = extractYouTubeId(block);
+    if (ytId && /^https?:\/\//.test(block.trim())) {
+      output.push(`<div class="an-editor__youtube"><iframe src="https://www.youtube-nocookie.com/embed/${ytId}" style="border:none" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe></div>`);
+      continue;
+    }
+    const imgMatch = block.match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
+    if (imgMatch) {
+      output.push(`<figure class="an-editor__image"><img src="${escapeHtml(imgMatch[2])}" alt="${escapeHtml(imgMatch[1])}" /></figure>`);
+      continue;
+    }
+    const imgHtmlMatch = block.match(/^<img\s+([^>]+?)\s*\/?>$/);
+    if (imgHtmlMatch) {
+      const attrs = imgHtmlMatch[1];
+      const srcM = attrs.match(/src="([^"]*)"/);
+      const altM = attrs.match(/alt="([^"]*)"/);
+      const widthM = attrs.match(/width="([^"]*)"/);
+      if (srcM) {
+        const src = escapeHtml(srcM[1]);
+        const alt = altM ? escapeHtml(altM[1]) : "";
+        const widthAttr = widthM ? ` style="width:${escapeHtml(widthM[1])}"` : "";
+        output.push(`<figure class="an-editor__image"><img src="${src}" alt="${alt}"${widthAttr} /></figure>`);
+        continue;
+      }
+    }
+    const lines = block.split("\n").map((l) => processInline(l)).join("<br>");
+    output.push(`<p>${lines}</p>`);
+  }
+  let result = output.join("\n");
+  for (const [key, value] of placeholders) {
+    result = result.replaceAll(key, value);
+  }
+  return result;
+};
+const escapeHtml = (text) => {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+};
+const processInline = (text) => {
+  text = text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" />');
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+  text = text.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+  text = text.replace(/\*(.+?)\*/g, "<em>$1</em>");
+  text = text.replace(/~~(.+?)~~/g, "<s>$1</s>");
+  return text;
+};
+const parseListBlock = (lines, startIndent = 0) => {
+  const items = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    const indentMatch = line.match(/^(\s*)/);
+    const indent = indentMatch ? indentMatch[1].length : 0;
+    const ulMatch = line.match(/^(\s*)[-*]\s+(.*)$/);
+    const olMatch = line.match(/^(\s*)\d+\.\s+(.*)$/);
+    const match = ulMatch || olMatch;
+    if (!match) break;
+    const itemIndent = match[1].length;
+    if (itemIndent < startIndent && i > 0) break;
+    if (itemIndent > startIndent) {
+      const nested = parseListBlock(lines.slice(i), itemIndent);
+      if (items.length > 0) {
+        items[items.length - 1].children = nested.items;
+      }
+      i += nested.consumed;
+      continue;
+    }
+    const content = match[2];
+    const type = ulMatch ? "ul" : "ol";
+    items.push({ content, children: [], type });
+    i++;
+  }
+  return { items, consumed: i };
+};
+const renderList = (items) => {
+  if (items.length === 0) return "";
+  const type = items[0].type;
+  let html = `<${type}>`;
+  for (const item of items) {
+    html += `<li>`;
+    html += processInline(item.content);
+    if (item.children.length > 0) {
+      html += renderList(item.children);
+    }
+    html += "</li>";
+  }
+  html += `</${type}>`;
+  return html;
+};
+const isListLine = (line) => {
+  return /^\s*[-*]\s+/.test(line) || /^\s*\d+\.\s+/.test(line);
+};
+const parseTable = (block) => {
+  const lines = block.split("\n").filter((l) => l.trim());
+  if (lines.length < 2) return null;
+  const sepLine = lines[1].trim();
+  if (!/^\|?(\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?$/.test(sepLine)) return null;
+  const parseCells = (line) => {
+    let trimmed = line.trim();
+    if (trimmed.startsWith("|")) trimmed = trimmed.slice(1);
+    if (trimmed.endsWith("|")) trimmed = trimmed.slice(0, -1);
+    return trimmed.split("|").map((c) => c.trim());
+  };
+  const parseAlign = (line) => {
+    return parseCells(line).map((cell) => {
+      const t = cell.trim();
+      const left = t.startsWith(":");
+      const right = t.endsWith(":");
+      if (left && right) return "center";
+      if (right) return "right";
+      return "left";
+    });
+  };
+  const headers = parseCells(lines[0]);
+  const aligns = parseAlign(lines[1]);
+  let html = '<table class="an-editor__table"><thead><tr>';
+  headers.forEach((h, i) => {
+    const align = aligns[i] && aligns[i] !== "left" ? ` style="text-align:${aligns[i]}"` : "";
+    const content = processInline(h) || "<br>";
+    html += `<th${align}>${content}</th>`;
+  });
+  html += "</tr></thead><tbody>";
+  for (let r = 2; r < lines.length; r++) {
+    const cells = parseCells(lines[r]);
+    html += "<tr>";
+    cells.forEach((c, ci) => {
+      const align = aligns[ci] && aligns[ci] !== "left" ? ` style="text-align:${aligns[ci]}"` : "";
+      const content = processInline(c) || "<br>";
+      html += `<td${align}>${content}</td>`;
+    });
+    html += "</tr>";
+  }
+  html += "</tbody></table>";
+  return html;
+};

package/dist/runtime/utils/toMarkdown.d.ts

@@ -0,0 +1 @@
+export declare const toMarkdown: (html: string) => string;