@pinkpixel/marzipan 1.0.5

package/dist/index.js

@@ -0,0 +1,3212 @@
+const N = class N {
+  /**
+   * Reset link index (call before parsing a new document)
+   */
+  static resetLinkIndex() {
+    this.linkIndex = 0;
+  }
+  /**
+   * Escape HTML special characters
+   * @param {string} text - Raw text to escape
+   * @returns {string} Escaped HTML-safe text
+   */
+  static escapeHtml(e) {
+    const t = {
+      "&": "&",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;"
+    };
+    return e.replace(/[&<>"']/g, (n) => t[n]);
+  }
+  /**
+   * Preserve leading spaces as non-breaking spaces
+   * @param {string} html - HTML string
+   * @param {string} originalLine - Original line with spaces
+   * @returns {string} HTML with preserved indentation
+   */
+  static preserveIndentation(e, t) {
+    const r = t.match(/^(\s*)/)[1].replace(/ /g, "&nbsp;");
+    return e.replace(/^\s*/, r);
+  }
+  /**
+   * Parse headers (h1-h3 only)
+   * @param {string} html - HTML line to parse
+   * @returns {string} Parsed HTML with header styling
+   */
+  static parseHeader(e) {
+    return e.replace(/^(#{1,3})\s(.+)$/, (t, n, r) => {
+      const o = n.length;
+      return `<h${o}><span class="syntax-marker">${n} </span>${r}</h${o}>`;
+    });
+  }
+  /**
+   * Parse horizontal rules
+   * @param {string} html - HTML line to parse
+   * @returns {string|null} Parsed horizontal rule or null
+   */
+  static parseHorizontalRule(e) {
+    return e.match(/^(-{3,}|\*{3,}|_{3,})$/) ? `<div><span class="hr-marker">${e}</span></div>` : null;
+  }
+  /**
+   * Parse blockquotes
+   * @param {string} html - HTML line to parse
+   * @returns {string} Parsed blockquote
+   */
+  static parseBlockquote(e) {
+    return e.replace(/^&gt; (.+)$/, (t, n) => `<span class="blockquote"><span class="syntax-marker">&gt;</span> ${n}</span>`);
+  }
+  /**
+   * Parse bullet lists
+   * @param {string} html - HTML line to parse
+   * @returns {string} Parsed bullet list item
+   */
+  static parseBulletList(e) {
+    return e.replace(/^((?:&nbsp;)*)([-*])\s(.+)$/, (t, n, r, o) => `${n}<li class="bullet-list"><span class="syntax-marker">${r} </span>${o}</li>`);
+  }
+  /**
+   * Parse numbered lists
+   * @param {string} html - HTML line to parse
+   * @returns {string} Parsed numbered list item
+   */
+  static parseNumberedList(e) {
+    return e.replace(/^((?:&nbsp;)*)(\d+\.)\s(.+)$/, (t, n, r, o) => `${n}<li class="ordered-list"><span class="syntax-marker">${r} </span>${o}</li>`);
+  }
+  /**
+   * Parse code blocks (markers only)
+   * @param {string} html - HTML line to parse
+   * @returns {string|null} Parsed code fence or null
+   */
+  static parseCodeBlock(e) {
+    return /^`{3}[^`]*$/.test(e) ? `<div><span class="code-fence">${e}</span></div>` : null;
+  }
+  /**
+   * Parse bold text
+   * @param {string} html - HTML with potential bold markdown
+   * @returns {string} HTML with bold styling
+   */
+  static parseBold(e) {
+    return e = e.replace(/\*\*(.+?)\*\*/g, '<strong><span class="syntax-marker">**</span>$1<span class="syntax-marker">**</span></strong>'), e = e.replace(/__(.+?)__/g, '<strong><span class="syntax-marker">__</span>$1<span class="syntax-marker">__</span></strong>'), e;
+  }
+  /**
+   * Parse italic text
+   * Note: Uses lookbehind assertions - requires modern browsers
+   * @param {string} html - HTML with potential italic markdown
+   * @returns {string} HTML with italic styling
+   */
+  static parseItalic(e) {
+    return e = e.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, '<em><span class="syntax-marker">*</span>$1<span class="syntax-marker">*</span></em>'), e = e.replace(/(?<=^|\s)_(?!_)(.+?)(?<!_)_(?!_)(?=\s|$)/g, '<em><span class="syntax-marker">_</span>$1<span class="syntax-marker">_</span></em>'), e;
+  }
+  /**
+   * Parse strikethrough text
+   * Supports both single (~) and double (~~) tildes, but rejects 3+ tildes
+   * @param {string} html - HTML with potential strikethrough markdown
+   * @returns {string} HTML with strikethrough styling
+   */
+  static parseStrikethrough(e) {
+    return e = e.replace(/(?<!~)~~(?!~)(.+?)(?<!~)~~(?!~)/g, '<del><span class="syntax-marker">~~</span>$1<span class="syntax-marker">~~</span></del>'), e = e.replace(/(?<!~)~(?!~)(.+?)(?<!~)~(?!~)/g, '<del><span class="syntax-marker">~</span>$1<span class="syntax-marker">~</span></del>'), e;
+  }
+  /**
+   * Check if line is a table row
+   * @param {string} html - HTML line to check
+   * @returns {boolean} True if table row
+   */
+  static isTableRow(e) {
+    return /^\|.+\|$/.test(e);
+  }
+  /**
+   * Check if line is a table separator row
+   * @param {string} html - HTML line to check
+   * @returns {boolean} True if table separator
+   */
+  static isTableSeparator(e) {
+    return /^\|\s*[-:]+\s*(?:\|\s*[-:]+\s*)*\|$/.test(e);
+  }
+  /**
+   * Parse a table row into cells
+   * @param {string} html - HTML table row
+   * @param {string} tag - Tag to use for cells (th or td)
+   * @returns {string} HTML table row
+   */
+  static parseTableRow(e, t = "td") {
+    return `<tr>${e.slice(1, -1).split(/(?<!\\)\|/).map((o) => {
+      const a = o.trim(), s = this.parseInlineElements(a || "&nbsp;");
+      return `<${t}>${s}</${t}>`;
+    }).join("")}</tr>`;
+  }
+  /**
+   * Parse inline code
+   * @param {string} html - HTML with potential code markdown
+   * @returns {string} HTML with code styling
+   */
+  static parseInlineCode(e) {
+    return e.replace(/(?<!`)(`+)(?!`)((?:(?!\1).)+?)(\1)(?!`)/g, '<code><span class="syntax-marker">$1</span>$2<span class="syntax-marker">$3</span></code>');
+  }
+  /**
+   * Parse markdown images
+   * @param {string} html - HTML with potential image markdown
+   * @returns {string} HTML with image tags
+   */
+  static parseImages(e) {
+    return e.replace(/!\[([^\]]*)\]\(([^\s)]+)(?:\s+"([^"]+)")?\)/g, (t, n, r, o) => {
+      const a = this.sanitizeUrl(r), s = this.escapeHtml(n || ""), c = o ? ` title="${this.escapeHtml(o)}"` : "";
+      return `<img src="${a}" alt="${s}"${c} class="marzipan-image" />`;
+    });
+  }
+  /**
+   * Sanitize URL to prevent XSS attacks
+   * @param {string} url - URL to sanitize
+   * @returns {string} Safe URL or '#' if dangerous
+   */
+  static sanitizeUrl(e) {
+    const t = e.trim(), n = t.toLowerCase(), o = [
+      "http://",
+      "https://",
+      "mailto:",
+      "ftp://",
+      "ftps://"
+    ].some((s) => n.startsWith(s)), a = t.startsWith("/") || t.startsWith("#") || t.startsWith("?") || t.startsWith(".") || !t.includes(":") && !t.includes("//");
+    return o || a ? e : "#";
+  }
+  /**
+   * Parse links
+   * @param {string} html - HTML with potential link markdown
+   * @returns {string} HTML with link styling
+   */
+  static parseLinks(e) {
+    return e.replace(/\[(.+?)\]\((.+?)\)/g, (t, n, r) => {
+      const o = `--link-${this.linkIndex++}`;
+      return `<a href="${this.sanitizeUrl(r)}" style="anchor-name: ${o}"><span class="syntax-marker">[</span>${n}<span class="syntax-marker url-part">](${r})</span></a>`;
+    });
+  }
+  /**
+   * Identify and protect sanctuaries (code and links) before parsing
+   * @param {string} text - Text with potential markdown
+   * @returns {Object} Object with protected text and sanctuary map
+   */
+  static identifyAndProtectSanctuaries(e) {
+    const t = /* @__PURE__ */ new Map();
+    let n = 0, r = e;
+    const o = [], a = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let s;
+    for (; (s = a.exec(e)) !== null; ) {
+      const m = s.index + s[0].indexOf("](") + 2, u = m + s[2].length;
+      o.push({ start: m, end: u });
+    }
+    const c = /(?<!`)(`+)(?!`)((?:(?!\1).)+?)(\1)(?!`)/g;
+    let p;
+    const d = [];
+    for (; (p = c.exec(e)) !== null; ) {
+      const l = p.index, m = p.index + p[0].length;
+      o.some(
+        (h) => l >= h.start && m <= h.end
+      ) || d.push({
+        match: p[0],
+        index: p.index,
+        openTicks: p[1],
+        content: p[2],
+        closeTicks: p[3]
+      });
+    }
+    return d.sort((l, m) => m.index - l.index), d.forEach((l) => {
+      const m = `${n++}`;
+      t.set(m, {
+        type: "code",
+        original: l.match,
+        openTicks: l.openTicks,
+        content: l.content,
+        closeTicks: l.closeTicks
+      }), r = r.substring(0, l.index) + m + r.substring(l.index + l.match.length);
+    }), r = r.replace(/!\[([^\]]*)\]\(([^\s)]+)(?:\s+"([^"]+)")?\)/g, (l, m, u, h) => {
+      const f = `${n++}`;
+      return t.set(f, {
+        type: "image",
+        original: l,
+        alt: m,
+        url: u,
+        title: h
+      }), f;
+    }), r = r.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (l, m, u) => {
+      const h = `${n++}`;
+      return t.set(h, {
+        type: "link",
+        original: l,
+        linkText: m,
+        url: u
+      }), h;
+    }), { protectedText: r, sanctuaries: t };
+  }
+  /**
+   * Restore and transform sanctuaries back to HTML
+   * @param {string} html - HTML with sanctuary placeholders
+   * @param {Map} sanctuaries - Map of sanctuaries to restore
+   * @returns {string} HTML with sanctuaries restored and transformed
+   */
+  static restoreAndTransformSanctuaries(e, t) {
+    return Array.from(t.keys()).sort((r, o) => {
+      const a = e.indexOf(r), s = e.indexOf(o);
+      return a - s;
+    }).forEach((r) => {
+      const o = t.get(r);
+      let a;
+      if (o.type === "code")
+        a = `<code><span class="syntax-marker">${o.openTicks}</span>${this.escapeHtml(o.content)}<span class="syntax-marker">${o.closeTicks}</span></code>`;
+      else if (o.type === "image") {
+        const s = this.sanitizeUrl(o.url), c = this.escapeHtml(o.alt || ""), p = o.title ? ` title="${this.escapeHtml(o.title)}"` : "";
+        a = `<img src="${s}" alt="${c}"${p} class="marzipan-image" />`;
+      } else if (o.type === "link") {
+        let s = o.linkText;
+        t.forEach((d, l) => {
+          if (s.includes(l) && d.type === "code") {
+            const m = `<code><span class="syntax-marker">${d.openTicks}</span>${this.escapeHtml(d.content)}<span class="syntax-marker">${d.closeTicks}</span></code>`;
+            s = s.replace(l, m);
+          }
+        }), s = this.parseStrikethrough(s), s = this.parseBold(s), s = this.parseItalic(s);
+        const c = `--link-${this.linkIndex++}`;
+        a = `<a href="${this.sanitizeUrl(o.url)}" style="anchor-name: ${c}"><span class="syntax-marker">[</span>${s}<span class="syntax-marker url-part">](${this.escapeHtml(o.url)})</span></a>`;
+      }
+      e = e.replace(r, a);
+    }), e;
+  }
+  /**
+   * Parse all inline elements in correct order
+   * @param {string} text - Text with potential inline markdown
+   * @returns {string} HTML with all inline styling
+   */
+  static parseInlineElements(e) {
+    const { protectedText: t, sanctuaries: n } = this.identifyAndProtectSanctuaries(e);
+    let r = t;
+    return r = this.parseStrikethrough(r), r = this.parseBold(r), r = this.parseItalic(r), r = this.restoreAndTransformSanctuaries(r, n), r;
+  }
+  /**
+   * Parse a single line of markdown
+   * @param {string} line - Raw markdown line
+   * @returns {string} Parsed HTML line
+   */
+  static parseLine(e) {
+    let t = this.escapeHtml(e);
+    t = this.preserveIndentation(t, e);
+    const n = this.parseHorizontalRule(t);
+    if (n) return n;
+    const r = this.parseCodeBlock(t);
+    return r || (t = this.parseHeader(t), t = this.parseBlockquote(t), t = this.parseBulletList(t), t = this.parseNumberedList(t), t = this.parseInlineElements(t), t.trim() === "" ? "<div>&nbsp;</div>" : `<div>${t}</div>`);
+  }
+  /**
+   * Parse full markdown text
+   * @param {string} text - Full markdown text
+   * @param {number} activeLine - Currently active line index (optional)
+   * @param {boolean} showActiveLineRaw - Show raw markdown on active line
+   * @returns {string} Parsed HTML
+   */
+  static parse(e, t = -1, n = !1) {
+    this.resetLinkIndex();
+    const r = e.split(`
+`);
+    let o = !1;
+    const s = r.map((c, p) => {
+      if (n && p === t)
+        return `<div class="raw-line">${this.escapeHtml(c) || "&nbsp;"}</div>`;
+      if (/^```[^`]*$/.test(c))
+        return o = !o, this.parseLine(c);
+      if (o) {
+        const m = this.escapeHtml(c);
+        return `<div>${this.preserveIndentation(m, c) || "&nbsp;"}</div>`;
+      }
+      const l = this.escapeHtml(c);
+      return this.isTableRow(l) ? this.isTableSeparator(l) ? `<div class="table-separator">${l}</div>` : `<div class="table-row">${l}</div>` : this.parseLine(c);
+    }).join("");
+    return this.postProcessHTML(s);
+  }
+  /**
+   * Post-process HTML to consolidate lists and code blocks
+   * @param {string} html - HTML to post-process
+   * @returns {string} Post-processed HTML with consolidated lists and code blocks
+   */
+  static postProcessHTML(e) {
+    if (typeof document > "u" || !document)
+      return this.postProcessHTMLManual(e);
+    const t = document.createElement("div");
+    t.innerHTML = e;
+    let n = null, r = null, o = null, a = !1, s = null, c = !1;
+    const p = Array.from(t.children);
+    for (let d = 0; d < p.length; d++) {
+      const l = p[d];
+      if (!l.parentNode) continue;
+      if (l.classList && (l.classList.contains("table-row") || l.classList.contains("table-separator"))) {
+        if (l.classList.contains("table-separator")) {
+          if (!s) {
+            l.remove();
+            continue;
+          }
+          c = !1, l.remove();
+          continue;
+        }
+        s || (s = document.createElement("table"), s.className = "marzipan-table", t.insertBefore(s, l), c = !0);
+        const f = l.textContent, g = c ? "th" : "td", b = this.parseTableRow(f, g);
+        let v;
+        c ? (v = s.querySelector("thead"), v || (v = document.createElement("thead"), s.appendChild(v))) : (v = s.querySelector("tbody"), v || (v = document.createElement("tbody"), s.appendChild(v))), v.innerHTML += b, l.remove();
+        continue;
+      } else
+        s = null, c = !1;
+      const m = l.querySelector(".code-fence");
+      if (m) {
+        const h = m.textContent;
+        if (h.startsWith("```"))
+          if (a) {
+            a = !1, o = null;
+            continue;
+          } else {
+            a = !0, o = document.createElement("pre");
+            const f = document.createElement("code");
+            o.appendChild(f), o.className = "code-block";
+            const g = h.slice(3).trim();
+            g && (f.className = `language-${g}`), t.insertBefore(o, l.nextSibling), o._codeElement = f;
+            continue;
+          }
+      }
+      if (a && o && l.tagName === "DIV" && !l.querySelector(".code-fence")) {
+        const h = o._codeElement || o.querySelector("code");
+        h.textContent.length > 0 && (h.textContent += `
+`);
+        const f = l.textContent.replace(/\u00A0/g, " ");
+        h.textContent += f, l.remove();
+        continue;
+      }
+      let u = null;
+      if (l.tagName === "DIV" && (u = l.querySelector("li")), u) {
+        const h = u.classList.contains("bullet-list"), f = u.classList.contains("ordered-list");
+        if (!h && !f) {
+          n = null, r = null;
+          continue;
+        }
+        const g = h ? "ul" : "ol";
+        (!n || r !== g) && (n = document.createElement(g), t.insertBefore(n, l), r = g);
+        const b = [];
+        for (const v of l.childNodes)
+          if (v.nodeType === 3 && v.textContent.match(/^\u00A0+$/))
+            b.push(v.cloneNode(!0));
+          else if (v === u)
+            break;
+        b.forEach((v) => {
+          u.insertBefore(v, u.firstChild);
+        }), n.appendChild(u), l.remove();
+      } else
+        n = null, r = null;
+    }
+    return t.innerHTML;
+  }
+  /**
+   * Manual post-processing for Node.js environments (without DOM)
+   * @param {string} html - HTML to post-process
+   * @returns {string} Post-processed HTML
+   */
+  static postProcessHTMLManual(e) {
+    let t = e;
+    t = t.replace(/((?:<div>(?:&nbsp;)*<li class="bullet-list">.*?<\/li><\/div>\s*)+)/gs, (r) => {
+      const o = r.match(/<div>(?:&nbsp;)*<li class="bullet-list">.*?<\/li><\/div>/gs) || [];
+      return o.length > 0 ? "<ul>" + o.map((s) => {
+        const c = s.match(/<div>((?:&nbsp;)*)<li/), p = s.match(/<li class="bullet-list">.*?<\/li>/);
+        if (c && p) {
+          const d = c[1];
+          return p[0].replace(/<li class="bullet-list">/, `<li class="bullet-list">${d}`);
+        }
+        return p ? p[0] : "";
+      }).filter(Boolean).join("") + "</ul>" : r;
+    }), t = t.replace(/((?:<div>(?:&nbsp;)*<li class="ordered-list">.*?<\/li><\/div>\s*)+)/gs, (r) => {
+      const o = r.match(/<div>(?:&nbsp;)*<li class="ordered-list">.*?<\/li><\/div>/gs) || [];
+      return o.length > 0 ? "<ol>" + o.map((s) => {
+        const c = s.match(/<div>((?:&nbsp;)*)<li/), p = s.match(/<li class="ordered-list">.*?<\/li>/);
+        if (c && p) {
+          const d = c[1];
+          return p[0].replace(/<li class="ordered-list">/, `<li class="ordered-list">${d}`);
+        }
+        return p ? p[0] : "";
+      }).filter(Boolean).join("") + "</ol>" : r;
+    });
+    const n = /<div><span class="code-fence">(```[^<]*)<\/span><\/div>(.*?)<div><span class="code-fence">(```)<\/span><\/div>/gs;
+    return t = t.replace(n, (r, o, a, s) => {
+      const p = (a.match(/<div>(.*?)<\/div>/gs) || []).map((u) => u.replace(/<div>(.*?)<\/div>/s, "$1").replace(/&nbsp;/g, " ")).join(`
+`), d = o.slice(3).trim(), l = d ? ` class="language-${d}"` : "";
+      let m = `<div><span class="code-fence">${o}</span></div>`;
+      return m += `<pre class="code-block"><code${l}>${p}</code></pre>`, m += `<div><span class="code-fence">${s}</span></div>`, m;
+    }), t;
+  }
+  /**
+   * Get list context at cursor position
+   * @param {string} text - Full text content
+   * @param {number} cursorPosition - Current cursor position
+   * @returns {Object} List context information
+   */
+  static getListContext(e, t) {
+    const n = e.split(`
+`);
+    let r = 0, o = 0, a = 0;
+    for (let m = 0; m < n.length; m++) {
+      const u = n[m].length;
+      if (r + u >= t) {
+        o = m, a = r;
+        break;
+      }
+      r += u + 1;
+    }
+    const s = n[o], c = a + s.length, p = s.match(this.LIST_PATTERNS.checkbox);
+    if (p)
+      return {
+        inList: !0,
+        listType: "checkbox",
+        indent: p[1],
+        marker: "-",
+        checked: p[2] === "x",
+        content: p[3],
+        lineStart: a,
+        lineEnd: c,
+        markerEndPos: a + p[1].length + p[2].length + 5
+        // indent + "- [ ] "
+      };
+    const d = s.match(this.LIST_PATTERNS.bullet);
+    if (d)
+      return {
+        inList: !0,
+        listType: "bullet",
+        indent: d[1],
+        marker: d[2],
+        content: d[3],
+        lineStart: a,
+        lineEnd: c,
+        markerEndPos: a + d[1].length + d[2].length + 1
+        // indent + marker + space
+      };
+    const l = s.match(this.LIST_PATTERNS.numbered);
+    return l ? {
+      inList: !0,
+      listType: "numbered",
+      indent: l[1],
+      marker: parseInt(l[2]),
+      content: l[3],
+      lineStart: a,
+      lineEnd: c,
+      markerEndPos: a + l[1].length + l[2].length + 2
+      // indent + number + ". "
+    } : {
+      inList: !1,
+      listType: null,
+      indent: "",
+      marker: null,
+      content: s,
+      lineStart: a,
+      lineEnd: c,
+      markerEndPos: a
+    };
+  }
+  /**
+   * Create a new list item based on context
+   * @param {Object} context - List context from getListContext
+   * @returns {string} New list item text
+   */
+  static createNewListItem(e) {
+    switch (e.listType) {
+      case "bullet":
+        return `${e.indent}${e.marker} `;
+      case "numbered":
+        return `${e.indent}${e.marker + 1}. `;
+      case "checkbox":
+        return `${e.indent}- [ ] `;
+      default:
+        return "";
+    }
+  }
+  /**
+   * Renumber all numbered lists in text
+   * @param {string} text - Text containing numbered lists
+   * @returns {string} Text with renumbered lists
+   */
+  static renumberLists(e) {
+    const t = e.split(`
+`), n = /* @__PURE__ */ new Map();
+    let r = !1;
+    return t.map((a) => {
+      const s = a.match(this.LIST_PATTERNS.numbered);
+      if (s) {
+        const c = s[1], p = c.length, d = s[3];
+        r || n.clear();
+        const l = (n.get(p) || 0) + 1;
+        n.set(p, l);
+        for (const [m] of n)
+          m > p && n.delete(m);
+        return r = !0, `${c}${l}. ${d}`;
+      } else
+        return (a.trim() === "" || !a.match(/^\s/)) && (r = !1, n.clear()), a;
+    }).join(`
+`);
+  }
+};
+N.linkIndex = 0, N.LIST_PATTERNS = {
+  bullet: /^(\s*)([-*+])\s+(.*)$/,
+  numbered: /^(\s*)(\d+)\.\s+(.*)$/,
+  checkbox: /^(\s*)-\s+\[([ x])\]\s+(.*)$/
+};
+let T = N;
+const S = {
+  bold: {
+    prefix: "**",
+    suffix: "**",
+    trimFirst: !0
+  },
+  italic: {
+    prefix: "_",
+    suffix: "_",
+    trimFirst: !0
+  },
+  code: {
+    prefix: "`",
+    suffix: "`",
+    blockPrefix: "```",
+    blockSuffix: "```"
+  },
+  link: {
+    prefix: "[",
+    suffix: "](url)",
+    replaceNext: "url",
+    scanFor: "https?://"
+  },
+  bulletList: {
+    prefix: "- ",
+    multiline: !0,
+    unorderedList: !0
+  },
+  numberedList: {
+    prefix: "1. ",
+    multiline: !0,
+    orderedList: !0
+  },
+  quote: {
+    prefix: "> ",
+    multiline: !0,
+    surroundWithNewlines: !0
+  },
+  taskList: {
+    prefix: "- [ ] ",
+    multiline: !0,
+    surroundWithNewlines: !0
+  },
+  header1: { prefix: "# " },
+  header2: { prefix: "## " },
+  header3: { prefix: "### " },
+  header4: { prefix: "#### " },
+  header5: { prefix: "##### " },
+  header6: { prefix: "###### " }
+};
+function Le() {
+  return {
+    prefix: "",
+    suffix: "",
+    blockPrefix: "",
+    blockSuffix: "",
+    multiline: !1,
+    replaceNext: "",
+    prefixSpace: !1,
+    scanFor: null,
+    surroundWithNewlines: !1,
+    orderedList: !1,
+    unorderedList: !1,
+    trimFirst: !1
+  };
+}
+function C(i) {
+  const e = {
+    ...Le(),
+    ...i
+  };
+  return e.scanFor = i.scanFor ?? null, e;
+}
+let I = !1;
+function ce(i) {
+  I = i;
+}
+function V() {
+  return I;
+}
+function k(i, e, t) {
+  I && (console.group(`🔍 ${i}`), console.log(e), console.groupEnd());
+}
+function R(i, e) {
+  if (!I) return;
+  const t = i.value.slice(i.selectionStart, i.selectionEnd);
+  console.group(`📍 Selection: ${e}`), console.log("Position:", `${i.selectionStart}-${i.selectionEnd}`), console.log("Selected text:", JSON.stringify(t)), console.log("Length:", t.length);
+  const n = i.value.slice(Math.max(0, i.selectionStart - 10), i.selectionStart), r = i.value.slice(i.selectionEnd, Math.min(i.value.length, i.selectionEnd + 10));
+  console.log("Context:", `${JSON.stringify(n)}[SELECTION]${JSON.stringify(r)}`), console.groupEnd();
+}
+function D(i) {
+  I && (console.group("📝 Result"), console.log("Text to insert:", JSON.stringify(i.text)), console.log("New selection:", `${i.selectionStart}-${i.selectionEnd}`), console.groupEnd());
+}
+let y = null;
+function H(i, e) {
+  const t = V();
+  t && (console.group("🔧 insertText"), console.log("Current selection:", `${i.selectionStart}-${i.selectionEnd}`), console.log("Text to insert:", JSON.stringify(e.text)), console.log("New selection to set:", e.selectionStart, "-", e.selectionEnd)), i.focus();
+  const n = i.selectionStart, r = i.selectionEnd, o = i.value.slice(0, n), a = i.value.slice(r);
+  t && (console.log("Before text (last 20):", JSON.stringify(o.slice(-20))), console.log("After text (first 20):", JSON.stringify(a.slice(0, 20))), console.log(
+    "Selected text being replaced:",
+    JSON.stringify(i.value.slice(n, r))
+  ));
+  const s = i.value;
+  if (y === null || y === !0) {
+    i.contentEditable = "true";
+    try {
+      y = document.execCommand("insertText", !1, e.text), t && console.log(
+        "execCommand returned:",
+        y,
+        "for text with",
+        e.text.split(`
+`).length,
+        "lines"
+      );
+    } catch (c) {
+      y = !1, t && console.log("execCommand threw error:", c);
+    }
+    i.contentEditable = "false";
+  }
+  if (t && (console.log("canInsertText before:", y), console.log("execCommand result:", y)), y) {
+    const c = o + e.text + a, p = i.value;
+    t && (console.log("Expected length:", c.length), console.log("Actual length:", p.length)), p !== c && t && (console.log("execCommand changed the value but not as expected"), console.log("Expected:", JSON.stringify(c.slice(0, 100))), console.log("Actual:", JSON.stringify(p.slice(0, 100))));
+  }
+  if (!y)
+    if (t && console.log("Using manual insertion"), i.value === s) {
+      t && console.log("Value unchanged, doing manual replacement");
+      try {
+        document.execCommand("ms-beginUndoUnit");
+      } catch {
+      }
+      i.value = o + e.text + a;
+      try {
+        document.execCommand("ms-endUndoUnit");
+      } catch {
+      }
+      i.dispatchEvent(new CustomEvent("input", { bubbles: !0, cancelable: !0 }));
+    } else t && console.log("Value was changed by execCommand, skipping manual insertion");
+  t && console.log("Setting selection range:", e.selectionStart, e.selectionEnd), e.selectionStart != null && e.selectionEnd != null ? i.setSelectionRange(e.selectionStart, e.selectionEnd) : i.setSelectionRange(n, i.selectionEnd), t && (console.log("Final value length:", i.value.length), console.groupEnd());
+}
+function pe(i) {
+  switch (i) {
+    case "native":
+      y = !0;
+      break;
+    case "manual":
+      y = !1;
+      break;
+    case "auto":
+    default:
+      y = null;
+      break;
+  }
+}
+function Se() {
+  return y === !0 ? "native" : y === !1 ? "manual" : "auto";
+}
+function O(i) {
+  return i.trim().split(`
+`).length > 1;
+}
+function Ce(i, e) {
+  let t = e;
+  for (; i[t] && i[t - 1] != null && !/\s/.test(i[t - 1]); )
+    t -= 1;
+  return t;
+}
+function Ee(i, e, t) {
+  let n = e;
+  const r = t ? /\n/ : /\s/;
+  for (; i[n] && !r.test(i[n]); )
+    n += 1;
+  return n;
+}
+function de(i) {
+  const e = i.value.split(`
+`);
+  let t = 0;
+  for (let n = 0; n < e.length; n += 1) {
+    const r = e[n].length + 1;
+    i.selectionStart >= t && i.selectionStart < t + r && (i.selectionStart = t), i.selectionEnd >= t && i.selectionEnd < t + r && (n === e.length - 1 ? i.selectionEnd = Math.min(t + e[n].length, i.value.length) : i.selectionEnd = t + r - 1), t += r;
+  }
+}
+function Te(i, e, t, n = !1) {
+  if (i.selectionStart === i.selectionEnd)
+    i.selectionStart = Ce(i.value, i.selectionStart), i.selectionEnd = Ee(i.value, i.selectionEnd, n);
+  else {
+    const r = i.selectionStart - e.length, o = i.selectionEnd + t.length, a = i.value.slice(r, i.selectionStart) === e, s = i.value.slice(i.selectionEnd, o) === t;
+    a && s && (i.selectionStart = r, i.selectionEnd = o);
+  }
+  return i.value.slice(i.selectionStart, i.selectionEnd);
+}
+function U(i) {
+  const e = i.value.slice(0, i.selectionStart), t = i.value.slice(i.selectionEnd), n = e.match(/\n*$/), r = t.match(/^\n*/), o = n ? n[0].length : 0, a = r ? r[0].length : 0;
+  let s = "", c = "";
+  return /\S/.test(e) && o < 2 && (s = `
+`.repeat(2 - o)), /\S/.test(t) && a < 2 && (c = `
+`.repeat(2 - a)), { newlinesToAppend: s, newlinesToPrepend: c };
+}
+function me(i, e) {
+  const t = i.selectionStart, n = i.selectionEnd, r = i.scrollTop;
+  e(), i.selectionStart = t, i.selectionEnd = n, i.scrollTop = r;
+}
+function j(i, e, t = {}) {
+  const n = i.selectionStart, r = i.selectionEnd, o = n === r, a = i.value;
+  let s = n;
+  for (; s > 0 && a[s - 1] !== `
+`; )
+    s -= 1;
+  if (o) {
+    let p = n;
+    for (; p < a.length && a[p] !== `
+`; )
+      p += 1;
+    i.selectionStart = s, i.selectionEnd = p;
+  } else
+    de(i);
+  const c = e(i);
+  if (t.adjustSelection) {
+    const p = i.value.slice(i.selectionStart, i.selectionEnd), d = t.prefix ?? "", l = d.length > 0 && p.startsWith(d), m = t.adjustSelection(
+      l,
+      n,
+      r,
+      s
+    );
+    return c.selectionStart = m.start, c.selectionEnd = m.end, c;
+  }
+  if (t.prefix) {
+    const d = i.value.slice(i.selectionStart, i.selectionEnd).startsWith(t.prefix);
+    if (o)
+      if (d) {
+        const l = Math.max(n - t.prefix.length, s);
+        c.selectionStart = l, c.selectionEnd = l;
+      } else {
+        const l = n + t.prefix.length;
+        c.selectionStart = l, c.selectionEnd = l;
+      }
+    else d ? (c.selectionStart = Math.max(n - t.prefix.length, s), c.selectionEnd = Math.max(r - t.prefix.length, s)) : (c.selectionStart = n + t.prefix.length, c.selectionEnd = r + t.prefix.length);
+  }
+  return c;
+}
+function $(i, e) {
+  const {
+    prefix: t,
+    suffix: n,
+    blockPrefix: r,
+    blockSuffix: o,
+    replaceNext: a,
+    prefixSpace: s,
+    scanFor: c,
+    surroundWithNewlines: p,
+    trimFirst: d
+  } = e, l = i.selectionStart, m = i.selectionEnd;
+  let u = i.value.slice(i.selectionStart, i.selectionEnd), h = O(u) && r && r.length > 0 ? `${r}
+` : t, f = O(u) && o && o.length > 0 ? `
+${o}` : n;
+  if (s) {
+    const z = i.value[i.selectionStart - 1];
+    i.selectionStart !== 0 && z != null && !/\s/.test(z) && (h = ` ${h}`);
+  }
+  u = Te(i, h, f, e.multiline);
+  let g = i.selectionStart, b = i.selectionEnd;
+  const v = !!a && a.length > 0 && f.includes(a) && u.length > 0;
+  let x = "", ee = "";
+  if (p) {
+    const z = U(i);
+    x = z.newlinesToAppend, ee = z.newlinesToPrepend, h = x + t, f += ee;
+  }
+  if (u.startsWith(h) && u.endsWith(f)) {
+    const z = u.slice(h.length, u.length - f.length);
+    if (l === m) {
+      let L = l - h.length;
+      L = Math.max(L, g), L = Math.min(L, g + z.length), g = L, b = L;
+    } else
+      b = g + z.length;
+    return { text: z, selectionStart: g, selectionEnd: b };
+  }
+  if (!v) {
+    let z = h + u + f;
+    g = l + h.length, b = m + h.length;
+    const L = u.match(/^\s*|\s*$/g);
+    if (d && L) {
+      const te = L[0] ?? "", ne = L[1] ?? "";
+      z = te + h + u.trim() + f + ne, g += te.length, b -= ne.length;
+    }
+    return { text: z, selectionStart: g, selectionEnd: b };
+  }
+  if (c && (typeof c == "string" ? new RegExp(c) : c).test(u)) {
+    const L = h + f.replace(a, u);
+    return g = g + h.length, b = g, { text: L, selectionStart: g, selectionEnd: b };
+  }
+  const ye = h + u + f, ze = f.indexOf(a);
+  return g = g + h.length + u.length + ze, b = g + a.length, { text: ye, selectionStart: g, selectionEnd: b };
+}
+function q(i, e) {
+  const { prefix: t, suffix: n, surroundWithNewlines: r } = e;
+  let o = i.value.slice(i.selectionStart, i.selectionEnd), a = i.selectionStart, s = i.selectionEnd;
+  const c = o.split(`
+`);
+  if (c.every((d) => d.startsWith(t) && (!n || d.endsWith(n))))
+    o = c.map((d) => {
+      let l = d.slice(t.length);
+      return n && (l = l.slice(0, l.length - n.length)), l;
+    }).join(`
+`), s = a + o.length;
+  else if (o = c.map((d) => t + d + (n ?? "")).join(`
+`), r) {
+    const { newlinesToAppend: d, newlinesToPrepend: l } = U(i);
+    a += d.length, s = a + o.length, o = d + o + l;
+  }
+  return { text: o, selectionStart: a, selectionEnd: s };
+}
+function ie(i) {
+  const e = i.split(`
+`), t = /^\d+\.\s+/, n = e.every((o) => t.test(o));
+  return {
+    text: (n ? e.map((o) => o.replace(t, "")) : e).join(`
+`),
+    processed: n
+  };
+}
+function re(i) {
+  const e = i.split(`
+`), t = "- ", n = e.every((o) => o.startsWith(t));
+  return {
+    text: (n ? e.map((o) => o.slice(t.length)) : e).join(`
+`),
+    processed: n
+  };
+}
+function P(i, e) {
+  return e ? "- " : `${i + 1}. `;
+}
+function He(i, e) {
+  let t, n, r;
+  return i.orderedList ? (t = ie(e), n = re(t.text), r = n.text) : (t = re(e), n = ie(t.text), r = n.text), [t, n, r];
+}
+function Me(i, e) {
+  const t = i.selectionStart === i.selectionEnd;
+  let n = i.selectionStart, r = i.selectionEnd;
+  de(i);
+  const o = i.value.slice(i.selectionStart, i.selectionEnd), [a, s, c] = He(e, o), p = c.split(`
+`).map((f, g) => `${P(g, e.unorderedList)}${f}`), d = p.reduce((f, g, b) => f + P(b, e.unorderedList).length, 0), l = p.reduce((f, g, b) => f + P(b, !e.unorderedList).length, 0);
+  if (a.processed)
+    return t ? (n = Math.max(n - P(0, e.unorderedList).length, 0), r = n) : (n = i.selectionStart, r = i.selectionEnd - d), { text: c, selectionStart: n, selectionEnd: r };
+  const { newlinesToAppend: m, newlinesToPrepend: u } = U(i), h = m + p.join(`
+`) + u;
+  return t ? (n = Math.max(
+    n + P(0, e.unorderedList).length + m.length,
+    0
+  ), r = n) : s.processed ? (n = Math.max(i.selectionStart + m.length, 0), r = i.selectionEnd + m.length + d - l) : (n = Math.max(i.selectionStart + m.length, 0), r = i.selectionEnd + m.length + d), { text: h, selectionStart: n, selectionEnd: r };
+}
+function he(i, e) {
+  const t = j(
+    i,
+    (n) => Me(n, e),
+    {
+      adjustSelection: (n, r, o, a) => {
+        const s = i.value.slice(a, i.selectionEnd), c = /^\d+\.\s+/, p = /^- /, d = c.test(s), l = p.test(s), m = e.orderedList && d || e.unorderedList && l;
+        if (r === o) {
+          if (m) {
+            const f = s.match(e.orderedList ? c : p), g = f ? f[0].length : 0;
+            return {
+              start: Math.max(r - g, a),
+              end: Math.max(r - g, a)
+            };
+          }
+          if (d || l) {
+            const f = s.match(d ? c : p), g = f ? f[0].length : 0, v = (e.unorderedList ? 2 : 3) - g;
+            return {
+              start: r + v,
+              end: r + v
+            };
+          }
+          const h = e.unorderedList ? 2 : 3;
+          return {
+            start: r + h,
+            end: r + h
+          };
+        }
+        if (m) {
+          const h = s.match(e.orderedList ? c : p), f = h ? h[0].length : 0;
+          return {
+            start: Math.max(r - f, a),
+            end: Math.max(o - f, a)
+          };
+        }
+        if (d || l) {
+          const h = s.match(d ? c : p), f = h ? h[0].length : 0, b = (e.unorderedList ? 2 : 3) - f;
+          return {
+            start: r + b,
+            end: o + b
+          };
+        }
+        const u = e.unorderedList ? 2 : 3;
+        return {
+          start: r + u,
+          end: o + u
+        };
+      },
+      prefix: e.unorderedList ? "- " : "1. "
+    }
+  );
+  H(i, t);
+}
+function Ae(i, e) {
+  const t = S[e];
+  if (!t) return !1;
+  const n = t.prefix ?? "", r = t.suffix ?? "";
+  return n ? r ? i.startsWith(n) && i.endsWith(r) : i.startsWith(n) : !1;
+}
+function W(i) {
+  if (!i) return [];
+  const e = [], { selectionStart: t, selectionEnd: n, value: r } = i, o = r.split(`
+`);
+  let a = 0, s = "";
+  for (const l of o) {
+    if (t >= a && t <= a + l.length) {
+      s = l;
+      break;
+    }
+    a += l.length + 1;
+  }
+  s.startsWith("- ") && (s.startsWith("- [ ] ") || s.startsWith("- [x] ") ? e.push("task-list") : e.push("bullet-list")), /^\d+\.\s/.test(s) && e.push("numbered-list"), s.startsWith("> ") && e.push("quote"), s.startsWith("### ") ? e.push("header-3") : s.startsWith("## ") ? e.push("header-2") : s.startsWith("# ") && e.push("header");
+  const c = Math.max(0, t - 10), p = Math.min(r.length, n + 10), d = r.slice(c, p);
+  if (d.includes("**")) {
+    const l = r.slice(Math.max(0, t - 100), t), m = r.slice(n, Math.min(r.length, n + 100)), u = l.lastIndexOf("**"), h = m.indexOf("**");
+    u !== -1 && h !== -1 && e.push("bold");
+  }
+  if (d.includes("_")) {
+    const l = r.slice(Math.max(0, t - 100), t), m = r.slice(n, Math.min(r.length, n + 100)), u = l.lastIndexOf("_"), h = m.indexOf("_");
+    u !== -1 && h !== -1 && e.push("italic");
+  }
+  if (d.includes("`")) {
+    const l = r.slice(Math.max(0, t - 100), t), m = r.slice(n, Math.min(r.length, n + 100));
+    l.includes("`") && m.includes("`") && e.push("code");
+  }
+  if (d.includes("[") && d.includes("]")) {
+    const l = r.slice(Math.max(0, t - 100), t), m = r.slice(n, Math.min(r.length, n + 100)), u = l.lastIndexOf("["), h = m.indexOf("]");
+    u !== -1 && h !== -1 && r.slice(n + h + 1, n + h + 10).startsWith("(") && e.push("link");
+  }
+  return e;
+}
+function ue(i, e) {
+  return W(i).includes(e);
+}
+function fe(i, e = {}) {
+  if (!i) return;
+  const { toWord: t, toLine: n, toFormat: r } = e, { selectionStart: o, selectionEnd: a, value: s } = i;
+  if (n) {
+    const c = s.split(`
+`);
+    let p = 0, d = 0, l = 0;
+    for (const m of c) {
+      if (o >= l && o <= l + m.length) {
+        p = l, d = l + m.length;
+        break;
+      }
+      l += m.length + 1;
+    }
+    i.selectionStart = p, i.selectionEnd = d;
+    return;
+  }
+  if (r && Ae(s.slice(o, a), r)) {
+    const c = S[r], p = (c.prefix ?? "").length, d = (c.suffix ?? "").length;
+    i.selectionStart = Math.max(0, o - p), i.selectionEnd = Math.min(s.length, a + d);
+    return;
+  }
+  if (t && o === a) {
+    let c = o, p = a;
+    for (; c > 0 && !/\s/.test(s[c - 1]); )
+      c -= 1;
+    for (; p < s.length && !/\s/.test(s[p]); )
+      p += 1;
+    i.selectionStart = c, i.selectionEnd = p;
+  }
+}
+function E(i) {
+  return !!i && !i.disabled && !i.readOnly;
+}
+function K(i) {
+  if (!E(i)) return;
+  k("toggleBold", "Starting"), R(i, "Before");
+  const e = C(S.bold), t = $(i, e);
+  D(t), H(i, t), R(i, "After");
+}
+function Z(i) {
+  if (!E(i)) return;
+  const e = C(S.italic), t = $(i, e);
+  H(i, t);
+}
+function ge(i) {
+  if (!E(i)) return;
+  const e = C(S.code), t = $(i, e);
+  H(i, t);
+}
+function J(i, e = {}) {
+  if (!E(i)) return;
+  const t = i.value.slice(i.selectionStart, i.selectionEnd);
+  let n = C(S.link);
+  if (t && /^https?:\/\//.test(t) && !e.url ? n = {
+    ...n,
+    suffix: `](${t})`,
+    replaceNext: ""
+  } : e.url && (n = {
+    ...n,
+    suffix: `](${e.url})`,
+    replaceNext: ""
+  }), e.text && !t) {
+    const a = i.selectionStart;
+    i.value = i.value.slice(0, a) + e.text + i.value.slice(a), i.selectionStart = a, i.selectionEnd = a + e.text.length;
+  }
+  const o = $(i, n);
+  H(i, o);
+}
+function Q(i) {
+  if (!E(i)) return;
+  const e = C(S.bulletList);
+  he(i, e);
+}
+function G(i) {
+  if (!E(i)) return;
+  const e = C(S.numberedList);
+  he(i, e);
+}
+function X(i) {
+  if (!E(i)) return;
+  k("toggleQuote", "Starting"), R(i, "Initial");
+  const e = C(S.quote), t = j(
+    i,
+    (n) => q(n, e),
+    { prefix: e.prefix }
+  );
+  D(t), H(i, t), R(i, "Final");
+}
+function Y(i) {
+  if (!E(i)) return;
+  const e = C(S.taskList), t = j(
+    i,
+    (n) => q(n, e),
+    { prefix: e.prefix }
+  );
+  H(i, t);
+}
+function $e(i, e, t) {
+  let n = e;
+  for (; n > 0 && i[n - 1] !== `
+`; )
+    n -= 1;
+  let r = t;
+  for (; r < i.length && i[r] !== `
+`; )
+    r += 1;
+  return { lineStart: n, lineEnd: r };
+}
+function B(i, e = 1, t = !1) {
+  if (!E(i)) return;
+  (e < 1 || e > 6) && (e = 1), k("insertHeader", "============ START ============"), k("insertHeader", `Level: ${e}, Toggle: ${t}`), k("insertHeader", `Initial cursor: ${i.selectionStart}-${i.selectionEnd}`);
+  const n = `header${e === 1 ? "1" : e}`, r = C(S[n] || S.header1);
+  k("insertHeader", `Style prefix: "${r.prefix}"`);
+  const o = i.value, a = i.selectionStart, s = i.selectionEnd, { lineStart: c, lineEnd: p } = $e(o, a, s), d = o.slice(c, p);
+  k("insertHeader", `Current line (before): "${d}"`);
+  const l = d.match(/^(#{1,6})\s*/), m = l ? l[1].length : 0, u = l ? l[0].length : 0;
+  k("insertHeader", `Existing header match: ${l ? l[0] : "none"}`), k("insertHeader", `Existing level: ${m}`), k("insertHeader", `Target level: ${e}`);
+  const h = t && m === e;
+  k("insertHeader", `Should toggle OFF: ${h}`);
+  const f = j(
+    i,
+    (g) => {
+      const b = g.value.slice(g.selectionStart, g.selectionEnd);
+      k("insertHeader", `Line in operation: "${b}"`);
+      const v = b.replace(/^#{1,6}\s*/, "");
+      k("insertHeader", `Cleaned line: "${v}"`);
+      let x;
+      return h ? (k("insertHeader", "ACTION: Toggling OFF - removing header"), x = v) : m > 0 ? (k("insertHeader", `ACTION: Replacing H${m} with H${e}`), x = r.prefix + v) : (k("insertHeader", "ACTION: Adding new header"), x = r.prefix + v), k("insertHeader", `New line: "${x}"`), {
+        text: x,
+        selectionStart: g.selectionStart,
+        selectionEnd: g.selectionEnd
+      };
+    },
+    {
+      prefix: r.prefix,
+      adjustSelection: (g, b, v) => {
+        if (k("insertHeader", `Adjusting selection with existing prefix length ${u}`), h) {
+          const x = Math.max(b - u, c);
+          return {
+            start: x,
+            end: b === v ? x : Math.max(v - u, c)
+          };
+        }
+        if (u > 0) {
+          const x = r.prefix.length - u;
+          return {
+            start: b + x,
+            end: v + x
+          };
+        }
+        return {
+          start: b + r.prefix.length,
+          end: v + r.prefix.length
+        };
+      }
+    }
+  );
+  D(f), k("insertHeader", "============ END ============"), H(i, f);
+}
+function be(i) {
+  B(i, 1, !0);
+}
+function ve(i) {
+  B(i, 2, !0);
+}
+function we(i) {
+  B(i, 3, !0);
+}
+function ke(i, e) {
+  if (!E(i)) return;
+  const t = C(e);
+  let n;
+  if (t.multiline) {
+    const r = i.value.slice(i.selectionStart, i.selectionEnd);
+    O(r) ? n = q(i, t) : n = $(i, t);
+  } else
+    n = $(i, t);
+  H(i, n);
+}
+const oe = {
+  toggleBold: K,
+  toggleItalic: Z,
+  toggleCode: ge,
+  insertLink: J,
+  toggleBulletList: Q,
+  toggleNumberedList: G,
+  toggleQuote: X,
+  toggleTaskList: Y,
+  insertHeader: B,
+  toggleH1: be,
+  toggleH2: ve,
+  toggleH3: we,
+  getActiveFormats: W,
+  hasFormat: ue,
+  expandSelection: fe,
+  applyCustomFormat: ke,
+  preserveSelection: me,
+  setUndoMethod: pe,
+  setDebugMode: ce,
+  getDebugMode: V
+}, Pe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  actions: oe,
+  applyCustomFormat: ke,
+  default: oe,
+  expandSelection: fe,
+  getActiveFormats: W,
+  getDebugMode: V,
+  getUndoMethod: Se,
+  hasFormat: ue,
+  insertHeader: B,
+  insertLink: J,
+  preserveSelection: me,
+  setDebugMode: ce,
+  setUndoMethod: pe,
+  toggleBold: K,
+  toggleBulletList: Q,
+  toggleCode: ge,
+  toggleH1: be,
+  toggleH2: ve,
+  toggleH3: we,
+  toggleItalic: Z,
+  toggleNumberedList: G,
+  toggleQuote: X,
+  toggleTaskList: Y
+}, Symbol.toStringTag, { value: "Module" })), _e = {
+  b: "toggleBold",
+  i: "toggleItalic",
+  k: "insertLink"
+}, Ie = {
+  Digit7: "toggleNumberedList",
+  Digit8: "toggleBulletList"
+};
+class xe {
+  constructor(e) {
+    this.editor = e, this.textarea = e.textarea;
+  }
+  handleKeydown(e) {
+    if (!(navigator.platform.toLowerCase().includes("mac") ? e.metaKey : e.ctrlKey)) return !1;
+    const o = e.key.toLowerCase(), a = Ie[e.code], s = a ?? _e[o];
+    return !s || a && !e.shiftKey || !a && (o === "b" || o === "i" || o === "k") && e.shiftKey ? !1 : (e.preventDefault(), this.editor.toolbar ? this.editor.toolbar.handleAction(s) : this.handleAction(s), !0);
+  }
+  handleAction(e) {
+    const t = this.textarea;
+    if (t) {
+      switch (t.focus(), e) {
+        case "toggleBold":
+          K(t);
+          break;
+        case "toggleItalic":
+          Z(t);
+          break;
+        case "insertLink":
+          J(t);
+          break;
+        case "toggleBulletList":
+          Q(t);
+          break;
+        case "toggleNumberedList":
+          G(t);
+          break;
+        case "toggleQuote":
+          X(t);
+          break;
+        case "toggleTaskList":
+          Y(t);
+          break;
+      }
+      t.dispatchEvent(new Event("input", { bubbles: !0 }));
+    }
+  }
+  destroy() {
+  }
+}
+const M = {
+  name: "solar",
+  colors: {
+    bgPrimary: "#faf0ca",
+    // Lemon Chiffon - main background
+    bgSecondary: "#ffffff",
+    // White - editor background
+    text: "#0d3b66",
+    // Yale Blue - main text
+    h1: "#f95738",
+    // Tomato - h1 headers
+    h2: "#ee964b",
+    // Sandy Brown - h2 headers  
+    h3: "#3d8a51",
+    // Forest green - h3 headers
+    strong: "#ee964b",
+    // Sandy Brown - bold text
+    em: "#f95738",
+    // Tomato - italic text
+    link: "#0d3b66",
+    // Yale Blue - links
+    code: "#0d3b66",
+    // Yale Blue - inline code
+    codeBg: "rgba(244, 211, 94, 0.4)",
+    // Naples Yellow with transparency
+    blockquote: "#5a7a9b",
+    // Muted blue - blockquotes
+    hr: "#5a7a9b",
+    // Muted blue - horizontal rules
+    syntaxMarker: "rgba(13, 59, 102, 0.52)",
+    // Yale Blue with transparency
+    cursor: "#f95738",
+    // Tomato - cursor
+    selection: "rgba(244, 211, 94, 0.4)",
+    // Naples Yellow with transparency
+    listMarker: "#ee964b",
+    // Sandy Brown - list markers
+    // Toolbar colors
+    toolbarBg: "#ffffff",
+    // White - toolbar background
+    toolbarBorder: "rgba(13, 59, 102, 0.15)",
+    // Yale Blue border
+    toolbarIcon: "#0d3b66",
+    // Yale Blue - icon color
+    toolbarHover: "#f5f5f5",
+    // Light gray - hover background
+    toolbarActive: "#faf0ca"
+    // Lemon Chiffon - active button background
+  }
+}, se = {
+  name: "cave",
+  colors: {
+    bgPrimary: "#141E26",
+    // Deep ocean - main background
+    bgSecondary: "#1D2D3E",
+    // Darker charcoal - editor background
+    text: "#c5dde8",
+    // Light blue-gray - main text
+    h1: "#d4a5ff",
+    // Rich lavender - h1 headers
+    h2: "#f6ae2d",
+    // Hunyadi Yellow - h2 headers
+    h3: "#9fcfec",
+    // Brighter blue - h3 headers
+    strong: "#f6ae2d",
+    // Hunyadi Yellow - bold text
+    em: "#9fcfec",
+    // Brighter blue - italic text
+    link: "#9fcfec",
+    // Brighter blue - links
+    code: "#c5dde8",
+    // Light blue-gray - inline code
+    codeBg: "#1a232b",
+    // Very dark blue - code background
+    blockquote: "#9fcfec",
+    // Brighter blue - same as italic
+    hr: "#c5dde8",
+    // Light blue-gray - horizontal rules
+    syntaxMarker: "rgba(159, 207, 236, 0.73)",
+    // Brighter blue semi-transparent
+    cursor: "#f26419",
+    // Orange Pantone - cursor
+    selection: "rgba(51, 101, 138, 0.4)",
+    // Lapis Lazuli with transparency
+    listMarker: "#f6ae2d",
+    // Hunyadi Yellow - list markers
+    // Toolbar colors for dark theme
+    toolbarBg: "#1D2D3E",
+    // Darker charcoal - toolbar background
+    toolbarBorder: "rgba(197, 221, 232, 0.1)",
+    // Light blue-gray border
+    toolbarIcon: "#c5dde8",
+    // Light blue-gray - icon color
+    toolbarHover: "#243546",
+    // Slightly lighter charcoal - hover background
+    toolbarActive: "#2a3f52"
+    // Even lighter - active button background
+  }
+}, ae = {
+  solar: M,
+  cave: se,
+  // Aliases for backward compatibility
+  light: M,
+  dark: se
+};
+function _(i) {
+  return typeof i == "string" ? { ...ae[i] || ae.solar, name: i } : i;
+}
+function F(i) {
+  const e = [];
+  for (const [t, n] of Object.entries(i)) {
+    const r = t.replace(/([A-Z])/g, "-$1").toLowerCase();
+    e.push(`--${r}: ${n};`);
+  }
+  return e.join(`
+`);
+}
+function Be(i, e = {}) {
+  return {
+    ...i,
+    colors: {
+      ...i.colors,
+      ...e
+    }
+  };
+}
+function Re(i = {}) {
+  const {
+    fontSize: e = "14px",
+    lineHeight: t = 1.6,
+    /* System-first, guaranteed monospaced; avoids Android 'ui-monospace' pitfalls */
+    fontFamily: n = '"SF Mono", SFMono-Regular, Menlo, Monaco, "Cascadia Code", Consolas, "Roboto Mono", "Noto Sans Mono", "Droid Sans Mono", "Ubuntu Mono", "DejaVu Sans Mono", "Liberation Mono", "Courier New", Courier, monospace',
+    padding: r = "20px",
+    theme: o = null,
+    mobile: a = {}
+  } = i, s = Object.keys(a).length > 0 ? `
+    @media (max-width: 640px) {
+      .marzipan-wrapper .marzipan-input,
+      .marzipan-wrapper .marzipan-preview {
+        ${Object.entries(a).map(([p, d]) => `${p.replace(/([A-Z])/g, "-$1").toLowerCase()}: ${d} !important;`).join(`
+        `)}
+      }
+    }
+  ` : "", c = o && o.colors ? F(o.colors) : "";
+  return `
+    /* Marzipan Editor Styles */
+    
+    /* Middle-ground CSS Reset - Prevent parent styles from leaking in */
+    .marzipan-container * {
+      /* Box model - these commonly leak */
+      margin: 0 !important;
+      padding: 0 !important;
+      border: 0 !important;
+      
+      /* Layout - these can break our layout */
+      /* Don't reset position - it breaks dropdowns */
+      float: none !important;
+      clear: none !important;
+      
+      /* Typography - only reset decorative aspects */
+      text-decoration: none !important;
+      text-transform: none !important;
+      letter-spacing: normal !important;
+      
+      /* Visual effects that can interfere */
+      box-shadow: none !important;
+      text-shadow: none !important;
+      
+      /* Ensure box-sizing is consistent */
+      box-sizing: border-box !important;
+      
+      /* Keep inheritance for these */
+      /* font-family, color, line-height, font-size - inherit */
+    }
+    
+    /* Container base styles after reset */
+    .marzipan-container {
+      display: grid !important;
+      grid-template-rows: auto 1fr auto !important;
+      width: 100% !important;
+      height: 100% !important;
+      position: relative !important; /* Override reset - needed for absolute children */
+      overflow: visible !important; /* Allow dropdown to overflow container */
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif !important;
+      text-align: left !important;
+      ${c ? `
+      /* Theme Variables */
+      ${c}` : ""}
+    }
+    
+    /* Force left alignment for all elements in the editor */
+    .marzipan-container .marzipan-wrapper * {
+      text-align: left !important;
+    }
+    
+    /* Auto-resize mode styles */
+    .marzipan-container.marzipan-auto-resize {
+      height: auto !important;
+      grid-template-rows: auto auto auto !important;
+    }
+    
+    .marzipan-container.marzipan-auto-resize .marzipan-wrapper {
+      height: auto !important;
+      min-height: 60px !important;
+      overflow: visible !important;
+    }
+    
+    .marzipan-wrapper {
+      position: relative !important; /* Override reset - needed for absolute children */
+      width: 100% !important;
+      height: 100% !important; /* Take full height of grid cell */
+      min-height: 60px !important; /* Minimum usable height */
+      overflow: hidden !important;
+      background: var(--bg-secondary, #ffffff) !important;
+      grid-row: 2 !important; /* Always second row in grid */
+      z-index: 1; /* Below toolbar and dropdown */
+    }
+
+    /* Critical alignment styles - must be identical for both layers */
+    .marzipan-wrapper .marzipan-input,
+    .marzipan-wrapper .marzipan-preview {
+      /* Positioning - must be identical */
+      position: absolute !important; /* Override reset - required for overlay */
+      top: 0 !important;
+      left: 0 !important;
+      width: 100% !important;
+      height: 100% !important;
+      
+      /* Font properties - any difference breaks alignment */
+      font-family: ${n} !important;
+      font-variant-ligatures: none !important; /* keep metrics stable for code */
+      font-size: var(--instance-font-size, ${e}) !important;
+      line-height: var(--instance-line-height, ${t}) !important;
+      font-weight: normal !important;
+      font-style: normal !important;
+      font-variant: normal !important;
+      font-stretch: normal !important;
+      font-kerning: none !important;
+      font-feature-settings: normal !important;
+      
+      /* Box model - must match exactly */
+      padding: var(--instance-padding, ${r}) !important;
+      margin: 0 !important;
+      border: none !important;
+      outline: none !important;
+      box-sizing: border-box !important;
+      
+      /* Text layout - critical for character positioning */
+      white-space: pre-wrap !important;
+      word-wrap: break-word !important;
+      word-break: normal !important;
+      overflow-wrap: break-word !important;
+      tab-size: 2 !important;
+      -moz-tab-size: 2 !important;
+      text-align: left !important;
+      text-indent: 0 !important;
+      letter-spacing: normal !important;
+      word-spacing: normal !important;
+      
+      /* Text rendering */
+      text-transform: none !important;
+      text-rendering: auto !important;
+      -webkit-font-smoothing: auto !important;
+      -webkit-text-size-adjust: 100% !important;
+      
+      /* Direction and writing */
+      direction: ltr !important;
+      writing-mode: horizontal-tb !important;
+      unicode-bidi: normal !important;
+      text-orientation: mixed !important;
+      
+      /* Visual effects that could shift perception */
+      text-shadow: none !important;
+      filter: none !important;
+      transform: none !important;
+      zoom: 1 !important;
+      
+      /* Vertical alignment */
+      vertical-align: baseline !important;
+      
+      /* Size constraints */
+      min-width: 0 !important;
+      min-height: 0 !important;
+      max-width: none !important;
+      max-height: none !important;
+      
+      /* Overflow */
+      overflow-y: auto !important;
+      overflow-x: auto !important;
+      /* overscroll-behavior removed to allow scroll-through to parent */
+      scrollbar-width: auto !important;
+      scrollbar-gutter: auto !important;
+      
+      /* Animation/transition - disabled to prevent movement */
+      animation: none !important;
+      transition: none !important;
+    }
+
+    /* Input layer styles */
+    .marzipan-wrapper .marzipan-input {
+      /* Layer positioning */
+      z-index: 1 !important;
+      
+      /* Text visibility */
+      color: transparent !important;
+      caret-color: var(--cursor, #f95738) !important;
+      background-color: transparent !important;
+      
+      /* Textarea-specific */
+      resize: none !important;
+      appearance: none !important;
+      -webkit-appearance: none !important;
+      -moz-appearance: none !important;
+      
+      /* Prevent mobile zoom on focus */
+      touch-action: manipulation !important;
+      
+      /* Disable autofill and spellcheck */
+      autocomplete: off !important;
+      autocorrect: off !important;
+      autocapitalize: off !important;
+      spellcheck: false !important;
+    }
+
+    .marzipan-wrapper .marzipan-input::selection {
+      background-color: var(--selection, rgba(244, 211, 94, 0.4));
+    }
+
+    /* Preview layer styles */
+    .marzipan-wrapper .marzipan-preview {
+      /* Layer positioning */
+      z-index: 0 !important;
+      pointer-events: none !important;
+      color: var(--text, #0d3b66) !important;
+      background-color: transparent !important;
+      
+      /* Prevent text selection */
+      user-select: none !important;
+      -webkit-user-select: none !important;
+      -moz-user-select: none !important;
+      -ms-user-select: none !important;
+    }
+
+    /* Defensive styles for preview child divs */
+    .marzipan-wrapper .marzipan-preview div {
+      /* Reset any inherited styles */
+      margin: 0 !important;
+      padding: 0 !important;
+      border: none !important;
+      text-align: left !important;
+      text-indent: 0 !important;
+      display: block !important;
+      position: static !important;
+      transform: none !important;
+      min-height: 0 !important;
+      max-height: none !important;
+      line-height: inherit !important;
+      font-size: inherit !important;
+      font-family: inherit !important;
+    }
+
+    /* Markdown element styling - NO SIZE CHANGES */
+    .marzipan-wrapper .marzipan-preview .header {
+      font-weight: bold !important;
+    }
+
+    /* Header colors */
+    .marzipan-wrapper .marzipan-preview .h1 { 
+      color: var(--h1, #f95738) !important; 
+    }
+    .marzipan-wrapper .marzipan-preview .h2 { 
+      color: var(--h2, #ee964b) !important; 
+    }
+    .marzipan-wrapper .marzipan-preview .h3 { 
+      color: var(--h3, #3d8a51) !important; 
+    }
+
+    /* Semantic headers - flatten in edit mode */
+    .marzipan-wrapper .marzipan-preview h1,
+    .marzipan-wrapper .marzipan-preview h2,
+    .marzipan-wrapper .marzipan-preview h3 {
+      font-size: inherit !important;
+      font-weight: bold !important;
+      margin: 0 !important;
+      padding: 0 !important;
+      display: inline !important;
+      line-height: inherit !important;
+    }
+
+    /* Header colors for semantic headers */
+    .marzipan-wrapper .marzipan-preview h1 { 
+      color: var(--h1, #f95738) !important; 
+    }
+    .marzipan-wrapper .marzipan-preview h2 { 
+      color: var(--h2, #ee964b) !important; 
+    }
+    .marzipan-wrapper .marzipan-preview h3 { 
+      color: var(--h3, #3d8a51) !important; 
+    }
+
+    /* Lists - remove styling in edit mode */
+    .marzipan-wrapper .marzipan-preview ul,
+    .marzipan-wrapper .marzipan-preview ol {
+      list-style: none !important;
+      margin: 0 !important;
+      padding: 0 !important;
+      display: block !important; /* Lists need to be block for line breaks */
+    }
+
+    .marzipan-wrapper .marzipan-preview li {
+      display: block !important; /* Each item on its own line */
+      margin: 0 !important;
+      padding: 0 !important;
+      /* Don't set list-style here - let ul/ol control it */
+    }
+
+    /* Bold text */
+    .marzipan-wrapper .marzipan-preview strong {
+      color: var(--strong, #ee964b) !important;
+      font-weight: bold !important;
+    }
+
+    /* Italic text */
+    .marzipan-wrapper .marzipan-preview em {
+      color: var(--em, #f95738) !important;
+      text-decoration-color: var(--em, #f95738) !important;
+      text-decoration-thickness: 1px !important;
+      font-style: italic !important;
+    }
+
+    /* Strikethrough text */
+    .marzipan-wrapper .marzipan-preview del {
+      color: var(--del, #ee964b) !important;
+      text-decoration: line-through !important;
+      text-decoration-color: var(--del, #ee964b) !important;
+      text-decoration-thickness: 1px !important;
+    }
+
+    /* Inline code */
+    .marzipan-wrapper .marzipan-preview code {
+      background: var(--code-bg, rgba(244, 211, 94, 0.4)) !important;
+      color: var(--code, #0d3b66) !important;
+      padding: 0 !important;
+      border-radius: 2px !important;
+      font-family: inherit !important;
+      font-size: inherit !important;
+      line-height: inherit !important;
+      font-weight: normal !important;
+    }
+
+    /* Code blocks - consolidated pre blocks */
+    .marzipan-wrapper .marzipan-preview pre {
+      padding: 0 !important;
+      margin: 0 !important;
+      border-radius: 4px !important;
+      overflow-x: auto !important;
+    }
+    
+    /* Code block styling in normal mode - yellow background */
+    .marzipan-wrapper .marzipan-preview pre.code-block {
+      background: var(--code-bg, rgba(244, 211, 94, 0.4)) !important;
+    }
+
+    /* Code inside pre blocks - remove background */
+    .marzipan-wrapper .marzipan-preview pre code {
+      background: transparent !important;
+      color: var(--code, #0d3b66) !important;
+    }
+
+    /* Blockquotes */
+    .marzipan-wrapper .marzipan-preview .blockquote {
+      color: var(--blockquote, #5a7a9b) !important;
+      padding: 0 !important;
+      margin: 0 !important;
+      border: none !important;
+    }
+
+    /* Links */
+    .marzipan-wrapper .marzipan-preview a {
+      color: var(--link, #0d3b66) !important;
+      text-decoration: underline !important;
+      font-weight: normal !important;
+    }
+
+    .marzipan-wrapper .marzipan-preview a:hover {
+      text-decoration: underline !important;
+      color: var(--link, #0d3b66) !important;
+    }
+
+    /* Lists - no list styling */
+    .marzipan-wrapper .marzipan-preview ul,
+    .marzipan-wrapper .marzipan-preview ol {
+      list-style: none !important;
+      margin: 0 !important;
+      padding: 0 !important;
+    }
+
+
+    /* Horizontal rules */
+    .marzipan-wrapper .marzipan-preview hr {
+      border: none !important;
+      color: var(--hr, #5a7a9b) !important;
+      margin: 0 !important;
+      padding: 0 !important;
+    }
+
+    .marzipan-wrapper .marzipan-preview .hr-marker {
+      color: var(--hr, #5a7a9b) !important;
+      opacity: 0.6 !important;
+    }
+
+    /* Code fence markers - with background when not in code block */
+    .marzipan-wrapper .marzipan-preview .code-fence {
+      color: var(--code, #0d3b66) !important;
+      background: var(--code-bg, rgba(244, 211, 94, 0.4)) !important;
+    }
+    
+    /* Code block lines - background for entire code block */
+    .marzipan-wrapper .marzipan-preview .code-block-line {
+      background: var(--code-bg, rgba(244, 211, 94, 0.4)) !important;
+    }
+    
+    /* Remove background from code fence when inside code block line */
+    .marzipan-wrapper .marzipan-preview .code-block-line .code-fence {
+      background: transparent !important;
+    }
+
+    /* Raw markdown line */
+    .marzipan-wrapper .marzipan-preview .raw-line {
+      color: var(--raw-line, #5a7a9b) !important;
+      font-style: normal !important;
+      font-weight: normal !important;
+    }
+
+    /* Syntax markers */
+    .marzipan-wrapper .marzipan-preview .syntax-marker {
+      color: var(--syntax-marker, rgba(13, 59, 102, 0.52)) !important;
+      opacity: 0.7 !important;
+    }
+
+    /* List markers */
+    .marzipan-wrapper .marzipan-preview .list-marker {
+      color: var(--list-marker, #ee964b) !important;
+    }
+
+    /* Stats bar */
+    
+    /* Stats bar - positioned by grid, not absolute */
+    .marzipan-stats {
+      height: 40px !important;
+      padding: 0 20px !important;
+      background: #f8f9fa !important;
+      border-top: 1px solid #e0e0e0 !important;
+      display: flex !important;
+      justify-content: space-between !important;
+      align-items: center !important;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif !important;
+      font-size: 0.85rem !important;
+      color: #666 !important;
+      grid-row: 3 !important; /* Always third row in grid */
+    }
+    
+    /* Dark theme stats bar */
+    .marzipan-container[data-theme="cave"] .marzipan-stats {
+      background: var(--bg-secondary, #1D2D3E) !important;
+      border-top: 1px solid rgba(197, 221, 232, 0.1) !important;
+      color: var(--text, #c5dde8) !important;
+    }
+    
+    .marzipan-stats .marzipan-stat {
+      display: flex !important;
+      align-items: center !important;
+      gap: 5px !important;
+      white-space: nowrap !important;
+    }
+    
+    .marzipan-stats .live-dot {
+      width: 8px !important;
+      height: 8px !important;
+      background: #4caf50 !important;
+      border-radius: 50% !important;
+      animation: marzipan-pulse 2s infinite !important;
+    }
+    
+    @keyframes marzipan-pulse {
+      0%, 100% { opacity: 1; transform: scale(1); }
+      50% { opacity: 0.6; transform: scale(1.2); }
+    }
+    
+
+    /* Toolbar Styles */
+    .marzipan-toolbar {
+      display: flex !important;
+      align-items: center !important;
+      gap: 4px !important;
+      padding: 8px !important; /* Override reset */
+      background: var(--toolbar-bg, var(--bg-primary, #f8f9fa)) !important; /* Override reset */
+      border-bottom: 1px solid var(--toolbar-border, rgba(0, 0, 0, 0.08)) !important;
+      overflow-x: auto !important; /* Allow horizontal scrolling */
+      overflow-y: hidden !important; /* Hide vertical overflow */
+      -webkit-overflow-scrolling: touch !important;
+      flex-shrink: 0 !important;
+      height: auto !important;
+      grid-row: 1 !important; /* Always first row in grid */
+      position: relative !important; /* Override reset */
+      z-index: 100 !important; /* Ensure toolbar is above wrapper */
+      scrollbar-width: thin; /* Thin scrollbar on Firefox */
+    }
+    
+    /* Thin scrollbar styling */
+    .marzipan-toolbar::-webkit-scrollbar {
+      height: 4px;
+    }
+    
+    .marzipan-toolbar::-webkit-scrollbar-track {
+      background: transparent;
+    }
+    
+    .marzipan-toolbar::-webkit-scrollbar-thumb {
+      background: rgba(0, 0, 0, 0.2);
+      border-radius: 2px;
+    }
+
+    .marzipan-toolbar-button {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 32px;
+      height: 32px;
+      padding: 0;
+      border: none;
+      border-radius: 6px;
+      background: transparent;
+      color: var(--toolbar-icon, var(--text-secondary, #666));
+      cursor: pointer;
+      transition: all 0.2s ease;
+      flex-shrink: 0;
+    }
+
+    .marzipan-toolbar-button svg {
+      width: 20px;
+      height: 20px;
+      fill: currentColor;
+    }
+
+    .marzipan-toolbar-button:hover {
+      background: var(--toolbar-hover, var(--bg-secondary, #e9ecef));
+      color: var(--toolbar-icon, var(--text-primary, #333));
+    }
+
+    .marzipan-toolbar-button:active {
+      transform: scale(0.95);
+    }
+
+    .marzipan-toolbar-button.active {
+      background: var(--toolbar-active, var(--primary, #007bff));
+      color: var(--toolbar-icon, var(--text-primary, #333));
+    }
+
+    .marzipan-toolbar-button:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+    }
+
+    .marzipan-toolbar-separator {
+      width: 1px;
+      height: 24px;
+      background: var(--border, #e0e0e0);
+      margin: 0 4px;
+      flex-shrink: 0;
+    }
+
+    /* Adjust wrapper when toolbar is present */
+    .marzipan-container .marzipan-toolbar + .marzipan-wrapper {
+    }
+
+    /* Mobile toolbar adjustments */
+    @media (max-width: 640px) {
+      .marzipan-toolbar {
+        padding: 6px;
+        gap: 2px;
+      }
+
+      .marzipan-toolbar-button {
+        width: 36px;
+        height: 36px;
+      }
+
+      .marzipan-toolbar-separator {
+        margin: 0 2px;
+      }
+    }
+    
+    /* Plain mode - hide preview and show textarea text */
+    .marzipan-container.plain-mode .marzipan-preview {
+      display: none !important;
+    }
+    
+    .marzipan-container.plain-mode .marzipan-input {
+      color: var(--text, #0d3b66) !important;
+      /* Use system font stack for better plain text readability */
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, 
+                   "Helvetica Neue", Arial, sans-serif !important;
+    }
+    
+    /* Ensure textarea remains transparent in overlay mode */
+    .marzipan-container:not(.plain-mode) .marzipan-input {
+      color: transparent !important;
+    }
+
+    /* Dropdown menu styles */
+    .marzipan-toolbar-button {
+      position: relative !important; /* Override reset - needed for dropdown */
+    }
+
+    .marzipan-toolbar-button.dropdown-active {
+      background: var(--toolbar-active, var(--hover-bg, #f0f0f0));
+    }
+
+    .marzipan-dropdown-menu {
+      position: fixed !important; /* Fixed positioning relative to viewport */
+      background: var(--bg-secondary, white) !important; /* Override reset */
+      border: 1px solid var(--border, #e0e0e0) !important; /* Override reset */
+      border-radius: 6px;
+      box-shadow: 0 2px 8px rgba(0,0,0,0.1) !important; /* Override reset */
+      z-index: 10000; /* Very high z-index to ensure visibility */
+      min-width: 150px;
+      padding: 4px 0 !important; /* Override reset */
+      /* Position will be set via JavaScript based on button position */
+    }
+
+    .marzipan-dropdown-item {
+      display: flex;
+      align-items: center;
+      width: 100%;
+      padding: 8px 12px;
+      border: none;
+      background: none;
+      text-align: left;
+      cursor: pointer;
+      font-size: 14px;
+      color: var(--text, #333);
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+    }
+
+    .marzipan-dropdown-item:hover {
+      background: var(--hover-bg, #f0f0f0);
+    }
+
+    .marzipan-dropdown-item.active {
+      font-weight: 600;
+    }
+
+    .marzipan-dropdown-check {
+      width: 16px;
+      margin-right: 8px;
+      color: var(--h1, #007bff);
+    }
+
+    /* Preview mode styles */
+    .marzipan-container.preview-mode .marzipan-input {
+      display: none !important;
+    }
+
+    .marzipan-container.preview-mode .marzipan-preview {
+      pointer-events: auto !important;
+      user-select: text !important;
+      cursor: text !important;
+    }
+
+    /* Hide syntax markers in preview mode */
+    .marzipan-container.preview-mode .syntax-marker {
+      display: none !important;
+    }
+    
+    /* Hide URL part of links in preview mode - extra specificity */
+    .marzipan-container.preview-mode .syntax-marker.url-part,
+    .marzipan-container.preview-mode .url-part {
+      display: none !important;
+    }
+    
+    /* Hide all syntax markers inside links too */
+    .marzipan-container.preview-mode a .syntax-marker {
+      display: none !important;
+    }
+
+    /* Headers - restore proper sizing in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h1, 
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h2, 
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h3 {
+      font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif !important;
+      font-weight: 600 !important;
+      margin: 0 !important;
+      display: block !important;
+      color: inherit !important; /* Use parent text color */
+      line-height: 1 !important; /* Tight line height for headings */
+    }
+    
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h1 { 
+      font-size: 2em !important; 
+    }
+    
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h2 { 
+      font-size: 1.5em !important; 
+    }
+    
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview h3 { 
+      font-size: 1.17em !important; 
+    }
+
+    /* Lists - restore list styling in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview ul {
+      display: block !important;
+      list-style: disc !important;
+      padding-left: 2em !important;
+      margin: 1em 0 !important;
+    }
+
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview ol {
+      display: block !important;
+      list-style: decimal !important;
+      padding-left: 2em !important;
+      margin: 1em 0 !important;
+    }
+    
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview li {
+      display: list-item !important;
+      margin: 0 !important;
+      padding: 0 !important;
+    }
+
+    /* Links - make clickable in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview a {
+      pointer-events: auto !important;
+      cursor: pointer !important;
+      color: var(--link, #0066cc) !important;
+      text-decoration: underline !important;
+    }
+
+    /* Code blocks - proper pre/code styling in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview pre.code-block {
+      background: #2d2d2d !important;
+      color: #f8f8f2 !important;
+      padding: 1.2em !important;
+      border-radius: 3px !important;
+      overflow-x: auto !important;
+      margin: 0 !important;
+      display: block !important;
+    }
+    
+    /* Cave theme code block background in preview mode */
+    .marzipan-container[data-theme="cave"].preview-mode .marzipan-wrapper .marzipan-preview pre.code-block {
+      background: #11171F !important;
+    }
+
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview pre.code-block code {
+      background: transparent !important;
+      color: inherit !important;
+      padding: 0 !important;
+      font-family: ${n} !important;
+      font-size: 0.9em !important;
+      line-height: 1.4 !important;
+    }
+
+    /* Hide old code block lines and fences in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .code-block-line {
+      display: none !important;
+    }
+
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .code-fence {
+      display: none !important;
+    }
+
+    /* Blockquotes - enhanced styling in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .blockquote {
+      display: block !important;
+      border-left: 4px solid var(--blockquote, #ddd) !important;
+      padding-left: 1em !important;
+      margin: 1em 0 !important;
+      font-style: italic !important;
+    }
+
+    /* Typography improvements in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview {
+      font-family: Georgia, 'Times New Roman', serif !important;
+      font-size: 16px !important;
+      line-height: 1.8 !important;
+      color: var(--text, #333) !important; /* Consistent text color */
+    }
+
+    /* Inline code in preview mode - keep monospace */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview code {
+      font-family: ${n} !important;
+      font-size: 0.9em !important;
+      background: rgba(135, 131, 120, 0.15) !important;
+      padding: 0.2em 0.4em !important;
+      border-radius: 3px !important;
+    }
+
+    /* Strong and em elements in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview strong {
+      font-weight: 700 !important;
+      color: inherit !important; /* Use parent text color */
+    }
+
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview em {
+      font-style: italic !important;
+      color: inherit !important; /* Use parent text color */
+    }
+
+    /* HR in preview mode */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .hr-marker {
+      display: block !important;
+      border-top: 2px solid var(--hr, #ddd) !important;
+      text-indent: -9999px !important;
+      height: 2px !important;
+    }
+    
+    /* Tables - GFM-style table rendering */
+    .marzipan-preview .marzipan-table {
+      border-collapse: collapse;
+      margin: 1em 0;
+      width: 100%;
+      overflow: auto;
+    }
+    
+    .marzipan-preview .marzipan-table th,
+    .marzipan-preview .marzipan-table td {
+      border: 1px solid var(--border, #ddd);
+      padding: 0.5em 1em;
+      text-align: left;
+    }
+    
+    .marzipan-preview .marzipan-table th {
+      background: var(--bgSecondary, #f5f5f5);
+      font-weight: 600;
+    }
+    
+    .marzipan-preview .marzipan-table tr:nth-child(even) {
+      background: var(--bgSecondary, #f9f9f9);
+    }
+    
+    /* In preview mode - hide table syntax markers */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .table-row,
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .table-separator {
+      display: none !important;
+    }
+    
+    /* Images - responsive and styled */
+    .marzipan-preview .marzipan-image {
+      max-width: 100%;
+      height: auto;
+      display: inline-block;
+      border-radius: 4px;
+      margin: 0.5em 0;
+    }
+    
+    /* In preview mode - make images fully visible */
+    .marzipan-container.preview-mode .marzipan-wrapper .marzipan-preview .marzipan-image {
+      display: block;
+      margin: 1em auto;
+    }
+
+    ${s}
+  `;
+}
+const Ne = `<svg viewBox="0 0 18 18">
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5,4H9.5A2.5,2.5,0,0,1,12,6.5v0A2.5,2.5,0,0,1,9.5,9H5A0,0,0,0,1,5,9V4A0,0,0,0,1,5,4Z"></path>
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5,9h5.5A2.5,2.5,0,0,1,13,11.5v0A2.5,2.5,0,0,1,10.5,14H5a0,0,0,0,1,0,0V9A0,0,0,0,1,5,9Z"></path>
+</svg>`, je = `<svg viewBox="0 0 18 18">
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="7" x2="13" y1="4" y2="4"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="5" x2="11" y1="14" y2="14"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="8" x2="10" y1="14" y2="4"></line>
+</svg>`, Oe = `<svg viewBox="0 0 18 18">
+  <path fill="currentColor" d="M10,4V14a1,1,0,0,1-2,0V10H3v4a1,1,0,0,1-2,0V4A1,1,0,0,1,3,4V8H8V4a1,1,0,0,1,2,0Zm6.06787,9.209H14.98975V7.59863a.54085.54085,0,0,0-.605-.60547h-.62744a1.01119,1.01119,0,0,0-.748.29688L11.645,8.56641a.5435.5435,0,0,0-.022.8584l.28613.30762a.53861.53861,0,0,0,.84717.0332l.09912-.08789a1.2137,1.2137,0,0,0,.2417-.35254h.02246s-.01123.30859-.01123.60547V13.209H12.041a.54085.54085,0,0,0-.605.60547v.43945a.54085.54085,0,0,0,.605.60547h4.02686a.54085.54085,0,0,0,.605-.60547v-.43945A.54085.54085,0,0,0,16.06787,13.209Z"></path>
+</svg>`, Fe = `<svg viewBox="0 0 18 18">
+  <path fill="currentColor" d="M16.73975,13.81445v.43945a.54085.54085,0,0,1-.605.60547H11.855a.58392.58392,0,0,1-.64893-.60547V14.0127c0-2.90527,3.39941-3.42187,3.39941-4.55469a.77675.77675,0,0,0-.84717-.78125,1.17684,1.17684,0,0,0-.83594.38477c-.2749.26367-.561.374-.85791.13184l-.4292-.34082c-.30811-.24219-.38525-.51758-.1543-.81445a2.97155,2.97155,0,0,1,2.45361-1.17676,2.45393,2.45393,0,0,1,2.68408,2.40918c0,2.45312-3.1792,2.92676-3.27832,3.93848h2.79443A.54085.54085,0,0,1,16.73975,13.81445ZM9,3A.99974.99974,0,0,0,8,4V8H3V4A1,1,0,0,0,1,4V14a1,1,0,0,0,2,0V10H8v4a1,1,0,0,0,2,0V4A.99974.99974,0,0,0,9,3Z"></path>
+</svg>`, Ve = `<svg viewBox="0 0 18 18">
+  <path fill="currentColor" d="M16.65186,12.30664a2.6742,2.6742,0,0,1-2.915,2.68457,3.96592,3.96592,0,0,1-2.25537-.6709.56007.56007,0,0,1-.13232-.83594L11.64648,13c.209-.34082.48389-.36328.82471-.1543a2.32654,2.32654,0,0,0,1.12256.33008c.71484,0,1.12207-.35156,1.12207-.78125,0-.61523-.61621-.86816-1.46338-.86816H13.2085a.65159.65159,0,0,1-.68213-.41895l-.05518-.10937a.67114.67114,0,0,1,.14307-.78125l.71533-.86914a8.55289,8.55289,0,0,1,.68213-.7373V8.58887a3.93913,3.93913,0,0,1-.748.05469H11.9873a.54085.54085,0,0,1-.605-.60547V7.59863a.54085.54085,0,0,1,.605-.60547h3.75146a.53773.53773,0,0,1,.60547.59375v.17676a1.03723,1.03723,0,0,1-.27539.748L14.74854,10.0293A2.31132,2.31132,0,0,1,16.65186,12.30664ZM9,3A.99974.99974,0,0,0,8,4V8H3V4A1,1,0,0,0,1,4V14a1,1,0,0,0,2,0V10H8v4a1,1,0,0,0,2,0V4A.99974.99974,0,0,0,9,3Z"></path>
+</svg>`, De = `<svg viewBox="0 0 18 18">
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="7" x2="11" y1="7" y2="11"></line>
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8.9,4.577a3.476,3.476,0,0,1,.36,4.679A3.476,3.476,0,0,1,4.577,8.9C3.185,7.5,2.035,6.4,4.217,4.217S7.5,3.185,8.9,4.577Z"></path>
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13.423,9.1a3.476,3.476,0,0,0-4.679-.36,3.476,3.476,0,0,0,.36,4.679c1.392,1.392,2.5,2.542,4.679.36S14.815,10.5,13.423,9.1Z"></path>
+</svg>`, Ue = `<svg viewBox="0 0 18 18">
+  <polyline stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" points="5 7 3 9 5 11"></polyline>
+  <polyline stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" points="13 7 15 9 13 11"></polyline>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="10" x2="8" y1="5" y2="13"></line>
+</svg>`, qe = `<svg viewBox="0 0 18 18">
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="6" x2="15" y1="4" y2="4"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="6" x2="15" y1="9" y2="9"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="6" x2="15" y1="14" y2="14"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="3" x2="3" y1="4" y2="4"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="3" x2="3" y1="9" y2="9"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="3" x2="3" y1="14" y2="14"></line>
+</svg>`, We = `<svg viewBox="0 0 18 18">
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="7" x2="15" y1="4" y2="4"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="7" x2="15" y1="9" y2="9"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="7" x2="15" y1="14" y2="14"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="1" x1="2.5" x2="4.5" y1="5.5" y2="5.5"></line>
+  <path fill="currentColor" d="M3.5,6A0.5,0.5,0,0,1,3,5.5V3.085l-0.276.138A0.5,0.5,0,0,1,2.053,3c-0.124-.247-0.023-0.324.224-0.447l1-.5A0.5,0.5,0,0,1,4,2.5v3A0.5,0.5,0,0,1,3.5,6Z"></path>
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="1" d="M4.5,10.5h-2c0-.234,1.85-1.076,1.85-2.234A0.959,0.959,0,0,0,2.5,8.156"></path>
+  <path stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="1" d="M2.5,14.846a0.959,0.959,0,0,0,1.85-.109A0.7,0.7,0,0,0,3.75,14a0.688,0.688,0,0,0,.6-0.736,0.959,0.959,0,0,0-1.85-.109"></path>
+</svg>`, Ke = `<svg viewBox="2 2 20 20">
+  <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 10.8182L9 10.8182C8.80222 10.8182 8.60888 10.7649 8.44443 10.665C8.27998 10.5651 8.15181 10.4231 8.07612 10.257C8.00043 10.0909 7.98063 9.90808 8.01922 9.73174C8.0578 9.55539 8.15304 9.39341 8.29289 9.26627C8.43275 9.13913 8.61093 9.05255 8.80491 9.01747C8.99889 8.98239 9.19996 9.00039 9.38268 9.0692C9.56541 9.13801 9.72159 9.25453 9.83147 9.40403C9.94135 9.55353 10 9.72929 10 9.90909L10 12.1818C10 12.664 9.78929 13.1265 9.41421 13.4675C9.03914 13.8084 8.53043 14 8 14"></path>
+  <path stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M16 10.8182L15 10.8182C14.8022 10.8182 14.6089 10.7649 14.4444 10.665C14.28 10.5651 14.1518 10.4231 14.0761 10.257C14.0004 10.0909 13.9806 9.90808 14.0192 9.73174C14.0578 9.55539 14.153 9.39341 14.2929 9.26627C14.4327 9.13913 14.6109 9.05255 14.8049 9.01747C14.9989 8.98239 15.2 9.00039 15.3827 9.0692C15.5654 9.13801 15.7216 9.25453 15.8315 9.40403C15.9414 9.55353 16 9.72929 16 9.90909L16 12.1818C16 12.664 15.7893 13.1265 15.4142 13.4675C15.0391 13.8084 14.5304 14 14 14"></path>
+</svg>`, Ze = `<svg viewBox="0 0 18 18">
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="8" x2="16" y1="4" y2="4"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="8" x2="16" y1="9" y2="9"></line>
+  <line stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="2" x1="8" x2="16" y1="14" y2="14"></line>
+  <rect stroke="currentColor" fill="none" stroke-width="1.5" x="2" y="3" width="3" height="3" rx="0.5"></rect>
+  <rect stroke="currentColor" fill="none" stroke-width="1.5" x="2" y="13" width="3" height="3" rx="0.5"></rect>
+  <polyline stroke="currentColor" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-width="1.5" points="2.65 9.5 3.5 10.5 5 8.5"></polyline>
+</svg>`, Je = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z" fill="none"></path>
+  <circle cx="12" cy="12" r="3" fill="none"></circle>
+</svg>`;
+class Qe {
+  constructor(e, t = null) {
+    this.container = null, this.buttons = {}, this.actions = Pe, this.editor = e, this.buttonConfig = t;
+  }
+  create() {
+    this.container = document.createElement("div"), this.container.className = "marzipan-toolbar", this.container.setAttribute("role", "toolbar"), this.container.setAttribute("aria-label", "Text formatting"), (this.buttonConfig ?? [
+      { name: "bold", icon: Ne, title: "Bold (Ctrl+B)", action: "toggleBold" },
+      { name: "italic", icon: je, title: "Italic (Ctrl+I)", action: "toggleItalic" },
+      { separator: !0 },
+      { name: "h1", icon: Oe, title: "Heading 1", action: "insertH1" },
+      { name: "h2", icon: Fe, title: "Heading 2", action: "insertH2" },
+      { name: "h3", icon: Ve, title: "Heading 3", action: "insertH3" },
+      { separator: !0 },
+      { name: "link", icon: De, title: "Insert Link (Ctrl+K)", action: "insertLink" },
+      { name: "code", icon: Ue, title: "Code (Ctrl+`)", action: "toggleCode" },
+      { separator: !0 },
+      { name: "quote", icon: Ke, title: "Quote", action: "toggleQuote" },
+      { separator: !0 },
+      { name: "bulletList", icon: qe, title: "Bullet List", action: "toggleBulletList" },
+      { name: "orderedList", icon: We, title: "Numbered List", action: "toggleNumberedList" },
+      { name: "taskList", icon: Ze, title: "Task List", action: "toggleTaskList" },
+      { separator: !0 },
+      { name: "viewMode", icon: Je, title: "View mode", action: "toggle-view-menu", hasDropdown: !0 }
+    ]).forEach((r) => {
+      if (r.separator) {
+        const o = document.createElement("div");
+        o.className = "marzipan-toolbar-separator", o.setAttribute("role", "separator"), this.container.appendChild(o);
+      } else if (r.action && r.icon) {
+        const o = this.createButton(r);
+        r.name && (this.buttons[r.name] = o), this.container.appendChild(o);
+      }
+    });
+    const t = this.editor.element.querySelector(".marzipan-container"), n = this.editor.element.querySelector(".marzipan-wrapper");
+    return t instanceof HTMLElement && n instanceof HTMLElement && t.insertBefore(this.container, n), this.container;
+  }
+  createButton(e) {
+    const t = document.createElement("button");
+    return t.className = "marzipan-toolbar-button", t.type = "button", t.title = e.title ?? "", t.setAttribute("aria-label", e.title ?? ""), e.action && (t.dataset.action = e.action), t.innerHTML = e.icon ?? "", e.hasDropdown && (t.classList.add("has-dropdown"), e.name === "viewMode" && (this.viewModeButton = t)), t.addEventListener("click", (n) => {
+      n.preventDefault(), e.action && this.handleAction(e.action, t);
+    }), t;
+  }
+  handleAction(e, t) {
+    const n = this.editor.textarea;
+    if (n) {
+      if (e === "toggle-view-menu") {
+        t && this.toggleViewDropdown(t);
+        return;
+      }
+      switch (n.focus(), e) {
+        case "toggleBold":
+          this.actions.toggleBold(n);
+          break;
+        case "toggleItalic":
+          this.actions.toggleItalic(n);
+          break;
+        case "insertH1":
+          this.actions.toggleH1(n);
+          break;
+        case "insertH2":
+          this.actions.toggleH2(n);
+          break;
+        case "insertH3":
+          this.actions.toggleH3(n);
+          break;
+        case "insertLink":
+          this.actions.insertLink(n);
+          break;
+        case "toggleCode":
+          this.actions.toggleCode(n);
+          break;
+        case "toggleBulletList":
+          this.actions.toggleBulletList(n);
+          break;
+        case "toggleNumberedList":
+          this.actions.toggleNumberedList(n);
+          break;
+        case "toggleQuote":
+          this.actions.toggleQuote(n);
+          break;
+        case "toggleTaskList":
+          this.actions.toggleTaskList(n);
+          break;
+        case "toggle-plain":
+          this.togglePlainMode();
+          break;
+        default:
+          console.warn(`[Marzipan] Unknown toolbar action: ${e}`);
+          break;
+      }
+      e !== "toggle-view-menu" && n.dispatchEvent(new Event("input", { bubbles: !0 }));
+    }
+  }
+  togglePlainMode() {
+    const e = this.editor.container.classList.contains("plain-mode");
+    this.editor.showPlainTextarea(!e);
+  }
+  updateButtonStates() {
+    const e = this.editor.textarea;
+    if (!e) return;
+    const t = this.actions.getActiveFormats(e);
+    Object.entries(this.buttons).forEach(([n, r]) => {
+      let o = !1;
+      switch (n) {
+        case "bold":
+          o = t.includes("bold");
+          break;
+        case "italic":
+          o = t.includes("italic");
+          break;
+        case "code":
+          o = !1;
+          break;
+        case "bulletList":
+          o = t.includes("bullet-list");
+          break;
+        case "orderedList":
+          o = t.includes("numbered-list");
+          break;
+        case "quote":
+          o = t.includes("quote");
+          break;
+        case "taskList":
+          o = t.includes("task-list");
+          break;
+        case "h1":
+          o = t.includes("header");
+          break;
+        case "h2":
+          o = t.includes("header-2");
+          break;
+        case "h3":
+          o = t.includes("header-3");
+          break;
+        case "togglePlain":
+          o = !this.editor.container.classList.contains("plain-mode");
+          break;
+      }
+      r.classList.toggle("active", o), r.setAttribute("aria-pressed", String(o));
+    });
+  }
+  toggleViewDropdown(e) {
+    const t = document.querySelector(".marzipan-dropdown-menu");
+    if (t instanceof HTMLElement) {
+      t.remove(), e.classList.remove("dropdown-active"), document.removeEventListener("click", this.handleDocumentClick);
+      return;
+    }
+    const n = this.createViewDropdown(), r = e.getBoundingClientRect();
+    n.style.top = `${r.bottom + 4}px`, n.style.left = `${r.left}px`, document.body.appendChild(n), e.classList.add("dropdown-active"), this.handleDocumentClick = (o) => {
+      !e.contains(o.target) && !n.contains(o.target) && (n.remove(), e.classList.remove("dropdown-active"), document.removeEventListener("click", this.handleDocumentClick));
+    }, setTimeout(() => {
+      document.addEventListener("click", this.handleDocumentClick);
+    }, 0);
+  }
+  createViewDropdown() {
+    const e = document.createElement("div");
+    e.className = "marzipan-dropdown-menu";
+    const t = this.editor.container.classList.contains("plain-mode"), r = this.editor.container.classList.contains("preview-mode") ? "preview" : t ? "plain" : "normal";
+    return [
+      { id: "normal", label: "Normal Edit", icon: "✓" },
+      { id: "plain", label: "Plain Textarea", icon: "✓" },
+      { id: "preview", label: "Preview Mode", icon: "✓" }
+    ].forEach((a) => {
+      const s = document.createElement("button");
+      s.className = "marzipan-dropdown-item", s.type = "button";
+      const c = document.createElement("span");
+      c.className = "marzipan-dropdown-check", c.textContent = r === a.id ? a.icon : "";
+      const p = document.createElement("span");
+      p.textContent = a.label, s.appendChild(c), s.appendChild(p), r === a.id && s.classList.add("active"), s.addEventListener("click", (d) => {
+        d.stopPropagation(), this.setViewMode(a.id), e.remove(), this.viewModeButton?.classList.remove("dropdown-active"), this.handleDocumentClick && document.removeEventListener("click", this.handleDocumentClick);
+      }), e.appendChild(s);
+    }), e;
+  }
+  setViewMode(e) {
+    switch (this.editor.container.classList.remove("plain-mode", "preview-mode"), e) {
+      case "plain":
+        this.editor.showPlainTextarea(!0);
+        break;
+      case "preview":
+        this.editor.showPreviewMode?.(!0);
+        break;
+      case "normal":
+      default:
+        this.editor.showPlainTextarea(!1), typeof this.editor.showPreviewMode == "function" && this.editor.showPreviewMode(!1);
+        break;
+    }
+  }
+  destroy() {
+    this.container && (this.handleDocumentClick && document.removeEventListener("click", this.handleDocumentClick), this.container.remove(), this.container = null, this.buttons = {}, this.viewModeButton = void 0, this.handleDocumentClick = void 0);
+  }
+}
+let le = !1;
+function Ge() {
+  if (le || typeof document > "u") return;
+  const i = document.createElement("style");
+  i.className = "marzipan-link-tooltip-styles", i.textContent = `
+    @supports (position-anchor: --x) and (position-area: center) {
+      .marzipan-link-tooltip {
+        position: absolute;
+        position-anchor: var(--target-anchor, --link-0);
+        position-area: block-end center;
+        margin-top: 8px !important;
+        background: #333 !important;
+        color: white !important;
+        padding: 6px 10px !important;
+        border-radius: 16px !important;
+        font-size: 12px !important;
+        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif !important;
+        display: none !important;
+        z-index: 10000 !important;
+        cursor: pointer !important;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.3) !important;
+        max-width: 300px !important;
+        white-space: nowrap !important;
+        overflow: hidden !important;
+        text-overflow: ellipsis !important;
+        position-try: most-width block-end inline-end, flip-inline, block-start center;
+        position-visibility: anchors-visible;
+      }
+
+      .marzipan-link-tooltip.visible {
+        display: flex !important;
+      }
+    }
+  `, document.head.appendChild(i), le = !0;
+}
+class Xe {
+  constructor(e) {
+    this.editor = e, this.tooltip = null, this.currentLink = null, this.hideTimeout = null, this.supportsAnchor = !1, this._selectionHandler = null, this._keyupHandler = null, this._inputHandler = null, this._scrollHandler = null, this._tooltipEnterHandler = null, this._tooltipLeaveHandler = null, this.init();
+  }
+  init() {
+    typeof CSS > "u" || typeof CSS.supports != "function" || !(CSS.supports("position-anchor: --x") && CSS.supports("position-area: center")) || (Ge(), this.supportsAnchor = !0, this.createTooltip(), this.bindListeners());
+  }
+  bindListeners() {
+    !this.supportsAnchor || typeof document > "u" || !this.tooltip || (this._selectionHandler = () => this.handleSelectionChange(), document.addEventListener("selectionchange", this._selectionHandler), this._keyupHandler = (e) => {
+      (e.key.includes("Arrow") || e.key === "Home" || e.key === "End") && this.checkCursorPosition();
+    }, this.editor.textarea.addEventListener("keyup", this._keyupHandler), this._inputHandler = () => this.hide(), this.editor.textarea.addEventListener("input", this._inputHandler), this._scrollHandler = () => this.hide(), this.editor.textarea.addEventListener("scroll", this._scrollHandler), this._tooltipEnterHandler = () => this.cancelHide(), this._tooltipLeaveHandler = () => this.scheduleHide(), this.tooltip.addEventListener("mouseenter", this._tooltipEnterHandler), this.tooltip.addEventListener("mouseleave", this._tooltipLeaveHandler));
+  }
+  createTooltip() {
+    typeof document > "u" || (this.tooltip = document.createElement("div"), this.tooltip.className = "marzipan-link-tooltip", this.tooltip.innerHTML = `
+      <span style="display: flex; align-items: center; gap: 6px;">
+        <svg width="12" height="12" viewBox="0 0 20 20" fill="currentColor" style="flex-shrink: 0;">
+          <path d="M11 3a1 1 0 100 2h2.586l-6.293 6.293a1 1 0 101.414 1.414L15 6.414V9a1 1 0 102 0V4a1 1 0 00-1-1h-5z"></path>
+          <path d="M5 5a2 2 0 00-2 2v8a2 2 0 002 2h8a2 2 0 002-2v-3a1 1 0 10-2 0v3H5V7h3a1 1 0 000-2H5z"></path>
+        </svg>
+        <span class="marzipan-link-tooltip-url"></span>
+      </span>
+    `, this.tooltip.addEventListener("click", (e) => {
+      e.preventDefault(), e.stopPropagation(), this.currentLink && (window.open(this.currentLink.url, "_blank"), this.hide());
+    }), this.editor.container.appendChild(this.tooltip));
+  }
+  handleSelectionChange() {
+    if (!(typeof document > "u")) {
+      if (document.activeElement !== this.editor.textarea) {
+        this.scheduleHide();
+        return;
+      }
+      this.checkCursorPosition();
+    }
+  }
+  checkCursorPosition() {
+    if (!this.tooltip) return;
+    const e = this.editor.textarea.selectionStart, t = this.editor.textarea.value, n = this.findLinkAtPosition(t, e);
+    n ? (!this.currentLink || this.currentLink.url !== n.url || this.currentLink.index !== n.index) && this.show(n) : this.scheduleHide();
+  }
+  findLinkAtPosition(e, t) {
+    const n = /\[([^\]]+)\]\(([^)]+)\)/g;
+    let r, o = 0;
+    for (; (r = n.exec(e)) !== null; ) {
+      const a = r.index, s = r.index + r[0].length;
+      if (t >= a && t <= s)
+        return {
+          text: r[1],
+          url: r[2],
+          index: o,
+          start: a,
+          end: s
+        };
+      o++;
+    }
+    return null;
+  }
+  show(e) {
+    if (!this.tooltip) return;
+    this.currentLink = e, this.cancelHide();
+    const t = this.tooltip.querySelector(".marzipan-link-tooltip-url");
+    t && (t.textContent = e.url), this.tooltip.style.setProperty("--target-anchor", `--link-${e.index}`), this.tooltip.classList.add("visible");
+  }
+  hide() {
+    this.tooltip && (this.tooltip.classList.remove("visible"), this.currentLink = null);
+  }
+  scheduleHide() {
+    this.cancelHide(), this.hideTimeout = setTimeout(() => this.hide(), 300);
+  }
+  cancelHide() {
+    this.hideTimeout && (clearTimeout(this.hideTimeout), this.hideTimeout = null);
+  }
+  destroy() {
+    this.cancelHide(), this._selectionHandler && typeof document < "u" && (document.removeEventListener("selectionchange", this._selectionHandler), this._selectionHandler = null), this._keyupHandler && (this.editor.textarea.removeEventListener("keyup", this._keyupHandler), this._keyupHandler = null), this._inputHandler && (this.editor.textarea.removeEventListener("input", this._inputHandler), this._inputHandler = null), this._scrollHandler && (this.editor.textarea.removeEventListener("scroll", this._scrollHandler), this._scrollHandler = null), this._tooltipEnterHandler && (this.tooltip?.removeEventListener("mouseenter", this._tooltipEnterHandler), this._tooltipEnterHandler = null), this._tooltipLeaveHandler && (this.tooltip?.removeEventListener("mouseleave", this._tooltipLeaveHandler), this._tooltipLeaveHandler = null), this.tooltip && this.tooltip.parentNode && this.tooltip.parentNode.removeChild(this.tooltip), this.tooltip = null, this.currentLink = null;
+  }
+}
+/**
+ * Marzipan - A lightweight markdown editor and viewer
+ * @version 1.0.0
+ * @license Apache-2.0
+ */
+const w = class w {
+  /**
+   * Constructor - Always returns an array of instances
+   * @param {string|Element|NodeList|Array} target - Target element(s)
+   * @param {Object} options - Configuration options
+   * @returns {Array} Array of Marzipan instances
+   */
+  constructor(e, t = {}) {
+    let n;
+    if (typeof e == "string") {
+      if (n = document.querySelectorAll(e), n.length === 0)
+        throw new Error(`No elements found for selector: ${e}`);
+      n = Array.from(n);
+    } else if (e instanceof Element)
+      n = [e];
+    else if (e instanceof NodeList)
+      n = Array.from(e);
+    else if (Array.isArray(e))
+      n = e;
+    else
+      throw new Error("Invalid target: must be selector string, Element, NodeList, or Array");
+    return n.map((o) => {
+      if (o.MarzipanInstance)
+        return o.MarzipanInstance.reinit(t), o.MarzipanInstance;
+      const a = Object.create(w.prototype);
+      return a._init(o, t), o.MarzipanInstance = a, w.instances.set(o, a), a;
+    });
+  }
+  /**
+   * Internal initialization
+   * @private
+   */
+  _init(e, t = {}) {
+    this.element = e, this.instanceTheme = t.theme || null, this.options = this._mergeOptions(t), this.instanceId = ++w.instanceCount, this.initialized = !1, this._autoResizeInputHandler = null, this._autoResizeResizeHandler = null, this._minAutoHeight = null, this._maxAutoHeight = null, w.injectStyles(), w.initGlobalListeners();
+    const n = e.querySelector(".marzipan-container"), r = e.querySelector(".marzipan-wrapper");
+    if (n || r ? this._recoverFromDOM(n, r) : this._buildFromScratch(), this.shortcuts = new xe(this), this.linkTooltip = new Xe(this), this.options.toolbar) {
+      const a = typeof this.options.toolbar == "object" ? this.options.toolbar.buttons : null;
+      this.toolbar = new Qe(this, a), this.toolbar.create(), this.textarea.addEventListener("selectionchange", () => {
+        this.toolbar?.updateButtonStates?.();
+      }), this.textarea.addEventListener("input", () => {
+        this.toolbar?.updateButtonStates?.();
+      });
+    }
+    this._applyPlugins() && this.updatePreview(), this.initialized = !0, this.options.onChange && this.options.onChange(this.getValue(), this);
+  }
+  /**
+   * Merge user options with defaults
+   * @private
+   */
+  _mergeOptions(e) {
+    const t = {
+      // Typography
+      fontSize: "14px",
+      lineHeight: 1.6,
+      /* System-first, guaranteed monospaced; avoids Android 'ui-monospace' pitfalls */
+      fontFamily: '"SF Mono", SFMono-Regular, Menlo, Monaco, "Cascadia Code", Consolas, "Roboto Mono", "Noto Sans Mono", "Droid Sans Mono", "Ubuntu Mono", "DejaVu Sans Mono", "Liberation Mono", "Courier New", Courier, monospace',
+      padding: "16px",
+      // Mobile styles
+      mobile: {
+        fontSize: "16px",
+        // Prevent zoom on iOS
+        padding: "12px",
+        lineHeight: 1.5
+      },
+      // Native textarea properties
+      textareaProps: {},
+      // Behavior
+      autofocus: !1,
+      autoResize: !1,
+      // Auto-expand height with content
+      minHeight: "100px",
+      // Minimum height for autoResize mode
+      maxHeight: null,
+      // Maximum height for autoResize mode (null = unlimited)
+      placeholder: "Start typing...",
+      value: "",
+      // Callbacks
+      onChange: null,
+      onKeydown: null,
+      // Features
+      showActiveLineRaw: !1,
+      showStats: !1,
+      toolbar: !1,
+      statsFormatter: null,
+      smartLists: !0
+      // Enable smart list continuation
+    }, { theme: n, colors: r, hooks: o, plugins: a, ...s } = e;
+    return {
+      ...t,
+      ...s,
+      hooks: o ? { ...o } : void 0,
+      plugins: Array.isArray(a) ? [...a] : void 0
+    };
+  }
+  /**
+   * Apply plugins attached to this editor instance
+   * @private
+   */
+  _applyPlugins() {
+    if (!Array.isArray(this.options?.plugins) || !this.options.plugins.length)
+      return !1;
+    this._appliedPlugins || (this._appliedPlugins = /* @__PURE__ */ new Set());
+    let e = !1;
+    for (const t of this.options.plugins)
+      if (typeof t == "function" && !this._appliedPlugins.has(t)) {
+        this._appliedPlugins.add(t);
+        try {
+          t(this);
+        } catch (n) {
+          console.error("[Marzipan] Plugin error:", n);
+        }
+        e = !0;
+      }
+    return e;
+  }
+  /**
+   * Recover from existing DOM structure
+   * @private
+   */
+  _recoverFromDOM(e, t) {
+    if (e && e.classList.contains("marzipan-container"))
+      this.container = e, this.wrapper = e.querySelector(".marzipan-wrapper");
+    else if (t) {
+      this.wrapper = t, this.container = document.createElement("div"), this.container.className = "marzipan-container";
+      const n = this.instanceTheme || w.currentTheme || M, r = typeof n == "string" ? n : n.name;
+      if (r && this.container.setAttribute("data-theme", r), this.instanceTheme) {
+        const o = typeof this.instanceTheme == "string" ? _(this.instanceTheme) : this.instanceTheme;
+        if (o && o.colors) {
+          const a = F(o.colors);
+          this.container.style.cssText += a;
+        }
+      }
+      t.parentNode.insertBefore(this.container, t), this.container.appendChild(t);
+    }
+    if (this.container && this.container.setAttribute("data-marzipan-instance", String(this.instanceId)), !this.wrapper) {
+      e && e.remove(), t && t.remove(), this._buildFromScratch();
+      return;
+    }
+    if (this.textarea = this.wrapper.querySelector(".marzipan-input"), this.preview = this.wrapper.querySelector(".marzipan-preview"), !this.textarea || !this.preview) {
+      this.container.remove(), this._buildFromScratch();
+      return;
+    }
+    this.wrapper._instance = this, this.options.fontSize && this.wrapper.style.setProperty("--instance-font-size", this.options.fontSize), this.options.lineHeight && this.wrapper.style.setProperty("--instance-line-height", String(this.options.lineHeight)), this.options.padding && this.wrapper.style.setProperty("--instance-padding", this.options.padding), this._configureTextarea(), this._applyOptions();
+  }
+  /**
+   * Build editor from scratch
+   * @private
+   */
+  _buildFromScratch() {
+    const e = this._extractContent();
+    this.element.innerHTML = "", this._createDOM(), (e || this.options.value) && this.setValue(e || this.options.value), this._applyOptions();
+  }
+  /**
+   * Extract content from element
+   * @private
+   */
+  _extractContent() {
+    const e = this.element.querySelector(".marzipan-input");
+    return e ? e.value : this.element.textContent || "";
+  }
+  /**
+   * Create DOM structure
+   * @private
+   */
+  _createDOM() {
+    this.container = document.createElement("div"), this.container.className = "marzipan-container", this.container.setAttribute("data-marzipan-instance", String(this.instanceId));
+    const e = this.instanceTheme || w.currentTheme || M, t = typeof e == "string" ? e : e.name;
+    if (t && this.container.setAttribute("data-theme", t), this.instanceTheme) {
+      const n = typeof this.instanceTheme == "string" ? _(this.instanceTheme) : this.instanceTheme;
+      if (n && n.colors) {
+        const r = F(n.colors);
+        this.container.style.cssText += r;
+      }
+    }
+    this.wrapper = document.createElement("div"), this.wrapper.className = "marzipan-wrapper", this.options.fontSize && this.wrapper.style.setProperty("--instance-font-size", this.options.fontSize), this.options.lineHeight && this.wrapper.style.setProperty("--instance-line-height", String(this.options.lineHeight)), this.options.padding && this.wrapper.style.setProperty("--instance-padding", this.options.padding), this.wrapper._instance = this, this.textarea = document.createElement("textarea"), this.textarea.className = "marzipan-input", this.textarea.placeholder = this.options.placeholder, this._configureTextarea(), this.options.textareaProps && Object.entries(this.options.textareaProps).forEach(([n, r]) => {
+      n === "className" || n === "class" ? this.textarea.className += " " + r : n === "style" && typeof r == "object" ? Object.assign(this.textarea.style, r) : this.textarea.setAttribute(n, r);
+    }), this.preview = document.createElement("div"), this.preview.className = "marzipan-preview", this.preview.setAttribute("aria-hidden", "true"), this.wrapper.appendChild(this.textarea), this.wrapper.appendChild(this.preview), this.container.appendChild(this.wrapper), this.options.showStats && (this.statsBar = document.createElement("div"), this.statsBar.className = "marzipan-stats", this.container.appendChild(this.statsBar), this._updateStats()), this.element.appendChild(this.container), this.options.autoResize ? this._setupAutoResize() : this.container.classList.remove("marzipan-auto-resize");
+  }
+  /**
+   * Configure textarea attributes
+   * @private
+   */
+  _configureTextarea() {
+    this.textarea.setAttribute("autocomplete", "off"), this.textarea.setAttribute("autocorrect", "off"), this.textarea.setAttribute("autocapitalize", "off"), this.textarea.setAttribute("spellcheck", "false"), this.textarea.setAttribute("data-gramm", "false"), this.textarea.setAttribute("data-gramm_editor", "false"), this.textarea.setAttribute("data-enable-grammarly", "false");
+  }
+  /**
+   * Apply options to the editor
+   * @private
+   */
+  _applyOptions() {
+    this.options.autofocus && this.textarea.focus(), this.options.autoResize ? this._setupAutoResize() : this._teardownAutoResize(), this.updatePreview();
+  }
+  /**
+   * Update preview with parsed markdown
+   */
+  updatePreview() {
+    const e = this.textarea.value, t = this.textarea.selectionStart, n = this._getCurrentLine(e, t), r = T.parse(e, n, this.options.showActiveLineRaw);
+    if (this.preview.innerHTML = r || '<span style="color: #808080;">Start typing...</span>', this.options?.hooks?.afterPreviewRender)
+      try {
+        this.options.hooks.afterPreviewRender(this.preview, this);
+      } catch (o) {
+        console.error("[Marzipan] afterPreviewRender hook error:", o);
+      }
+    this._applyCodeBlockBackgrounds(), this.options.showStats && this.statsBar && this._updateStats(), this.options.onChange && this.initialized && this.options.onChange(e, this);
+  }
+  /**
+   * Apply background styling to code blocks
+   * @private
+   */
+  _applyCodeBlockBackgrounds() {
+    const e = this.preview.querySelectorAll(".code-fence");
+    for (let t = 0; t < e.length - 1; t += 2) {
+      const n = e[t], r = e[t + 1], o = n.parentElement, a = r.parentElement;
+      !o || !a || (n.style.display = "block", r.style.display = "block", o.classList.add("code-block-line"), a.classList.add("code-block-line"));
+    }
+  }
+  /**
+   * Get current line number from cursor position
+   * @private
+   */
+  _getCurrentLine(e, t) {
+    return e.substring(0, t).split(`
+`).length - 1;
+  }
+  /**
+   * Handle input events
+   * @private
+   */
+  handleInput(e) {
+    this.updatePreview();
+  }
+  /**
+   * Handle keydown events
+   * @private
+   */
+  handleKeydown(e) {
+    if (e.key === "Tab") {
+      e.preventDefault();
+      const n = this.textarea.selectionStart, r = this.textarea.selectionEnd, o = this.textarea.value;
+      if (n !== r && e.shiftKey) {
+        const a = o.substring(0, n), s = o.substring(n, r), c = o.substring(r), d = s.split(`
+`).map((l) => l.replace(/^  /, "")).join(`
+`);
+        document.execCommand ? (this.textarea.setSelectionRange(n, r), document.execCommand("insertText", !1, d)) : (this.textarea.value = a + d + c, this.textarea.selectionStart = n, this.textarea.selectionEnd = n + d.length);
+      } else if (n !== r) {
+        const a = o.substring(0, n), s = o.substring(n, r), c = o.substring(r), d = s.split(`
+`).map((l) => "  " + l).join(`
+`);
+        document.execCommand ? (this.textarea.setSelectionRange(n, r), document.execCommand("insertText", !1, d)) : (this.textarea.value = a + d + c, this.textarea.selectionStart = n, this.textarea.selectionEnd = n + d.length);
+      } else
+        document.execCommand ? document.execCommand("insertText", !1, "  ") : (this.textarea.value = o.substring(0, n) + "  " + o.substring(r), this.textarea.selectionStart = this.textarea.selectionEnd = n + 2);
+      this.textarea.dispatchEvent(new Event("input", { bubbles: !0 }));
+      return;
+    }
+    if (e.key === "Enter" && !e.shiftKey && !e.metaKey && !e.ctrlKey && this.options.smartLists && this.handleSmartListContinuation()) {
+      e.preventDefault();
+      return;
+    }
+    !this.shortcuts.handleKeydown(e) && this.options.onKeydown && this.options.onKeydown(e, this);
+  }
+  /**
+   * Handle smart list continuation
+   * @returns {boolean} Whether the event was handled
+   */
+  handleSmartListContinuation() {
+    const e = this.textarea, t = e.selectionStart, n = T.getListContext(e.value, t);
+    return !n || !n.inList ? !1 : n.content.trim() === "" && t >= n.markerEndPos ? (this.deleteListMarker(n), !0) : (t > n.markerEndPos && t < n.lineEnd ? this.splitListItem(n, t) : this.insertNewListItem(n), n.listType === "numbered" && this.scheduleNumberedListUpdate(), !0);
+  }
+  /**
+   * Delete list marker and exit list
+   * @private
+   */
+  deleteListMarker(e) {
+    this.textarea.setSelectionRange(e.lineStart, e.markerEndPos), document.execCommand("delete"), this.textarea.dispatchEvent(new Event("input", { bubbles: !0 }));
+  }
+  /**
+   * Insert new list item
+   * @private
+   */
+  insertNewListItem(e) {
+    const t = T.createNewListItem(e);
+    document.execCommand("insertText", !1, `
+` + t), this.textarea.dispatchEvent(new Event("input", { bubbles: !0 }));
+  }
+  /**
+   * Split list item at cursor position
+   * @private
+   */
+  splitListItem(e, t) {
+    const n = e.content.substring(t - e.markerEndPos);
+    this.textarea.setSelectionRange(t, e.lineEnd), document.execCommand("delete");
+    const r = T.createNewListItem(e);
+    document.execCommand("insertText", !1, `
+` + r + n);
+    const o = this.textarea.selectionStart - n.length;
+    this.textarea.setSelectionRange(o, o), this.textarea.dispatchEvent(new Event("input", { bubbles: !0 }));
+  }
+  /**
+   * Schedule numbered list renumbering
+   * @private
+   */
+  scheduleNumberedListUpdate() {
+    this.numberUpdateTimeout && clearTimeout(this.numberUpdateTimeout), this.numberUpdateTimeout = setTimeout(() => {
+      this.updateNumberedLists();
+    }, 10);
+  }
+  /**
+   * Update/renumber all numbered lists
+   * @private
+   */
+  updateNumberedLists() {
+    const e = this.textarea.value, t = this.textarea.selectionStart, n = T.renumberLists(e);
+    if (n !== e) {
+      let r = 0;
+      const o = e.split(`
+`), a = n.split(`
+`);
+      let s = 0;
+      for (let p = 0; p < o.length && s < t; p++) {
+        if (o[p] !== a[p]) {
+          const d = a[p].length - o[p].length;
+          s + o[p].length < t && (r += d);
+        }
+        s += o[p].length + 1;
+      }
+      this.textarea.value = n;
+      const c = t + r;
+      this.textarea.setSelectionRange(c, c), this.textarea.dispatchEvent(new Event("input", { bubbles: !0 }));
+    }
+  }
+  /**
+   * Handle scroll events
+   * @private
+   */
+  handleScroll(e) {
+    this.preview.scrollTop = this.textarea.scrollTop, this.preview.scrollLeft = this.textarea.scrollLeft;
+  }
+  /**
+   * Get editor content
+   * @returns {string} Current markdown content
+   */
+  getValue() {
+    return this.textarea.value;
+  }
+  /**
+   * Set editor content
+   * @param {string} value - Markdown content to set
+   */
+  setValue(e) {
+    this.textarea.value = e, this.updatePreview(), this.options.autoResize && this._updateAutoHeight();
+  }
+  /**
+   * Get the rendered HTML of the current content
+   * @param {Object} options - Rendering options
+   * @param {boolean} options.cleanHTML - If true, removes syntax markers and Marzipan-specific classes
+   * @returns {string} Rendered HTML
+   */
+  getRenderedHTML(e = {}) {
+    const t = this.getValue();
+    let n = T.parse(t);
+    return e.cleanHTML && (n = n.replace(/<span class="syntax-marker[^"]*">.*?<\/span>/g, ""), n = n.replace(/\sclass="(bullet-list|ordered-list|code-fence|hr-marker|blockquote|url-part)"/g, ""), n = n.replace(/\sclass=""/g, "")), n;
+  }
+  /**
+   * Get the current preview element's HTML
+   * This includes all syntax markers and Marzipan styling
+   * @returns {string} Current preview HTML (as displayed)
+   */
+  getPreviewHTML() {
+    return this.preview.innerHTML;
+  }
+  /**
+   * Get clean HTML without any Marzipan-specific markup
+   * Useful for exporting to other formats or storage
+   * @returns {string} Clean HTML suitable for export
+   */
+  getCleanHTML() {
+    return this.getRenderedHTML({ cleanHTML: !0 });
+  }
+  /**
+   * Focus the editor
+   */
+  focus() {
+    this.textarea.focus();
+  }
+  /**
+   * Blur the editor
+   */
+  blur() {
+    this.textarea.blur();
+  }
+  /**
+   * Check if editor is initialized
+   * @returns {boolean}
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Re-initialize with new options
+   * @param {Object} options - New options to apply
+   */
+  reinit(e = {}) {
+    this.options = this._mergeOptions({ ...this.options, ...e }), this._applyOptions(), this._applyPlugins(), this.updatePreview();
+  }
+  /**
+   * Update stats bar
+   * @private
+   */
+  _updateStats() {
+    if (!this.statsBar) return;
+    const e = this.textarea.value, t = e.split(`
+`), n = e.length, r = e.split(/\s+/).filter((d) => d.length > 0).length, o = this.textarea.selectionStart, s = e.substring(0, o).split(`
+`), c = s.length, p = s[s.length - 1].length + 1;
+    this.options.statsFormatter ? this.statsBar.innerHTML = this.options.statsFormatter({
+      chars: n,
+      words: r,
+      lines: t.length,
+      line: c,
+      column: p
+    }) : this.statsBar.innerHTML = `
+          <div class="marzipan-stat">
+            <span class="live-dot"></span>
+            <span>${n} chars, ${r} words, ${t.length} lines</span>
+          </div>
+          <div class="marzipan-stat">Line ${c}, Col ${p}</div>
+        `;
+  }
+  /**
+   * Setup auto-resize functionality
+   * @private
+   */
+  _setupAutoResize() {
+    !this.container || !this.textarea || !this.preview || !this.wrapper || (this._teardownAutoResize(), this.container.classList.add("marzipan-auto-resize"), this.previousHeight = null, this._refreshAutoResizeConstraints(), this._autoResizeInputHandler = () => this._updateAutoHeight(), this.textarea.addEventListener("input", this._autoResizeInputHandler), typeof window < "u" ? (this._autoResizeResizeHandler = () => this._updateAutoHeight(), window.addEventListener("resize", this._autoResizeResizeHandler)) : this._autoResizeResizeHandler = null, this._updateAutoHeight());
+  }
+  _teardownAutoResize() {
+    this.container && this.container.classList.remove("marzipan-auto-resize"), this._autoResizeInputHandler && this.textarea && this.textarea.removeEventListener("input", this._autoResizeInputHandler), this._autoResizeInputHandler = null, this._autoResizeResizeHandler && typeof window < "u" && window.removeEventListener("resize", this._autoResizeResizeHandler), this._autoResizeResizeHandler = null, this.textarea && (this.textarea.style.removeProperty("height"), this.textarea.style.removeProperty("overflow-y")), this.preview && (this.preview.style.removeProperty("height"), this.preview.style.removeProperty("overflow-y")), this.wrapper && this.wrapper.style.removeProperty("height"), this.previousHeight = null, this._minAutoHeight = null, this._maxAutoHeight = null;
+  }
+  /**
+   * Update height based on scrollHeight
+   * @private
+   */
+  _updateAutoHeight() {
+    if (!this.options.autoResize) return;
+    const e = this.textarea, t = this.preview, n = this.wrapper, r = e.scrollTop;
+    e.style.setProperty("height", "auto", "important");
+    let o = e.scrollHeight, a = "hidden";
+    const s = this._minAutoHeight;
+    typeof s == "number" && s > 0 && (o = Math.max(o, s));
+    const c = this._maxAutoHeight;
+    typeof c == "number" && c > 0 && o > c && (o = c, a = "auto");
+    const p = o + "px";
+    e.style.setProperty("height", p, "important"), e.style.setProperty("overflow-y", a, "important"), t.style.setProperty("height", p, "important"), t.style.setProperty("overflow-y", a, "important"), n.style.setProperty("height", p, "important"), e.scrollTop = r, t.scrollTop = r, this.previousHeight !== o && (this.previousHeight = o);
+  }
+  _refreshAutoResizeConstraints() {
+    this._minAutoHeight = this._resolveSizeToPixels(this.options.minHeight), this._maxAutoHeight = this._resolveSizeToPixels(this.options.maxHeight);
+  }
+  _resolveSizeToPixels(e) {
+    if (e == null || e === "")
+      return null;
+    if (typeof e == "number")
+      return e > 0 ? e : null;
+    const t = String(e).trim();
+    if (!t)
+      return null;
+    const n = Number(t);
+    if (Number.isFinite(n) && n > 0)
+      return n;
+    if (typeof document > "u" || !document.body)
+      return null;
+    const r = document.createElement("div");
+    r.style.position = "absolute", r.style.visibility = "hidden", r.style.height = t, r.style.pointerEvents = "none", document.body.appendChild(r);
+    const o = r.getBoundingClientRect().height;
+    return r.remove(), !Number.isFinite(o) || o <= 0 ? null : o;
+  }
+  /**
+   * Show or hide stats bar
+   * @param {boolean} show - Whether to show stats
+   */
+  showStats(e) {
+    this.options.showStats = e, e && !this.statsBar ? (this.statsBar = document.createElement("div"), this.statsBar.className = "marzipan-stats", this.container.appendChild(this.statsBar), this._updateStats()) : !e && this.statsBar && (this.statsBar.remove(), this.statsBar = null);
+  }
+  /**
+   * Show or hide the plain textarea (toggle overlay visibility)
+   * @param {boolean} show - true to show plain textarea (hide overlay), false to show overlay
+   * @returns {boolean} Current plain textarea state
+   */
+  showPlainTextarea(e) {
+    if (e ? this.container.classList.add("plain-mode") : this.container.classList.remove("plain-mode"), this.toolbar) {
+      const t = this.container.querySelector('[data-action="toggle-plain"]');
+      t && (t.classList.toggle("active", !e), t.title = e ? "Show markdown preview" : "Show plain textarea");
+    }
+    return e;
+  }
+  /**
+   * Show/hide preview mode
+   * @param {boolean} show - Show preview mode if true, edit mode if false
+   * @returns {boolean} Current preview mode state
+   */
+  showPreviewMode(e) {
+    return e ? this.container.classList.add("preview-mode") : this.container.classList.remove("preview-mode"), e;
+  }
+  /**
+   * Destroy the editor instance
+   */
+  destroy() {
+    if (this.element.MarzipanInstance = null, w.instances.delete(this.element), this._teardownAutoResize(), this.linkTooltip && (this.linkTooltip.destroy(), this.linkTooltip = null), this.toolbar && (this.toolbar.destroy(), this.toolbar = null), this.shortcuts && this.shortcuts.destroy(), this.wrapper) {
+      const e = this.getValue();
+      this.wrapper.remove(), this.element.textContent = e;
+    }
+    this.container && this.container.removeAttribute("data-marzipan-instance"), this.initialized = !1;
+  }
+  // ===== Static Methods =====
+  /**
+   * Initialize multiple editors (static convenience method)
+   * @param {string|Element|NodeList|Array} target - Target element(s)
+   * @param {Object} options - Configuration options
+   * @returns {Array} Array of Marzipan instances
+   */
+  static init(e, t = {}) {
+    return new w(e, t);
+  }
+  /**
+   * Get instance from element
+   * @param {Element} element - DOM element
+   * @returns {Marzipan|null} Marzipan instance or null
+   */
+  static getInstance(e) {
+    return e.MarzipanInstance || w.instances.get(e) || null;
+  }
+  /**
+   * Destroy all instances
+   */
+  static destroyAll() {
+    document.querySelectorAll("[data-marzipan-instance]").forEach((t) => {
+      const n = w.getInstance(t);
+      n && n.destroy();
+    });
+  }
+  /**
+   * Inject styles into the document
+   * @param {boolean} force - Force re-injection
+   */
+  static injectStyles(e = !1) {
+    if (w.stylesInjected && !e) return;
+    const t = document.querySelector("style.marzipan-styles");
+    t && t.remove();
+    const n = w.currentTheme || M, r = Re({ theme: n }), o = document.createElement("style");
+    o.className = "marzipan-styles", o.textContent = r, document.head.appendChild(o), w.stylesInjected = !0;
+  }
+  /**
+   * Set global theme for all Marzipan instances
+   * @param {string|Object} theme - Theme name or custom theme object
+   * @param {Object} customColors - Optional color overrides
+   */
+  static setTheme(e, t = null) {
+    let n = typeof e == "string" ? _(e) : e;
+    t && (n = Be(n, t)), w.currentTheme = n, w.injectStyles(!0), document.querySelectorAll(".marzipan-container").forEach((r) => {
+      const o = typeof n == "string" ? n : n.name;
+      o && r.setAttribute("data-theme", o);
+    }), document.querySelectorAll(".marzipan-wrapper").forEach((r) => {
+      if (!r.closest(".marzipan-container")) {
+        const a = typeof n == "string" ? n : n.name;
+        a && r.setAttribute("data-theme", a);
+      }
+      const o = r._instance;
+      o && o.updatePreview();
+    });
+  }
+  /**
+   * Initialize global event listeners
+   */
+  static initGlobalListeners() {
+    w.globalListenersInitialized || (document.addEventListener("input", (e) => {
+      if (e.target && e.target.classList && e.target.classList.contains("marzipan-input")) {
+        const n = e.target.closest(".marzipan-wrapper")?._instance;
+        n && n.handleInput(e);
+      }
+    }), document.addEventListener("keydown", (e) => {
+      if (e.target && e.target.classList && e.target.classList.contains("marzipan-input")) {
+        const n = e.target.closest(".marzipan-wrapper")?._instance;
+        n && n.handleKeydown(e);
+      }
+    }), document.addEventListener("scroll", (e) => {
+      if (e.target && e.target.classList && e.target.classList.contains("marzipan-input")) {
+        const n = e.target.closest(".marzipan-wrapper")?._instance;
+        n && n.handleScroll(e);
+      }
+    }, !0), document.addEventListener("selectionchange", (e) => {
+      const t = document.activeElement;
+      if (t && t.classList.contains("marzipan-input")) {
+        const r = t.closest(".marzipan-wrapper")?._instance;
+        r && (r.options.showStats && r.statsBar && r._updateStats(), clearTimeout(r._selectionTimeout), r._selectionTimeout = setTimeout(() => {
+          r.updatePreview();
+        }, 50));
+      }
+    }), w.globalListenersInitialized = !0);
+  }
+};
+w.instances = /* @__PURE__ */ new WeakMap(), w.stylesInjected = !1, w.globalListenersInitialized = !1, w.instanceCount = 0;
+let A = w;
+A.MarkdownParser = T;
+A.ShortcutsManager = xe;
+A.themes = { solar: M, cave: _("cave") };
+A.getTheme = _;
+A.currentTheme = M;
+export {
+  Xe as LinkTooltip,
+  T as MarkdownParser,
+  A as Marzipan,
+  xe as ShortcutsManager,
+  Qe as Toolbar,
+  Pe as actions,
+  se as cave,
+  A as default,
+  Re as generateStyles,
+  _ as getTheme,
+  Be as mergeTheme,
+  M as solar,
+  F as themeToCSSVars,
+  ae as themes
+};
+//# sourceMappingURL=index.js.map