@mobilon-dev/chotto 0.3.30 → 0.3.32

package/dist/node_modules/markdown-it/lib/common/html_blocks.js

@@ -0,0 +1,67 @@
+const e = [
+  "address",
+  "article",
+  "aside",
+  "base",
+  "basefont",
+  "blockquote",
+  "body",
+  "caption",
+  "center",
+  "col",
+  "colgroup",
+  "dd",
+  "details",
+  "dialog",
+  "dir",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "frame",
+  "frameset",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hr",
+  "html",
+  "iframe",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "menu",
+  "menuitem",
+  "nav",
+  "noframes",
+  "ol",
+  "optgroup",
+  "option",
+  "p",
+  "param",
+  "search",
+  "section",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "track",
+  "ul"
+];
+export {
+  e as default
+};

package/dist/node_modules/markdown-it/lib/common/html_re.js

@@ -0,0 +1,5 @@
+const o = "[a-zA-Z_:][a-zA-Z0-9:._-]*", n = "[^\"'=<>`\\x00-\\x20]+", c = "'[^']*'", a = '"[^"]*"', e = "(?:" + n + "|" + c + "|" + a + ")", _ = "(?:\\s+" + o + "(?:\\s*=\\s*" + e + ")?)", t = "<[A-Za-z][A-Za-z0-9\\-]*" + _ + "*\\s*\\/?>", s = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>", A = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->", u = "<[?][\\s\\S]*?[?]>", z = "<![A-Za-z][^>]*>", Z = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>", d = new RegExp("^(?:" + t + "|" + s + "|" + A + "|" + u + "|" + z + "|" + Z + ")"), g = new RegExp("^(?:" + t + "|" + s + ")");
+export {
+  g as HTML_OPEN_CLOSE_TAG_RE,
+  d as HTML_TAG_RE
+};

package/dist/node_modules/markdown-it/lib/common/utils.js

@@ -0,0 +1,169 @@
+import * as s from "../../../mdurl/index.js";
+import * as a from "../../../uc.micro/index.js";
+import { decodeHTML as i } from "../../../entities/lib/esm/decode.js";
+import o from "../../../uc.micro/categories/P/regex.js";
+import x from "../../../uc.micro/categories/S/regex.js";
+function u(e) {
+  return Object.prototype.toString.call(e);
+}
+function D(e) {
+  return u(e) === "[object String]";
+}
+const f = Object.prototype.hasOwnProperty;
+function L(e, r) {
+  return f.call(e, r);
+}
+function h(e) {
+  return Array.prototype.slice.call(arguments, 1).forEach(function(t) {
+    if (t) {
+      if (typeof t != "object")
+        throw new TypeError(t + "must be object");
+      Object.keys(t).forEach(function(n) {
+        e[n] = t[n];
+      });
+    }
+  }), e;
+}
+function w(e, r, t) {
+  return [].concat(e.slice(0, r), t, e.slice(r + 1));
+}
+function E(e) {
+  return !(e >= 55296 && e <= 57343 || e >= 64976 && e <= 65007 || (e & 65535) === 65535 || (e & 65535) === 65534 || e >= 0 && e <= 8 || e === 11 || e >= 14 && e <= 31 || e >= 127 && e <= 159 || e > 1114111);
+}
+function l(e) {
+  if (e > 65535) {
+    e -= 65536;
+    const r = 55296 + (e >> 10), t = 56320 + (e & 1023);
+    return String.fromCharCode(r, t);
+  }
+  return String.fromCharCode(e);
+}
+const c = /\\([!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])/g, p = /&([a-z#][a-z0-9]{1,31});/gi, F = new RegExp(c.source + "|" + p.source, "gi"), C = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))$/i;
+function d(e, r) {
+  if (r.charCodeAt(0) === 35 && C.test(r)) {
+    const n = r[1].toLowerCase() === "x" ? parseInt(r.slice(2), 16) : parseInt(r.slice(1), 10);
+    return E(n) ? l(n) : e;
+  }
+  const t = i(e);
+  return t !== e ? t : e;
+}
+function y(e) {
+  return e.indexOf("\\") < 0 ? e : e.replace(c, "$1");
+}
+function M(e) {
+  return e.indexOf("\\") < 0 && e.indexOf("&") < 0 ? e : e.replace(F, function(r, t, n) {
+    return t || d(r, n);
+  });
+}
+const _ = /[&<>"]/, g = /[&<>"]/g, A = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;"
+};
+function P(e) {
+  return A[e];
+}
+function O(e) {
+  return _.test(e) ? e.replace(g, P) : e;
+}
+const S = /[.?*+^$[\]\\(){}|-]/g;
+function b(e) {
+  return e.replace(S, "\\$&");
+}
+function B(e) {
+  switch (e) {
+    case 9:
+    case 32:
+      return !0;
+  }
+  return !1;
+}
+function I(e) {
+  if (e >= 8192 && e <= 8202)
+    return !0;
+  switch (e) {
+    case 9:
+    // \t
+    case 10:
+    // \n
+    case 11:
+    // \v
+    case 12:
+    // \f
+    case 13:
+    // \r
+    case 32:
+    case 160:
+    case 5760:
+    case 8239:
+    case 8287:
+    case 12288:
+      return !0;
+  }
+  return !1;
+}
+function $(e) {
+  return o.test(e) || x.test(e);
+}
+function j(e) {
+  switch (e) {
+    case 33:
+    case 34:
+    case 35:
+    case 36:
+    case 37:
+    case 38:
+    case 39:
+    case 40:
+    case 41:
+    case 42:
+    case 43:
+    case 44:
+    case 45:
+    case 46:
+    case 47:
+    case 58:
+    case 59:
+    case 60:
+    case 61:
+    case 62:
+    case 63:
+    case 64:
+    case 91:
+    case 92:
+    case 93:
+    case 94:
+    case 95:
+    case 96:
+    case 123:
+    case 124:
+    case 125:
+    case 126:
+      return !0;
+    default:
+      return !1;
+  }
+}
+function H(e) {
+  return e = e.trim().replace(/\s+/g, " "), "ẞ".toLowerCase() === "Ṿ" && (e = e.replace(/ẞ/g, "ß")), e.toLowerCase().toUpperCase();
+}
+const N = { mdurl: s, ucmicro: a };
+export {
+  w as arrayReplaceAt,
+  h as assign,
+  O as escapeHtml,
+  b as escapeRE,
+  l as fromCodePoint,
+  L as has,
+  j as isMdAsciiPunct,
+  $ as isPunctChar,
+  B as isSpace,
+  D as isString,
+  E as isValidEntityCode,
+  I as isWhiteSpace,
+  N as lib,
+  H as normalizeReference,
+  M as unescapeAll,
+  y as unescapeMd
+};

package/dist/node_modules/markdown-it/lib/helpers/index.js

@@ -0,0 +1,8 @@
+import { default as r } from "./parse_link_label.js";
+import { default as o } from "./parse_link_destination.js";
+import { default as f } from "./parse_link_title.js";
+export {
+  o as parseLinkDestination,
+  r as parseLinkLabel,
+  f as parseLinkTitle
+};

package/dist/node_modules/markdown-it/lib/helpers/parse_link_destination.js

@@ -0,0 +1,44 @@
+import { unescapeAll as u } from "../common/utils.js";
+function c(o, n, t) {
+  let r, e = n;
+  const i = {
+    ok: !1,
+    pos: 0,
+    str: ""
+  };
+  if (o.charCodeAt(e) === 60) {
+    for (e++; e < t; ) {
+      if (r = o.charCodeAt(e), r === 10 || r === 60)
+        return i;
+      if (r === 62)
+        return i.pos = e + 1, i.str = u(o.slice(n + 1, e)), i.ok = !0, i;
+      if (r === 92 && e + 1 < t) {
+        e += 2;
+        continue;
+      }
+      e++;
+    }
+    return i;
+  }
+  let f = 0;
+  for (; e < t && (r = o.charCodeAt(e), !(r === 32 || r < 32 || r === 127)); ) {
+    if (r === 92 && e + 1 < t) {
+      if (o.charCodeAt(e + 1) === 32)
+        break;
+      e += 2;
+      continue;
+    }
+    if (r === 40 && (f++, f > 32))
+      return i;
+    if (r === 41) {
+      if (f === 0)
+        break;
+      f--;
+    }
+    e++;
+  }
+  return n === e || f !== 0 || (i.str = u(o.slice(n, e)), i.pos = e, i.ok = !0), i;
+}
+export {
+  c as default
+};

package/dist/node_modules/markdown-it/lib/helpers/parse_link_label.js

@@ -0,0 +1,21 @@
+function u(o, f, s) {
+  let p, i, r, l;
+  const d = o.posMax, n = o.pos;
+  for (o.pos = f + 1, p = 1; o.pos < d; ) {
+    if (r = o.src.charCodeAt(o.pos), r === 93 && (p--, p === 0)) {
+      i = !0;
+      break;
+    }
+    if (l = o.pos, o.md.inline.skipToken(o), r === 91) {
+      if (l === o.pos - 1)
+        p++;
+      else if (s)
+        return o.pos = n, -1;
+    }
+  }
+  let e = -1;
+  return i && (e = o.pos), o.pos = n, e;
+}
+export {
+  u as default
+};

package/dist/node_modules/markdown-it/lib/helpers/parse_link_title.js

@@ -0,0 +1,37 @@
+import { unescapeAll as f } from "../common/utils.js";
+function u(n, l, t, c) {
+  let o, r = l;
+  const e = {
+    // if `true`, this is a valid link title
+    ok: !1,
+    // if `true`, this link can be continued on the next line
+    can_continue: !1,
+    // if `ok`, it's the position of the first character after the closing marker
+    pos: 0,
+    // if `ok`, it's the unescaped title
+    str: "",
+    // expected closing marker character code
+    marker: 0
+  };
+  if (c)
+    e.str = c.str, e.marker = c.marker;
+  else {
+    if (r >= t)
+      return e;
+    let i = n.charCodeAt(r);
+    if (i !== 34 && i !== 39 && i !== 40)
+      return e;
+    l++, r++, i === 40 && (i = 41), e.marker = i;
+  }
+  for (; r < t; ) {
+    if (o = n.charCodeAt(r), o === e.marker)
+      return e.pos = r + 1, e.str += f(n.slice(l, r)), e.ok = !0, e;
+    if (o === 40 && e.marker === 41)
+      return e;
+    o === 92 && r + 1 < t && r++, r++;
+  }
+  return e.can_continue = !0, e.str += f(n.slice(l, r)), e;
+}
+export {
+  u as default
+};

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

@@ -0,0 +1,112 @@
+import * as m from "./common/utils.js";
+import { isString as c, assign as a } from "./common/utils.js";
+import * as p from "./helpers/index.js";
+import d from "./renderer.js";
+import w from "./parser_core.js";
+import y from "./parser_block.js";
+import k from "./parser_inline.js";
+import g from "../../linkify-it/index.js";
+import s from "../../mdurl/lib/decode.js";
+import b from "../../mdurl/lib/encode.js";
+import f from "../../mdurl/lib/format.js";
+import u from "../../mdurl/lib/parse.js";
+import l from "../../punycode.js/punycode.es6.js";
+import O from "./presets/default.js";
+import E from "./presets/zero.js";
+import I from "./presets/commonmark.js";
+const A = {
+  default: O,
+  zero: E,
+  commonmark: I
+}, _ = /^(vbscript|javascript|file|data):/, x = /^data:image\/(gif|png|jpeg|webp);/;
+function L(t) {
+  const r = t.trim().toLowerCase();
+  return _.test(r) ? x.test(r) : !0;
+}
+const h = ["http:", "https:", "mailto:"];
+function z(t) {
+  const r = u(t, !0);
+  if (r.hostname && (!r.protocol || h.indexOf(r.protocol) >= 0))
+    try {
+      r.hostname = l.toASCII(r.hostname);
+    } catch {
+    }
+  return b(f(r));
+}
+function R(t) {
+  const r = u(t, !0);
+  if (r.hostname && (!r.protocol || h.indexOf(r.protocol) >= 0))
+    try {
+      r.hostname = l.toUnicode(r.hostname);
+    } catch {
+    }
+  return s(f(r), s.defaultChars + "%");
+}
+function n(t, r) {
+  if (!(this instanceof n))
+    return new n(t, r);
+  r || c(t) || (r = t || {}, t = "default"), this.inline = new k(), this.block = new y(), this.core = new w(), this.renderer = new d(), this.linkify = new g(), this.validateLink = L, this.normalizeLink = z, this.normalizeLinkText = R, this.utils = m, this.helpers = a({}, p), this.options = {}, this.configure(t), r && this.set(r);
+}
+n.prototype.set = function(t) {
+  return a(this.options, t), this;
+};
+n.prototype.configure = function(t) {
+  const r = this;
+  if (c(t)) {
+    const o = t;
+    if (t = A[o], !t)
+      throw new Error('Wrong `markdown-it` preset "' + o + '", check name');
+  }
+  if (!t)
+    throw new Error("Wrong `markdown-it` preset, can't be empty");
+  return t.options && r.set(t.options), t.components && Object.keys(t.components).forEach(function(o) {
+    t.components[o].rules && r[o].ruler.enableOnly(t.components[o].rules), t.components[o].rules2 && r[o].ruler2.enableOnly(t.components[o].rules2);
+  }), this;
+};
+n.prototype.enable = function(t, r) {
+  let o = [];
+  Array.isArray(t) || (t = [t]), ["core", "block", "inline"].forEach(function(e) {
+    o = o.concat(this[e].ruler.enable(t, !0));
+  }, this), o = o.concat(this.inline.ruler2.enable(t, !0));
+  const i = t.filter(function(e) {
+    return o.indexOf(e) < 0;
+  });
+  if (i.length && !r)
+    throw new Error("MarkdownIt. Failed to enable unknown rule(s): " + i);
+  return this;
+};
+n.prototype.disable = function(t, r) {
+  let o = [];
+  Array.isArray(t) || (t = [t]), ["core", "block", "inline"].forEach(function(e) {
+    o = o.concat(this[e].ruler.disable(t, !0));
+  }, this), o = o.concat(this.inline.ruler2.disable(t, !0));
+  const i = t.filter(function(e) {
+    return o.indexOf(e) < 0;
+  });
+  if (i.length && !r)
+    throw new Error("MarkdownIt. Failed to disable unknown rule(s): " + i);
+  return this;
+};
+n.prototype.use = function(t) {
+  const r = [this].concat(Array.prototype.slice.call(arguments, 1));
+  return t.apply(t, r), this;
+};
+n.prototype.parse = function(t, r) {
+  if (typeof t != "string")
+    throw new Error("Input data should be a String");
+  const o = new this.core.State(t, this, r);
+  return this.core.process(o), o.tokens;
+};
+n.prototype.render = function(t, r) {
+  return r = r || {}, this.renderer.render(this.parse(t, r), this.options, r);
+};
+n.prototype.parseInline = function(t, r) {
+  const o = new this.core.State(t, this, r);
+  return o.inlineMode = !0, this.core.process(o), o.tokens;
+};
+n.prototype.renderInline = function(t, r) {
+  return r = r || {}, this.renderer.render(this.parseInline(t, r), this.options, r);
+};
+export {
+  n as default
+};

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

@@ -0,0 +1,63 @@
+import u from "./ruler.js";
+import s from "./rules_block/state_block.js";
+import k from "./rules_block/table.js";
+import b from "./rules_block/code.js";
+import g from "./rules_block/fence.js";
+import d from "./rules_block/blockquote.js";
+import q from "./rules_block/hr.js";
+import w from "./rules_block/list.js";
+import y from "./rules_block/reference.js";
+import E from "./rules_block/html_block.js";
+import x from "./rules_block/heading.js";
+import S from "./rules_block/lheading.js";
+import _ from "./rules_block/paragraph.js";
+const t = [
+  // First 2 params - rule name & source. Secondary array - list of rules,
+  // which can be terminated by this one.
+  ["table", k, ["paragraph", "reference"]],
+  ["code", b],
+  ["fence", g, ["paragraph", "reference", "blockquote", "list"]],
+  ["blockquote", d, ["paragraph", "reference", "blockquote", "list"]],
+  ["hr", q, ["paragraph", "reference", "blockquote", "list"]],
+  ["list", w, ["paragraph", "reference", "blockquote"]],
+  ["reference", y],
+  ["html_block", E, ["paragraph", "reference", "blockquote"]],
+  ["heading", x, ["paragraph", "reference", "blockquote"]],
+  ["lheading", S],
+  ["paragraph", _]
+];
+function c() {
+  this.ruler = new u();
+  for (let e = 0; e < t.length; e++)
+    this.ruler.push(t[e][0], t[e][1], { alt: (t[e][2] || []).slice() });
+}
+c.prototype.tokenize = function(e, n, o) {
+  const l = this.ruler.getRules(""), i = l.length, m = e.md.options.maxNesting;
+  let r = n, p = !1;
+  for (; r < o && (e.line = r = e.skipEmptyLines(r), !(r >= o || e.sCount[r] < e.blkIndent)); ) {
+    if (e.level >= m) {
+      e.line = o;
+      break;
+    }
+    const h = e.line;
+    let f = !1;
+    for (let a = 0; a < i; a++)
+      if (f = l[a](e, r, o, !1), f) {
+        if (h >= e.line)
+          throw new Error("block rule didn't increment state.line");
+        break;
+      }
+    if (!f) throw new Error("none of the block rules matched");
+    e.tight = !p, e.isEmpty(e.line - 1) && (p = !0), r = e.line, r < o && e.isEmpty(r) && (p = !0, r++, e.line = r);
+  }
+};
+c.prototype.parse = function(e, n, o, l) {
+  if (!e)
+    return;
+  const i = new this.State(e, n, o, l);
+  this.tokenize(i, i.line, i.lineMax);
+};
+c.prototype.State = s;
+export {
+  c as default
+};

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

@@ -0,0 +1,34 @@
+import m from "./ruler.js";
+import n from "./rules_core/state_core.js";
+import p from "./rules_core/normalize.js";
+import s from "./rules_core/block.js";
+import f from "./rules_core/inline.js";
+import u from "./rules_core/linkify.js";
+import a from "./rules_core/replacements.js";
+import c from "./rules_core/smartquotes.js";
+import h from "./rules_core/text_join.js";
+const t = [
+  ["normalize", p],
+  ["block", s],
+  ["inline", f],
+  ["linkify", u],
+  ["replacements", a],
+  ["smartquotes", c],
+  // `text_join` finds `text_special` tokens (for escape sequences)
+  // and joins them with the rest of the text
+  ["text_join", h]
+];
+function i() {
+  this.ruler = new m();
+  for (let r = 0; r < t.length; r++)
+    this.ruler.push(t[r][0], t[r][1]);
+}
+i.prototype.process = function(r) {
+  const e = this.ruler.getRules("");
+  for (let o = 0, l = e.length; o < l; o++)
+    e[o](r);
+};
+i.prototype.State = n;
+export {
+  i as default
+};

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

@@ -0,0 +1,96 @@
+import c from "./ruler.js";
+import k from "./rules_inline/state_inline.js";
+import g from "./rules_inline/text.js";
+import a from "./rules_inline/linkify.js";
+import d from "./rules_inline/newline.js";
+import w from "./rules_inline/escape.js";
+import _ from "./rules_inline/backticks.js";
+import u from "./rules_inline/strikethrough.js";
+import h from "./rules_inline/emphasis.js";
+import x from "./rules_inline/link.js";
+import y from "./rules_inline/image.js";
+import b from "./rules_inline/autolink.js";
+import v from "./rules_inline/html_inline.js";
+import P from "./rules_inline/entity.js";
+import z from "./rules_inline/balance_pairs.js";
+import N from "./rules_inline/fragments_join.js";
+const m = [
+  ["text", g],
+  ["linkify", a],
+  ["newline", d],
+  ["escape", w],
+  ["backticks", _],
+  ["strikethrough", u.tokenize],
+  ["emphasis", h.tokenize],
+  ["link", x],
+  ["image", y],
+  ["autolink", b],
+  ["html_inline", v],
+  ["entity", P]
+], f = [
+  ["balance_pairs", z],
+  ["strikethrough", u.postProcess],
+  ["emphasis", h.postProcess],
+  // rules for pairs separate '**' into its own text tokens, which may be left unused,
+  // rule below merges unused segments back with the rest of the text
+  ["fragments_join", N]
+];
+function p() {
+  this.ruler = new c();
+  for (let o = 0; o < m.length; o++)
+    this.ruler.push(m[o][0], m[o][1]);
+  this.ruler2 = new c();
+  for (let o = 0; o < f.length; o++)
+    this.ruler2.push(f[o][0], f[o][1]);
+}
+p.prototype.skipToken = function(o) {
+  const i = o.pos, t = this.ruler.getRules(""), s = t.length, l = o.md.options.maxNesting, n = o.cache;
+  if (typeof n[i] < "u") {
+    o.pos = n[i];
+    return;
+  }
+  let r = !1;
+  if (o.level < l) {
+    for (let e = 0; e < s; e++)
+      if (o.level++, r = t[e](o, !0), o.level--, r) {
+        if (i >= o.pos)
+          throw new Error("inline rule didn't increment state.pos");
+        break;
+      }
+  } else
+    o.pos = o.posMax;
+  r || o.pos++, n[i] = o.pos;
+};
+p.prototype.tokenize = function(o) {
+  const i = this.ruler.getRules(""), t = i.length, s = o.posMax, l = o.md.options.maxNesting;
+  for (; o.pos < s; ) {
+    const n = o.pos;
+    let r = !1;
+    if (o.level < l) {
+      for (let e = 0; e < t; e++)
+        if (r = i[e](o, !1), r) {
+          if (n >= o.pos)
+            throw new Error("inline rule didn't increment state.pos");
+          break;
+        }
+    }
+    if (r) {
+      if (o.pos >= s)
+        break;
+      continue;
+    }
+    o.pending += o.src[o.pos++];
+  }
+  o.pending && o.pushPending();
+};
+p.prototype.parse = function(o, i, t, s) {
+  const l = new this.State(o, i, t, s);
+  this.tokenize(l);
+  const n = this.ruler2.getRules(""), r = n.length;
+  for (let e = 0; e < r; e++)
+    n[e](l);
+};
+p.prototype.State = k;
+export {
+  p as default
+};