turnish 1.0.0

package/dist/index.mjs

@@ -0,0 +1,818 @@
+function B(t, e) {
+  const n = t;
+  return n.isBlock = E(n), n.isCode = n.nodeName === "CODE" || n.parentNode?.isCode, n.isBlank = P(n), n.flankingWhitespace = H(n, e), n;
+}
+function P(t) {
+  return !S(t) && !U(t) && /^\s*$/i.test(t.textContent || "") && !$(t) && !z(t);
+}
+function H(t, e) {
+  const n = t;
+  if (n.isBlock || e.preformattedCode && n.isCode)
+    return { leading: "", trailing: "" };
+  const r = _(t.textContent || "");
+  return r.leadingAscii && A("left", t, e) && (r.leading = r.leadingNonAscii), r.trailingAscii && A("right", t, e) && (r.trailing = r.trailingNonAscii), { leading: r.leading, trailing: r.trailing };
+}
+function _(t) {
+  const e = t.match(/^(([ \t\r\n]*)(\s*))(?:(?=\S)[\s\S]*\S)?((\s*?)([ \t\r\n]*))$/);
+  return e ? {
+    leading: e[1],
+    // whole string for whitespace-only strings
+    leadingAscii: e[2],
+    leadingNonAscii: e[3],
+    trailing: e[4],
+    // empty for whitespace-only strings
+    trailingNonAscii: e[5],
+    trailingAscii: e[6]
+  } : {
+    leading: "",
+    leadingAscii: "",
+    leadingNonAscii: "",
+    trailing: "",
+    trailingNonAscii: "",
+    trailingAscii: ""
+  };
+}
+function A(t, e, n) {
+  let r, i, l;
+  return t === "left" ? (r = e.previousElementSibling, i = / $/) : (r = e.nextElementSibling, i = /^ /), r && (r.nodeType === 3 ? l = i.test(r.nodeValue || "") : n.preformattedCode && r.nodeName === "CODE" ? l = !1 : r.nodeType === 1 && !E(r) && (l = i.test(r.textContent || ""))), l || !1;
+}
+const m = {
+  Element: 1,
+  Text: 3,
+  CDATASection: 4
+};
+function N(t, e) {
+  return Array(e + 1).join(t);
+}
+function D(t) {
+  return t.replace(/^\n*/, "");
+}
+function w(t) {
+  let e = t.length;
+  for (; e > 0 && t[e - 1] === `
+`; ) e--;
+  return t.substring(0, e);
+}
+function x(t) {
+  return w(D(t));
+}
+const v = [
+  "ADDRESS",
+  "ARTICLE",
+  "ASIDE",
+  "AUDIO",
+  "BLOCKQUOTE",
+  "BODY",
+  "CANVAS",
+  "CENTER",
+  "DD",
+  "DIR",
+  "DIV",
+  "DL",
+  "DT",
+  "FIELDSET",
+  "FIGCAPTION",
+  "FIGURE",
+  "FOOTER",
+  "FORM",
+  "FRAMESET",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "HEADER",
+  "HGROUP",
+  "HR",
+  "HTML",
+  "ISINDEX",
+  "LI",
+  "MAIN",
+  "MENU",
+  "NAV",
+  "NOFRAMES",
+  "NOSCRIPT",
+  "OL",
+  "OUTPUT",
+  "P",
+  "PRE",
+  "SECTION",
+  "TABLE",
+  "TBODY",
+  "TD",
+  "TFOOT",
+  "TH",
+  "THEAD",
+  "TR",
+  "UL"
+];
+function E(t) {
+  return k(t, v);
+}
+const O = [
+  "AREA",
+  "BASE",
+  "BR",
+  "COL",
+  "COMMAND",
+  "EMBED",
+  "HR",
+  "IMG",
+  "INPUT",
+  "KEYGEN",
+  "LINK",
+  "META",
+  "PARAM",
+  "SOURCE",
+  "TRACK",
+  "WBR"
+];
+function S(t) {
+  return k(t, O);
+}
+function $(t) {
+  return M(t, O);
+}
+const L = [
+  "A",
+  "TABLE",
+  "THEAD",
+  "TBODY",
+  "TFOOT",
+  "TH",
+  "TD",
+  "IFRAME",
+  "SCRIPT",
+  "AUDIO",
+  "VIDEO"
+], F = [
+  "P",
+  "BR",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "BLOCKQUOTE",
+  "UL",
+  "OL",
+  "LI",
+  "PRE",
+  "CODE",
+  "HR",
+  "A",
+  "EM",
+  "I",
+  "STRONG",
+  "B",
+  "IMG",
+  "DIV",
+  "SPAN",
+  "TABLE",
+  "THEAD",
+  "TBODY",
+  "TR",
+  "TH",
+  "TD"
+];
+function U(t) {
+  return k(t, L);
+}
+function z(t) {
+  return M(t, L);
+}
+function k(t, e) {
+  return e.indexOf(t.nodeName) >= 0;
+}
+function M(t, e) {
+  return e.some(function(n) {
+    return t.nodeType !== m.Element ? !1 : t.getElementsByTagName(n).length;
+  });
+}
+function I(t) {
+  return t ? t.replace(/(\n+\s*)+/g, `
+`) : "";
+}
+function V(t) {
+  return I(t).replace(/[\t\r\n]+/g, " ").replace(/ {2,}/g, " ").replace(/([()])/g, "\\$1").trim();
+}
+function p(t) {
+  return I(t).replace(/[\t\r\n]+/g, " ");
+}
+const f = {};
+f.paragraph = {
+  filter: "p",
+  replacement: function(t) {
+    return `
+
+` + t + `
+
+`;
+  }
+};
+f.lineBreak = {
+  filter: "br",
+  replacement: function(t, e, n) {
+    return n.br + `
+`;
+  }
+};
+f.heading = {
+  filter: ["h1", "h2", "h3", "h4", "h5", "h6"],
+  replacement: function(t, e, n) {
+    const r = Number(e.nodeName.charAt(1));
+    if (n.headingStyle === "setext" && r < 3) {
+      const i = N(r === 1 ? "=" : "-", t.length);
+      return `
+
+` + t + `
+` + i + `
+
+`;
+    } else
+      return `
+
+` + N("#", r) + " " + t + `
+
+`;
+  }
+};
+f.blockquote = {
+  filter: "blockquote",
+  replacement: function(t) {
+    return t = x(t).replace(/^/gm, "> "), `
+
+` + t + `
+
+`;
+  }
+};
+f.list = {
+  filter: ["ul", "ol"],
+  replacement: function(t, e) {
+    const n = e.parentNode;
+    return n.nodeName === "LI" && n.lastElementChild === e ? `
+` + t : `
+
+` + t + `
+
+`;
+  }
+};
+f.listItem = {
+  filter: "li",
+  replacement: function(t, e, n) {
+    let r = n.bulletListMarker + "   ";
+    const i = e.parentNode;
+    if (i.nodeName === "OL") {
+      const a = i.getAttribute("start"), o = Array.prototype.indexOf.call(i.children, e);
+      r = (a ? Number(a) + o : o + 1) + ".  ";
+    }
+    const l = /\n$/.test(t);
+    return t = x(t) + (l ? `
+` : ""), t = t.replace(/\n/gm, `
+` + " ".repeat(r.length)), r + t + (e.nextSibling ? `
+` : "");
+  }
+};
+f.indentedCodeBlock = {
+  filter: function(t, e) {
+    return !!(e && e.codeBlockStyle === "indented" && t.nodeName === "PRE" && t.firstChild && t.firstChild.nodeName === "CODE");
+  },
+  replacement: function(t, e) {
+    return !e || !e.firstChild ? "" : `
+
+    ` + e.firstChild.textContent.replace(/\n/g, `
+    `) + `
+
+`;
+  }
+};
+f.fencedCodeBlock = {
+  filter: function(t, e) {
+    return !!(e && e.codeBlockStyle === "fenced" && t.nodeName === "PRE" && t.firstChild && t.firstChild.nodeName === "CODE");
+  },
+  replacement: function(t, e, n) {
+    if (!e.firstChild)
+      return "";
+    const r = e.firstChild, l = ((r.getAttribute("class") || "").match(/language-(\S+)/) || [null, ""])[1], a = r.textContent || "", o = n.fence?.charAt(0) || "`";
+    let s = 3;
+    const u = new RegExp("^" + o + "{3,}", "gm");
+    let c;
+    for (; c = u.exec(a); )
+      c[0].length >= s && (s = c[0].length + 1);
+    const d = N(o, s);
+    return `
+
+` + d + l + `
+` + a.replace(/\n$/, "") + `
+` + d + `
+
+`;
+  }
+};
+f.horizontalRule = {
+  filter: "hr",
+  replacement: function(t, e, n) {
+    return `
+
+` + n.hr + `
+
+`;
+  }
+};
+f.inlineLink = {
+  filter: function(t, e) {
+    return !!(e?.linkStyle === "inlined" && t.nodeName === "A" && t.getAttribute("href"));
+  },
+  replacement: function(t, e) {
+    const n = V(t);
+    let r = e.getAttribute("href")?.replace(/([()])/g, "\\$1"), i;
+    const l = e.getAttribute("title");
+    return l ? i = ' "' + p(l).replace(/"/g, '\\"') + '"' : i = "", "[" + n + "](" + r + i + ")";
+  }
+};
+const R = {
+  filter: function(t, e) {
+    return !!(e && e.linkStyle === "referenced" && t.nodeName === "A" && t.getAttribute("href"));
+  },
+  replacement: function(t, e, n) {
+    const r = R, i = e.getAttribute("href");
+    let l;
+    const a = e.getAttribute("title");
+    a ? l = ' "' + p(a) + '"' : l = "";
+    const o = i + l;
+    let s, u;
+    switch (n.linkReferenceStyle) {
+      case "collapsed":
+        s = "[" + t + "][]", u = "[" + t + "]: " + o;
+        break;
+      case "shortcut":
+        s = "[" + t + "]", u = "[" + t + "]: " + o;
+        break;
+      default: {
+        let c;
+        const d = r.urlReferenceIdMap.get(o);
+        n.linkReferenceDeduplication === "full" && d ? (c = d, u = "[" + c + "]: " + i + l) : (c = r.references.length + 1, r.urlReferenceIdMap.set(o, c), u = "[" + c + "]: " + i + l, r.references.push(u)), s = "[" + t + "][" + c + "]";
+        break;
+      }
+    }
+    return n.linkReferenceStyle !== "full" && (n.linkReferenceDeduplication === "full" ? r.urlReferenceIdMap.has(o) || (r.urlReferenceIdMap.set(o, 1), r.references.push(u)) : r.references.push(u)), s;
+  },
+  references: [],
+  urlReferenceIdMap: /* @__PURE__ */ new Map(),
+  append: () => {
+    const t = R;
+    let e = "";
+    return t.references && t.references.length && (e = `
+
+` + t.references.join(`
+`) + `
+
+`, t.references = [], t.urlReferenceIdMap = /* @__PURE__ */ new Map()), e;
+  }
+};
+f.referenceLink = R;
+f.emphasis = {
+  filter: ["em", "i"],
+  replacement: (t, e, n) => (t = t.trim(), t ? n.emDelimiter + t + n.emDelimiter : "")
+};
+f.strong = {
+  filter: ["strong", "b"],
+  replacement: (t, e, n) => (t = t.trim(), t ? n.strongDelimiter + t + n.strongDelimiter : "")
+};
+f.code = {
+  filter: (t) => {
+    const e = t.previousSibling || t.nextSibling, r = t.parentNode.nodeName === "PRE" && !e;
+    return t.nodeName === "CODE" && !r;
+  },
+  replacement: (t) => {
+    const e = t.replace(/\r?\n|\r/g, " "), n = /^`|^ .*?[^ ].* $|`$/.test(e) ? " " : "";
+    let r = "`";
+    const i = e.match(/`+/gm) || [];
+    for (; i.includes(r); ) r = r + "`";
+    return r + n + e + n + r;
+  }
+};
+f.image = {
+  filter: "img",
+  replacement: function(t, e) {
+    const n = e.getAttribute("alt"), r = n ? p(n) : "", i = e.getAttribute("src") || "", l = e.getAttribute("title"), a = l ? p(l) : "", o = a ? ' "' + a + '"' : "";
+    return i ? "![" + r + "](" + i + o + ")" : "";
+  }
+};
+class W {
+  options;
+  _keep;
+  _remove;
+  blankRule;
+  keepReplacement;
+  markdownIncludingHtmlReplacement;
+  defaultRule;
+  array;
+  constructor(e) {
+    this.options = e, this._keep = [], this._remove = [], this.blankRule = {
+      replacement: e.blankReplacement
+    }, this.keepReplacement = e.keepReplacement, this.markdownIncludingHtmlReplacement = e.markdownIncludingHtmlReplacement, this.defaultRule = {
+      replacement: e.defaultReplacement
+    }, this.array = [];
+    for (const n in e.rules)
+      this.array.push(e.rules[n]);
+  }
+  add(e, n) {
+    this.array.unshift(n);
+  }
+  keep(e) {
+    this._keep.unshift({
+      filter: e,
+      replacement: this.keepReplacement
+    });
+  }
+  remove(e) {
+    this._remove.unshift({
+      filter: e,
+      replacement: function() {
+        return "";
+      }
+    });
+  }
+  forNode(e) {
+    if (e.isBlank)
+      return this.blankRule;
+    if (this.options.htmlRetentionMode === "preserveAll" && this.isUnsupportedElement(e))
+      return {
+        replacement: this.keepReplacement
+      };
+    if (this.options.htmlRetentionMode === "markdownIncludingHtml" && this.isUnsupportedElement(e))
+      return {
+        replacement: this.markdownIncludingHtmlReplacement
+      };
+    let n;
+    return (n = h(this.array, e, this.options)) || (n = h(this._keep, e, this.options)) || (n = h(this._remove, e, this.options)) ? n : this.defaultRule;
+  }
+  /// Check if an element is unsupported for Markdown conversion.
+  isUnsupportedElement(e) {
+    const n = e.nodeName;
+    if (n === "PRE" && e.firstChild && e.firstChild.nodeName === "CODE") {
+      const r = e.firstChild;
+      if (r.attributes && r.attributes.length > 0) {
+        for (let i = 0; i < r.attributes.length; i++)
+          if (r.attributes[i].name.toLowerCase() !== "class")
+            return !0;
+      }
+    }
+    if (e.attributes && e.attributes.length > 0)
+      switch (n) {
+        case "IMG":
+          for (let i = 0; i < e.attributes.length; i++) {
+            const l = e.attributes[i].name.toLowerCase();
+            if (l !== "src" && l !== "alt" && l !== "title")
+              return !0;
+          }
+          return !1;
+        case "A":
+          for (let i = 0; i < e.attributes.length; i++) {
+            const l = e.attributes[i].name.toLowerCase();
+            if (l !== "href" && l !== "title")
+              return !0;
+          }
+          return !1;
+        case "CODE":
+          const r = e.parentNode;
+          if (r && r.nodeName === "PRE") {
+            for (let i = 0; i < e.attributes.length; i++)
+              if (e.attributes[i].name.toLowerCase() !== "class")
+                return !0;
+            return !1;
+          }
+        default:
+          return !0;
+      }
+    return F.indexOf(n) === -1;
+  }
+  forEach(e) {
+    for (let n = 0; n < this.array.length; n++)
+      e(this.array[n], n);
+  }
+}
+function h(t, e, n) {
+  for (let r = 0; r < t.length; r++) {
+    const i = t[r];
+    if (G(i, e, n)) return i;
+  }
+}
+function G(t, e, n) {
+  const r = t.filter;
+  if (typeof r == "string") {
+    if (r === e.nodeName.toLowerCase())
+      return !0;
+  } else if (Array.isArray(r)) {
+    if (r.indexOf(e.nodeName.toLowerCase()) > -1)
+      return !0;
+  } else if (typeof r == "function") {
+    if (r(e, n))
+      return !0;
+  } else
+    throw new TypeError("`filter` needs to be a string, array, or function");
+  return !1;
+}
+function K(t) {
+  const e = t.element, n = t.isBlock, r = t.isVoid, i = t.isPre || function(u) {
+    return u.nodeName === "PRE";
+  };
+  if (!e.firstChild || i(e)) return;
+  let l = null, a = !1, o = null, s = y(o, e, i);
+  for (; s !== e; ) {
+    if (s.nodeType === m.Text || s.nodeType === m.CDATASection) {
+      const c = s;
+      let d = c.data.replace(/[ \r\n\t]+/g, " ");
+      if ((!l || / $/.test(l.data)) && !a && d[0] === " " && (d = d.substr(1)), !d) {
+        s = g(s);
+        continue;
+      }
+      c.data = d, l = c;
+    } else if (s.nodeType === m.Element)
+      n(s) || s.nodeName === "BR" ? (l && (l.data = l.data.replace(/ $/, "")), l = null, a = !1) : r(s) || i(s) ? (l = null, a = !0) : l && (a = !1);
+    else {
+      s = g(s);
+      continue;
+    }
+    const u = y(o, s, i);
+    o = s, s = u;
+  }
+  l && (l.data = l.data.replace(/ $/, ""), l.data || g(l));
+}
+function g(t) {
+  const e = t.nextSibling ?? t.parentNode;
+  return t.parentNode && t.parentNode.removeChild(t), e;
+}
+function y(t, e, n) {
+  return t && t.parentNode === e || n(e) ? e.nextSibling ?? e.parentNode : e.firstChild ?? e.nextSibling ?? e.parentNode;
+}
+const T = typeof window < "u" ? window : typeof globalThis < "u" ? globalThis : {};
+function j() {
+  const t = typeof T.DOMParser < "u" ? T.DOMParser : void 0;
+  let e = !1;
+  if (!t) return !1;
+  try {
+    new t().parseFromString("", "text/html") && (e = !0);
+  } catch {
+  }
+  return e;
+}
+class C {
+  // This will be assigned per environment below
+  parseFromString(e, n) {
+    throw new Error("Not implemented");
+  }
+}
+function Y() {
+  if (typeof window < "u" && typeof document < "u" && (typeof process > "u" || process.browser), typeof window < "u") {
+    class t extends C {
+      parseFromString(n, r) {
+        const i = document.implementation.createHTMLDocument("");
+        return i.open(), i.write(n), i.close(), i;
+      }
+    }
+    return new t();
+  } else {
+    const t = require("@mixmark-io/domino");
+    class e extends C {
+      parseFromString(r, i) {
+        return t.createDocument(r);
+      }
+    }
+    return new e();
+  }
+}
+const q = () => j() ? new T.DOMParser() : Y();
+function Q(t, { preformattedCode: e }) {
+  let n;
+  return typeof t == "string" ? n = J().parseFromString(
+    // DOM parsers arrange elements in the <head> and <body>.
+    // Wrapping in a custom element ensures elements are reliably arranged in
+    // a single element.
+    '<x-turnish id="turnish-root">' + t + "</x-turnish>",
+    "text/html"
+  ).getElementById("turnish-root") : n = t.cloneNode(!0), K({
+    element: n,
+    isBlock: E,
+    isVoid: S,
+    isPre: e ? Z : void 0
+  }), n;
+}
+let X;
+function J() {
+  return X ??= q();
+}
+function Z(t) {
+  return t.nodeName === "PRE" || t.nodeName === "CODE";
+}
+const ee = [
+  [/\\/g, "\\\\"],
+  [/\*/g, "\\*"],
+  [/_/g, "\\_"],
+  [/^-/g, "\\-"],
+  [/^\+ /g, "\\+ "],
+  [/^(=+)/g, "\\$1"],
+  [/^(#{1,6}) /g, "\\$1 "],
+  [/`/g, "\\`"],
+  [/^~~~/g, "\\~~~"],
+  [/\[/g, "\\["],
+  [/\]/g, "\\]"],
+  [/<([^>]*)>/g, "\\<$1\\>"],
+  [/^>/g, "\\>"],
+  [/^(\d+)\. /g, "$1\\. "]
+], te = {
+  rules: f,
+  headingStyle: "atx",
+  hr: "---",
+  bulletListMarker: "-",
+  codeBlockStyle: "fenced",
+  fence: "```",
+  emDelimiter: "*",
+  strongDelimiter: "**",
+  linkStyle: "inlined",
+  linkReferenceStyle: "full",
+  linkReferenceDeduplication: "full",
+  br: "  ",
+  preformattedCode: !1,
+  htmlRetentionMode: "standard",
+  blankReplacement: (t, e) => e.isBlock ? `
+
+` : "",
+  keepReplacement: (t, e) => e.isBlock ? `
+
+` + e.outerHTML + `
+
+` : e.outerHTML,
+  markdownIncludingHtmlReplacement: (t, e) => {
+    const n = e.nodeName.toLowerCase();
+    let r = "";
+    if (e.attributes && e.attributes.length > 0) {
+      const s = [];
+      for (let u = 0; u < e.attributes.length; u++) {
+        const c = e.attributes[u];
+        s.push(`${c.name}="${c.value}"`);
+      }
+      r = " " + s.join(" ");
+    }
+    r += ' markdown="1"';
+    const i = `<${n}${r}>`, l = `</${n}>`, a = t.trim(), o = i + `
+` + a + `
+` + l;
+    return e.isBlock ? `
+
+` + o + `
+
+` : o;
+  },
+  defaultReplacement: function(t, e) {
+    return e.isBlock ? `
+
+` + t + `
+
+` : t;
+  }
+};
+class re {
+  options;
+  rules;
+  constructor(e) {
+    this.options = Object.assign({}, te, e), this.rules = new W(this.options);
+  }
+  /**
+   * The entry point for converting a string or DOM node to Markdown
+   * @public
+   * @param {InputType} input The string or DOM node to convert
+   * @returns A Markdown representation of the input
+   * @type string
+   */
+  render(e) {
+    if (!ne(e))
+      throw new TypeError(
+        e + " is not a string, or an element/document/fragment node."
+      );
+    if (e === "")
+      return "";
+    const n = this.process(Q(e, this.options));
+    return this.postProcess(n);
+  }
+  /**
+   * Add one or more plugins
+   * @public
+   * @param {Plugin|Plugin[]} plugin The plugin or array of plugins to add
+   * @returns The Turnish instance for chaining
+   * @type Object
+   */
+  use(e) {
+    if (Array.isArray(e))
+      for (let n = 0; n < e.length; n++) this.use(e[n]);
+    else if (typeof e == "function")
+      e(this);
+    else
+      throw new TypeError("plugin must be a Function or an Array of Functions");
+    return this;
+  }
+  /**
+   * Adds a rule
+   * @public
+   * @param {string} key The unique key of the rule
+   * @param {Object} rule The rule
+   * @returns The Turnish instance for chaining
+   * @type Object
+   */
+  addRule(e, n) {
+    return this.rules.add(e, n), this;
+  }
+  /**
+   * Keep a node (as HTML) that matches the filter
+   * @public
+   * @param {RuleFilter} filter The unique key of the rule
+   * @returns The Turnish instance for chaining
+   * @type Object
+   */
+  keep(e) {
+    return this.rules.keep(e), this;
+  }
+  /**
+   * Remove a node that matches the filter
+   * @public
+   * @param {string|Array|Function} filter The unique key of the rule
+   * @returns The Turnish instance for chaining
+   * @type Object
+   */
+  remove(e) {
+    return this.rules.remove(e), this;
+  }
+  /**
+   * Escapes Markdown syntax
+   * @public
+   * @param {string} string The string to escape
+   * @returns A string with Markdown syntax escaped
+   * @type string
+   */
+  escape(e) {
+    return ee.reduce(function(n, r) {
+      return n.replace(r[0], r[1]);
+    }, e);
+  }
+  /**
+   * Reduces a DOM node down to its Markdown string equivalent
+   * @private
+   * @param {HTMLElement} parentNode The node to convert
+   * @returns A Markdown representation of the node
+   * @type string
+   */
+  process(e) {
+    return Array.from(e.childNodes).reduce((n, r) => {
+      const i = B(r, this.options);
+      let l = "";
+      if (i.nodeType === m.Text) {
+        const a = i.nodeValue ?? "";
+        l = i.isCode ? a : this.escape(a);
+      } else i.nodeType === m.Element && (l = this.replacementForNode(i));
+      return b(n, l);
+    }, "");
+  }
+  /**
+   * Appends strings as each rule requires and trims the output
+   * @private
+   * @param {string} output The conversion output
+   * @returns A trimmed version of the ouput
+   * @type string
+   */
+  postProcess(e) {
+    for (const n of this.rules.array)
+      n.append && (e = b(e, n.append(this.options)));
+    return e.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
+  }
+  /**
+   * Converts an element node to its Markdown equivalent
+   * @private
+   * @param {ExtendedNode} node The node to convert
+   * @returns A Markdown representation of the node
+   * @type string
+   */
+  replacementForNode(e) {
+    const n = this.rules.forNode(e);
+    let r = this.process(e);
+    const i = e.flankingWhitespace;
+    return (i.leading || i.trailing) && (r = r.trim()), i.leading + n.replacement(r, e, this.options) + i.trailing;
+  }
+}
+function b(t, e) {
+  const n = w(t), r = D(e), i = Math.max(t.length - n.length, e.length - r.length), l = `
+
+`.substring(0, i);
+  return n + l + r;
+}
+function ne(t) {
+  return t != null && (typeof t == "string" || t.nodeType && (t.nodeType === 1 || t.nodeType === 9 || t.nodeType === 11));
+}
+export {
+  re as default
+};
+//# sourceMappingURL=index.mjs.map