@mobilon-dev/chotto 0.3.30 → 0.3.32

package/dist/node_modules/markdown-it/lib/rules_inline/autolink.js

@@ -0,0 +1,46 @@
+const f = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/, k = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
+function s(n, a) {
+  let u = n.pos;
+  if (n.src.charCodeAt(u) !== 60)
+    return !1;
+  const e = n.pos, c = n.posMax;
+  for (; ; ) {
+    if (++u >= c) return !1;
+    const r = n.src.charCodeAt(u);
+    if (r === 60) return !1;
+    if (r === 62) break;
+  }
+  const o = n.src.slice(e + 1, u);
+  if (k.test(o)) {
+    const r = n.md.normalizeLink(o);
+    if (!n.md.validateLink(r))
+      return !1;
+    if (!a) {
+      const i = n.push("link_open", "a", 1);
+      i.attrs = [["href", r]], i.markup = "autolink", i.info = "auto";
+      const t = n.push("text", "", 0);
+      t.content = n.md.normalizeLinkText(o);
+      const l = n.push("link_close", "a", -1);
+      l.markup = "autolink", l.info = "auto";
+    }
+    return n.pos += o.length + 2, !0;
+  }
+  if (f.test(o)) {
+    const r = n.md.normalizeLink("mailto:" + o);
+    if (!n.md.validateLink(r))
+      return !1;
+    if (!a) {
+      const i = n.push("link_open", "a", 1);
+      i.attrs = [["href", r]], i.markup = "autolink", i.info = "auto";
+      const t = n.push("text", "", 0);
+      t.content = n.md.normalizeLinkText(o);
+      const l = n.push("link_close", "a", -1);
+      l.markup = "autolink", l.info = "auto";
+    }
+    return n.pos += o.length + 2, !0;
+  }
+  return !1;
+}
+export {
+  s as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/backticks.js

@@ -0,0 +1,31 @@
+function s(c, h) {
+  let n = c.pos;
+  if (c.src.charCodeAt(n) !== 96)
+    return !1;
+  const p = n;
+  n++;
+  const k = c.posMax;
+  for (; n < k && c.src.charCodeAt(n) === 96; )
+    n++;
+  const o = c.src.slice(p, n), i = o.length;
+  if (c.backticksScanned && (c.backticks[i] || 0) <= p)
+    return h || (c.pending += o), c.pos += i, !0;
+  let r = n, e;
+  for (; (e = c.src.indexOf("`", r)) !== -1; ) {
+    for (r = e + 1; r < k && c.src.charCodeAt(r) === 96; )
+      r++;
+    const l = r - e;
+    if (l === i) {
+      if (!h) {
+        const d = c.push("code_inline", "code", 0);
+        d.markup = o, d.content = c.src.slice(n, e).replace(/\n/g, " ").replace(/^ (.+) $/, "$1");
+      }
+      return c.pos = r, !0;
+    }
+    c.backticks[l] = e;
+  }
+  return c.backticksScanned = !0, h || (c.pending += o), c.pos += i, !0;
+}
+export {
+  s as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/balance_pairs.js

@@ -0,0 +1,34 @@
+function k(o) {
+  const r = {}, c = o.length;
+  if (!c) return;
+  let n = 0, f = -2;
+  const a = [];
+  for (let s = 0; s < c; s++) {
+    const e = o[s];
+    if (a.push(0), (o[n].marker !== e.marker || f !== e.token - 1) && (n = s), f = e.token, e.length = e.length || 0, !e.close) continue;
+    r.hasOwnProperty(e.marker) || (r[e.marker] = [-1, -1, -1, -1, -1, -1]);
+    const h = r[e.marker][(e.open ? 3 : 0) + e.length % 3];
+    let t = n - a[n] - 1, i = t;
+    for (; t > h; t -= a[t] + 1) {
+      const l = o[t];
+      if (l.marker === e.marker && l.open && l.end < 0) {
+        let p = !1;
+        if ((l.close || e.open) && (l.length + e.length) % 3 === 0 && (l.length % 3 !== 0 || e.length % 3 !== 0) && (p = !0), !p) {
+          const m = t > 0 && !o[t - 1].open ? a[t - 1] + 1 : 0;
+          a[s] = s - t + m, a[t] = m, e.open = !1, l.end = s, l.close = !1, i = -1, f = -2;
+          break;
+        }
+      }
+    }
+    i !== -1 && (r[e.marker][(e.open ? 3 : 0) + (e.length || 0) % 3] = i);
+  }
+}
+function d(o) {
+  const r = o.tokens_meta, c = o.tokens_meta.length;
+  k(o.delimiters);
+  for (let n = 0; n < c; n++)
+    r[n] && r[n].delimiters && k(r[n].delimiters);
+}
+export {
+  d as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/emphasis.js

@@ -0,0 +1,57 @@
+function i(o, t) {
+  const c = o.pos, n = o.src.charCodeAt(c);
+  if (t || n !== 95 && n !== 42)
+    return !1;
+  const e = o.scanDelims(o.pos, n === 42);
+  for (let k = 0; k < e.length; k++) {
+    const s = o.push("text", "", 0);
+    s.content = String.fromCharCode(n), o.delimiters.push({
+      // Char code of the starting marker (number).
+      //
+      marker: n,
+      // Total length of these series of delimiters.
+      //
+      length: e.length,
+      // A position of the token this delimiter corresponds to.
+      //
+      token: o.tokens.length - 1,
+      // If this delimiter is matched as a valid opener, `end` will be
+      // equal to its position, otherwise it's `-1`.
+      //
+      end: -1,
+      // Boolean flags that determine if this delimiter could open or close
+      // an emphasis.
+      //
+      open: e.can_open,
+      close: e.can_close
+    });
+  }
+  return o.pos += e.length, !0;
+}
+function g(o, t) {
+  const c = t.length;
+  for (let n = c - 1; n >= 0; n--) {
+    const e = t[n];
+    if (e.marker !== 95 && e.marker !== 42 || e.end === -1)
+      continue;
+    const k = t[e.end], s = n > 0 && t[n - 1].end === e.end + 1 && // check that first two markers match and adjacent
+    t[n - 1].marker === e.marker && t[n - 1].token === e.token - 1 && // check that last two markers are adjacent (we can safely assume they match)
+    t[e.end + 1].token === k.token + 1, r = String.fromCharCode(e.marker), m = o.tokens[e.token];
+    m.type = s ? "strong_open" : "em_open", m.tag = s ? "strong" : "em", m.nesting = 1, m.markup = s ? r + r : r, m.content = "";
+    const p = o.tokens[k.token];
+    p.type = s ? "strong_close" : "em_close", p.tag = s ? "strong" : "em", p.nesting = -1, p.markup = s ? r + r : r, p.content = "", s && (o.tokens[t[n - 1].token].content = "", o.tokens[t[e.end + 1].token].content = "", n--);
+  }
+}
+function a(o) {
+  const t = o.tokens_meta, c = o.tokens_meta.length;
+  g(o, o.delimiters);
+  for (let n = 0; n < c; n++)
+    t[n] && t[n].delimiters && g(o, t[n].delimiters);
+}
+const f = {
+  tokenize: i,
+  postProcess: a
+};
+export {
+  f as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/entity.js

@@ -0,0 +1,33 @@
+import { fromCodePoint as i, isValidEntityCode as f } from "../common/utils.js";
+import { decodeHTML as p } from "../../../entities/lib/esm/decode.js";
+const a = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i, u = /^&([a-z][a-z0-9]{1,31});/i;
+function m(c, r) {
+  const t = c.pos, s = c.posMax;
+  if (c.src.charCodeAt(t) !== 38 || t + 1 >= s) return !1;
+  if (c.src.charCodeAt(t + 1) === 35) {
+    const o = c.src.slice(t).match(a);
+    if (o) {
+      if (!r) {
+        const e = o[1][0].toLowerCase() === "x" ? parseInt(o[1].slice(1), 16) : parseInt(o[1], 10), n = c.push("text_special", "", 0);
+        n.content = f(e) ? i(e) : i(65533), n.markup = o[0], n.info = "entity";
+      }
+      return c.pos += o[0].length, !0;
+    }
+  } else {
+    const o = c.src.slice(t).match(u);
+    if (o) {
+      const e = p(o[0]);
+      if (e !== o[0]) {
+        if (!r) {
+          const n = c.push("text_special", "", 0);
+          n.content = e, n.markup = o[0], n.info = "entity";
+        }
+        return c.pos += o[0].length, !0;
+      }
+    }
+  }
+  return !1;
+}
+export {
+  m as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/escape.js

@@ -0,0 +1,32 @@
+import { isSpace as h } from "../common/utils.js";
+const n = [];
+for (let r = 0; r < 256; r++)
+  n.push(0);
+"\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function(r) {
+  n[r.charCodeAt(0)] = 1;
+});
+function t(r, p) {
+  let c = r.pos;
+  const f = r.posMax;
+  if (r.src.charCodeAt(c) !== 92 || (c++, c >= f)) return !1;
+  let o = r.src.charCodeAt(c);
+  if (o === 10) {
+    for (p || r.push("hardbreak", "br", 0), c++; c < f && (o = r.src.charCodeAt(c), !!h(o)); )
+      c++;
+    return r.pos = c, !0;
+  }
+  let i = r.src[c];
+  if (o >= 55296 && o <= 56319 && c + 1 < f) {
+    const e = r.src.charCodeAt(c + 1);
+    e >= 56320 && e <= 57343 && (i += r.src[c + 1], c++);
+  }
+  const s = "\\" + i;
+  if (!p) {
+    const e = r.push("text_special", "", 0);
+    o < 256 && n[o] !== 0 ? e.content = i : e.content = s, e.markup = s, e.info = "escape";
+  }
+  return r.pos = c + 1, !0;
+}
+export {
+  t as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/fragments_join.js

@@ -0,0 +1,10 @@
+function f(l) {
+  let t, n, o = 0;
+  const e = l.tokens, s = l.tokens.length;
+  for (t = n = 0; t < s; t++)
+    e[t].nesting < 0 && o--, e[t].level = o, e[t].nesting > 0 && o++, e[t].type === "text" && t + 1 < s && e[t + 1].type === "text" ? e[t + 1].content = e[t].content + e[t + 1].content : (t !== n && (e[n] = e[t]), n++);
+  t !== n && (e.length = n);
+}
+export {
+  f as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/html_inline.js

@@ -0,0 +1,32 @@
+import { HTML_TAG_RE as s } from "../common/html_re.js";
+function l(n) {
+  return /^<a[>\s]/i.test(n);
+}
+function f(n) {
+  return /^<\/a\s*>/i.test(n);
+}
+function u(n) {
+  const i = n | 32;
+  return i >= 97 && i <= 122;
+}
+function x(n, i) {
+  if (!n.md.options.html)
+    return !1;
+  const c = n.posMax, e = n.pos;
+  if (n.src.charCodeAt(e) !== 60 || e + 2 >= c)
+    return !1;
+  const o = n.src.charCodeAt(e + 1);
+  if (o !== 33 && o !== 63 && o !== 47 && !u(o))
+    return !1;
+  const r = n.src.slice(e).match(s);
+  if (!r)
+    return !1;
+  if (!i) {
+    const t = n.push("html_inline", "", 0);
+    t.content = r[0], l(t.content) && n.linkLevel++, f(t.content) && n.linkLevel--;
+  }
+  return n.pos += r[0].length, !0;
+}
+export {
+  x as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/image.js

@@ -0,0 +1,48 @@
+import { isSpace as u, normalizeReference as C } from "../common/utils.js";
+function v(r, b) {
+  let o, h, p, e, d, n, c, f, s = "";
+  const x = r.pos, i = r.posMax;
+  if (r.src.charCodeAt(r.pos) !== 33 || r.src.charCodeAt(r.pos + 1) !== 91)
+    return !1;
+  const k = r.pos + 2, l = r.md.helpers.parseLinkLabel(r, r.pos + 1, !1);
+  if (l < 0)
+    return !1;
+  if (e = l + 1, e < i && r.src.charCodeAt(e) === 40) {
+    for (e++; e < i && (o = r.src.charCodeAt(e), !(!u(o) && o !== 10)); e++)
+      ;
+    if (e >= i)
+      return !1;
+    for (f = e, n = r.md.helpers.parseLinkDestination(r.src, e, r.posMax), n.ok && (s = r.md.normalizeLink(n.str), r.md.validateLink(s) ? e = n.pos : s = ""), f = e; e < i && (o = r.src.charCodeAt(e), !(!u(o) && o !== 10)); e++)
+      ;
+    if (n = r.md.helpers.parseLinkTitle(r.src, e, r.posMax), e < i && f !== e && n.ok)
+      for (c = n.str, e = n.pos; e < i && (o = r.src.charCodeAt(e), !(!u(o) && o !== 10)); e++)
+        ;
+    else
+      c = "";
+    if (e >= i || r.src.charCodeAt(e) !== 41)
+      return r.pos = x, !1;
+    e++;
+  } else {
+    if (typeof r.env.references > "u")
+      return !1;
+    if (e < i && r.src.charCodeAt(e) === 91 ? (f = e + 1, e = r.md.helpers.parseLinkLabel(r, e), e >= 0 ? p = r.src.slice(f, e++) : e = l + 1) : e = l + 1, p || (p = r.src.slice(k, l)), d = r.env.references[C(p)], !d)
+      return r.pos = x, !1;
+    s = d.href, c = d.title;
+  }
+  if (!b) {
+    h = r.src.slice(k, l);
+    const a = [];
+    r.md.inline.parse(
+      h,
+      r.md,
+      r.env,
+      a
+    );
+    const m = r.push("image", "img", 0), A = [["src", s], ["alt", ""]];
+    m.attrs = A, m.children = a, m.content = h, c && A.push(["title", c]);
+  }
+  return r.pos = e, r.posMax = i, !0;
+}
+export {
+  v as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/link.js

@@ -0,0 +1,40 @@
+import { isSpace as h, normalizeReference as b } from "../common/utils.js";
+function C(r, m) {
+  let o, p, l, s, f = "", d = "", c = r.pos, k = !0;
+  if (r.src.charCodeAt(r.pos) !== 91)
+    return !1;
+  const A = r.pos, i = r.posMax, u = r.pos + 1, n = r.md.helpers.parseLinkLabel(r, r.pos, !0);
+  if (n < 0)
+    return !1;
+  let e = n + 1;
+  if (e < i && r.src.charCodeAt(e) === 40) {
+    for (k = !1, e++; e < i && (o = r.src.charCodeAt(e), !(!h(o) && o !== 10)); e++)
+      ;
+    if (e >= i)
+      return !1;
+    if (c = e, l = r.md.helpers.parseLinkDestination(r.src, e, r.posMax), l.ok) {
+      for (f = r.md.normalizeLink(l.str), r.md.validateLink(f) ? e = l.pos : f = "", c = e; e < i && (o = r.src.charCodeAt(e), !(!h(o) && o !== 10)); e++)
+        ;
+      if (l = r.md.helpers.parseLinkTitle(r.src, e, r.posMax), e < i && c !== e && l.ok)
+        for (d = l.str, e = l.pos; e < i && (o = r.src.charCodeAt(e), !(!h(o) && o !== 10)); e++)
+          ;
+    }
+    (e >= i || r.src.charCodeAt(e) !== 41) && (k = !0), e++;
+  }
+  if (k) {
+    if (typeof r.env.references > "u")
+      return !1;
+    if (e < i && r.src.charCodeAt(e) === 91 ? (c = e + 1, e = r.md.helpers.parseLinkLabel(r, e), e >= 0 ? p = r.src.slice(c, e++) : e = n + 1) : e = n + 1, p || (p = r.src.slice(u, n)), s = r.env.references[b(p)], !s)
+      return r.pos = A, !1;
+    f = s.href, d = s.title;
+  }
+  if (!m) {
+    r.pos = u, r.posMax = n;
+    const L = r.push("link_open", "a", 1), x = [["href", f]];
+    L.attrs = x, d && x.push(["title", d]), r.linkLevel++, r.md.inline.tokenize(r), r.linkLevel--, r.push("link_close", "a", -1);
+  }
+  return r.pos = e, r.posMax = i, !0;
+}
+export {
+  C as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/linkify.js

@@ -0,0 +1,28 @@
+const k = /(?:^|[^a-z0-9.+-])([a-z][a-z0-9.+-]*)$/i;
+function p(n, t) {
+  if (!n.md.options.linkify || n.linkLevel > 0) return !1;
+  const i = n.pos, s = n.posMax;
+  if (i + 3 > s || n.src.charCodeAt(i) !== 58 || n.src.charCodeAt(i + 1) !== 47 || n.src.charCodeAt(i + 2) !== 47) return !1;
+  const o = n.pending.match(k);
+  if (!o) return !1;
+  const l = o[1], f = n.md.linkify.matchAtStart(n.src.slice(i - l.length));
+  if (!f) return !1;
+  let r = f.url;
+  if (r.length <= l.length) return !1;
+  r = r.replace(/\*+$/, "");
+  const c = n.md.normalizeLink(r);
+  if (!n.md.validateLink(c)) return !1;
+  if (!t) {
+    n.pending = n.pending.slice(0, -l.length);
+    const e = n.push("link_open", "a", 1);
+    e.attrs = [["href", c]], e.markup = "linkify", e.info = "auto";
+    const a = n.push("text", "", 0);
+    a.content = n.md.normalizeLinkText(r);
+    const u = n.push("link_close", "a", -1);
+    u.markup = "linkify", u.info = "auto";
+  }
+  return n.pos += r.length - l.length, !0;
+}
+export {
+  p as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/newline.js

@@ -0,0 +1,23 @@
+import { isSpace as d } from "../common/utils.js";
+function h(n, p) {
+  let r = n.pos;
+  if (n.src.charCodeAt(r) !== 10)
+    return !1;
+  const e = n.pending.length - 1, o = n.posMax;
+  if (!p)
+    if (e >= 0 && n.pending.charCodeAt(e) === 32)
+      if (e >= 1 && n.pending.charCodeAt(e - 1) === 32) {
+        let i = e - 1;
+        for (; i >= 1 && n.pending.charCodeAt(i - 1) === 32; ) i--;
+        n.pending = n.pending.slice(0, i), n.push("hardbreak", "br", 0);
+      } else
+        n.pending = n.pending.slice(0, -1), n.push("softbreak", "br", 0);
+    else
+      n.push("softbreak", "br", 0);
+  for (r++; r < o && d(n.src.charCodeAt(r)); )
+    r++;
+  return n.pos = r, !0;
+}
+export {
+  h as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/state_inline.js

@@ -0,0 +1,27 @@
+import p from "../token.js";
+import { isWhiteSpace as k, isMdAsciiPunct as f, isPunctChar as g } from "../common/utils.js";
+function o(t, i, e, s) {
+  this.src = t, this.env = e, this.md = i, this.tokens = s, this.tokens_meta = Array(s.length), this.pos = 0, this.posMax = this.src.length, this.level = 0, this.pending = "", this.pendingLevel = 0, this.cache = {}, this.delimiters = [], this._prev_delimiters = [], this.backticks = {}, this.backticksScanned = !1, this.linkLevel = 0;
+}
+o.prototype.pushPending = function() {
+  const t = new p("text", "", 0);
+  return t.content = this.pending, t.level = this.pendingLevel, this.tokens.push(t), this.pending = "", t;
+};
+o.prototype.push = function(t, i, e) {
+  this.pending && this.pushPending();
+  const s = new p(t, i, e);
+  let n = null;
+  return e < 0 && (this.level--, this.delimiters = this._prev_delimiters.pop()), s.level = this.level, e > 0 && (this.level++, this._prev_delimiters.push(this.delimiters), this.delimiters = [], n = { delimiters: this.delimiters }), this.pendingLevel = this.level, this.tokens.push(s), this.tokens_meta.push(n), s;
+};
+o.prototype.scanDelims = function(t, i) {
+  const e = this.posMax, s = this.src.charCodeAt(t), n = t > 0 ? this.src.charCodeAt(t - 1) : 32;
+  let h = t;
+  for (; h < e && this.src.charCodeAt(h) === s; )
+    h++;
+  const v = h - t, c = h < e ? this.src.charCodeAt(h) : 32, r = f(n) || g(String.fromCharCode(n)), l = f(c) || g(String.fromCharCode(c)), a = k(n), d = k(c), m = !d && (!l || a || r), u = !a && (!r || d || l);
+  return { can_open: m && (i || !u || r), can_close: u && (i || !m || l), length: v };
+};
+o.prototype.Token = p;
+export {
+  o as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/strikethrough.js

@@ -0,0 +1,54 @@
+function h(n, r) {
+  const e = n.pos, t = n.src.charCodeAt(e);
+  if (r || t !== 126)
+    return !1;
+  const i = n.scanDelims(n.pos, !0);
+  let s = i.length;
+  const o = String.fromCharCode(t);
+  if (s < 2)
+    return !1;
+  let c;
+  s % 2 && (c = n.push("text", "", 0), c.content = o, s--);
+  for (let k = 0; k < s; k += 2)
+    c = n.push("text", "", 0), c.content = o + o, n.delimiters.push({
+      marker: t,
+      length: 0,
+      // disable "rule of 3" length checks meant for emphasis
+      token: n.tokens.length - 1,
+      end: -1,
+      open: i.can_open,
+      close: i.can_close
+    });
+  return n.pos += i.length, !0;
+}
+function l(n, r) {
+  let e;
+  const t = [], i = r.length;
+  for (let s = 0; s < i; s++) {
+    const o = r[s];
+    if (o.marker !== 126 || o.end === -1)
+      continue;
+    const c = r[o.end];
+    e = n.tokens[o.token], e.type = "s_open", e.tag = "s", e.nesting = 1, e.markup = "~~", e.content = "", e = n.tokens[c.token], e.type = "s_close", e.tag = "s", e.nesting = -1, e.markup = "~~", e.content = "", n.tokens[c.token - 1].type === "text" && n.tokens[c.token - 1].content === "~" && t.push(c.token - 1);
+  }
+  for (; t.length; ) {
+    const s = t.pop();
+    let o = s + 1;
+    for (; o < n.tokens.length && n.tokens[o].type === "s_close"; )
+      o++;
+    o--, s !== o && (e = n.tokens[o], n.tokens[o] = n.tokens[s], n.tokens[s] = e);
+  }
+}
+function p(n) {
+  const r = n.tokens_meta, e = n.tokens_meta.length;
+  l(n, n.delimiters);
+  for (let t = 0; t < e; t++)
+    r[t] && r[t].delimiters && l(n, r[t].delimiters);
+}
+const u = {
+  tokenize: h,
+  postProcess: p
+};
+export {
+  u as default
+};

package/dist/node_modules/markdown-it/lib/rules_inline/text.js

@@ -0,0 +1,39 @@
+function x(e) {
+  switch (e) {
+    case 10:
+    case 33:
+    case 35:
+    case 36:
+    case 37:
+    case 38:
+    case 42:
+    case 43:
+    case 45:
+    case 58:
+    case 60:
+    case 61:
+    case 62:
+    case 64:
+    case 91:
+    case 92:
+    case 93:
+    case 94:
+    case 95:
+    case 96:
+    case 123:
+    case 125:
+    case 126:
+      return !0;
+    default:
+      return !1;
+  }
+}
+function a(e, s) {
+  let c = e.pos;
+  for (; c < e.posMax && !x(e.src.charCodeAt(c)); )
+    c++;
+  return c === e.pos ? !1 : (s || (e.pending += e.src.slice(e.pos, c)), e.pos = c, !0);
+}
+export {
+  a as default
+};

package/dist/node_modules/markdown-it/lib/token.js

@@ -0,0 +1,31 @@
+function n(r, t, i) {
+  this.type = r, this.tag = t, this.attrs = null, this.map = null, this.nesting = i, this.level = 0, this.children = null, this.content = "", this.markup = "", this.info = "", this.meta = null, this.block = !1, this.hidden = !1;
+}
+n.prototype.attrIndex = function(t) {
+  if (!this.attrs)
+    return -1;
+  const i = this.attrs;
+  for (let s = 0, e = i.length; s < e; s++)
+    if (i[s][0] === t)
+      return s;
+  return -1;
+};
+n.prototype.attrPush = function(t) {
+  this.attrs ? this.attrs.push(t) : this.attrs = [t];
+};
+n.prototype.attrSet = function(t, i) {
+  const s = this.attrIndex(t), e = [t, i];
+  s < 0 ? this.attrPush(e) : this.attrs[s] = e;
+};
+n.prototype.attrGet = function(t) {
+  const i = this.attrIndex(t);
+  let s = null;
+  return i >= 0 && (s = this.attrs[i][1]), s;
+};
+n.prototype.attrJoin = function(t, i) {
+  const s = this.attrIndex(t);
+  s < 0 ? this.attrPush([t, i]) : this.attrs[s][1] = this.attrs[s][1] + " " + i;
+};
+export {
+  n as default
+};

package/dist/node_modules/mdurl/index.js

@@ -0,0 +1,10 @@
+import { default as a } from "./lib/decode.js";
+import { default as f } from "./lib/encode.js";
+import { default as d } from "./lib/format.js";
+import { default as p } from "./lib/parse.js";
+export {
+  a as decode,
+  f as encode,
+  d as format,
+  p as parse
+};

package/dist/node_modules/mdurl/lib/decode.js

@@ -0,0 +1,61 @@
+const h = {};
+function l(s) {
+  let n = h[s];
+  if (n)
+    return n;
+  n = h[s] = [];
+  for (let e = 0; e < 128; e++) {
+    const t = String.fromCharCode(e);
+    n.push(t);
+  }
+  for (let e = 0; e < s.length; e++) {
+    const t = s.charCodeAt(e);
+    n[t] = "%" + ("0" + t.toString(16).toUpperCase()).slice(-2);
+  }
+  return n;
+}
+function u(s, n) {
+  typeof n != "string" && (n = u.defaultChars);
+  const e = l(n);
+  return s.replace(/(%[a-f0-9]{2})+/gi, function(t) {
+    let r = "";
+    for (let f = 0, a = t.length; f < a; f += 3) {
+      const o = parseInt(t.slice(f + 1, f + 3), 16);
+      if (o < 128) {
+        r += e[o];
+        continue;
+      }
+      if ((o & 224) === 192 && f + 3 < a) {
+        const c = parseInt(t.slice(f + 4, f + 6), 16);
+        if ((c & 192) === 128) {
+          const i = o << 6 & 1984 | c & 63;
+          i < 128 ? r += "��" : r += String.fromCharCode(i), f += 3;
+          continue;
+        }
+      }
+      if ((o & 240) === 224 && f + 6 < a) {
+        const c = parseInt(t.slice(f + 4, f + 6), 16), i = parseInt(t.slice(f + 7, f + 9), 16);
+        if ((c & 192) === 128 && (i & 192) === 128) {
+          const x = o << 12 & 61440 | c << 6 & 4032 | i & 63;
+          x < 2048 || x >= 55296 && x <= 57343 ? r += "���" : r += String.fromCharCode(x), f += 6;
+          continue;
+        }
+      }
+      if ((o & 248) === 240 && f + 9 < a) {
+        const c = parseInt(t.slice(f + 4, f + 6), 16), i = parseInt(t.slice(f + 7, f + 9), 16), x = parseInt(t.slice(f + 10, f + 12), 16);
+        if ((c & 192) === 128 && (i & 192) === 128 && (x & 192) === 128) {
+          let C = o << 18 & 1835008 | c << 12 & 258048 | i << 6 & 4032 | x & 63;
+          C < 65536 || C > 1114111 ? r += "����" : (C -= 65536, r += String.fromCharCode(55296 + (C >> 10), 56320 + (C & 1023))), f += 9;
+          continue;
+        }
+      }
+      r += "�";
+    }
+    return r;
+  });
+}
+u.defaultChars = ";/?:@&=+$,#";
+u.componentChars = "";
+export {
+  u as default
+};