@prokodo/ui 0.0.37 → 0.0.39

package/dist/node_modules/.pnpm/linkify-it@5.0.0/node_modules/linkify-it/index.js

@@ -0,0 +1,373 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import reFactory from "./lib/re.js";
+function assign(obj) {
+  const sources = Array.prototype.slice.call(arguments, 1);
+  sources.forEach(function(source) {
+    if (!source) {
+      return;
+    }
+    Object.keys(source).forEach(function(key) {
+      obj[key] = source[key];
+    });
+  });
+  return obj;
+}
+__name(assign, "assign");
+function _class(obj) {
+  return Object.prototype.toString.call(obj);
+}
+__name(_class, "_class");
+function isString(obj) {
+  return _class(obj) === "[object String]";
+}
+__name(isString, "isString");
+function isObject(obj) {
+  return _class(obj) === "[object Object]";
+}
+__name(isObject, "isObject");
+function isRegExp(obj) {
+  return _class(obj) === "[object RegExp]";
+}
+__name(isRegExp, "isRegExp");
+function isFunction(obj) {
+  return _class(obj) === "[object Function]";
+}
+__name(isFunction, "isFunction");
+function escapeRE(str) {
+  return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
+}
+__name(escapeRE, "escapeRE");
+const defaultOptions = {
+  fuzzyLink: true,
+  fuzzyEmail: true,
+  fuzzyIP: false
+};
+function isOptionsObj(obj) {
+  return Object.keys(obj || {}).reduce(function(acc, k) {
+    return acc || defaultOptions.hasOwnProperty(k);
+  }, false);
+}
+__name(isOptionsObj, "isOptionsObj");
+const defaultSchemas = {
+  "http:": {
+    validate: /* @__PURE__ */ __name(function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.http) {
+        self.re.http = new RegExp(
+          "^\\/\\/" + self.re.src_auth + self.re.src_host_port_strict + self.re.src_path,
+          "i"
+        );
+      }
+      if (self.re.http.test(tail)) {
+        return tail.match(self.re.http)[0].length;
+      }
+      return 0;
+    }, "validate")
+  },
+  "https:": "http:",
+  "ftp:": "http:",
+  "//": {
+    validate: /* @__PURE__ */ __name(function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.no_http) {
+        self.re.no_http = new RegExp(
+          "^" + self.re.src_auth + // Don't allow single-level domains, because of false positives like '//test'
+          // with code comments
+          "(?:localhost|(?:(?:" + self.re.src_domain + ")\\.)+" + self.re.src_domain_root + ")" + self.re.src_port + self.re.src_host_terminator + self.re.src_path,
+          "i"
+        );
+      }
+      if (self.re.no_http.test(tail)) {
+        if (pos >= 3 && text[pos - 3] === ":") {
+          return 0;
+        }
+        if (pos >= 3 && text[pos - 3] === "/") {
+          return 0;
+        }
+        return tail.match(self.re.no_http)[0].length;
+      }
+      return 0;
+    }, "validate")
+  },
+  "mailto:": {
+    validate: /* @__PURE__ */ __name(function(text, pos, self) {
+      const tail = text.slice(pos);
+      if (!self.re.mailto) {
+        self.re.mailto = new RegExp(
+          "^" + self.re.src_email_name + "@" + self.re.src_host_strict,
+          "i"
+        );
+      }
+      if (self.re.mailto.test(tail)) {
+        return tail.match(self.re.mailto)[0].length;
+      }
+      return 0;
+    }, "validate")
+  }
+};
+const tlds_2ch_src_re = "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
+const tlds_default = "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф".split("|");
+function resetScanCache(self) {
+  self.__index__ = -1;
+  self.__text_cache__ = "";
+}
+__name(resetScanCache, "resetScanCache");
+function createValidator(re) {
+  return function(text, pos) {
+    const tail = text.slice(pos);
+    if (re.test(tail)) {
+      return tail.match(re)[0].length;
+    }
+    return 0;
+  };
+}
+__name(createValidator, "createValidator");
+function createNormalizer() {
+  return function(match2, self) {
+    self.normalize(match2);
+  };
+}
+__name(createNormalizer, "createNormalizer");
+function compile(self) {
+  const re = self.re = reFactory(self.__opts__);
+  const tlds2 = self.__tlds__.slice();
+  self.onCompile();
+  if (!self.__tlds_replaced__) {
+    tlds2.push(tlds_2ch_src_re);
+  }
+  tlds2.push(re.src_xn);
+  re.src_tlds = tlds2.join("|");
+  function untpl(tpl) {
+    return tpl.replace("%TLDS%", re.src_tlds);
+  }
+  __name(untpl, "untpl");
+  re.email_fuzzy = RegExp(untpl(re.tpl_email_fuzzy), "i");
+  re.link_fuzzy = RegExp(untpl(re.tpl_link_fuzzy), "i");
+  re.link_no_ip_fuzzy = RegExp(untpl(re.tpl_link_no_ip_fuzzy), "i");
+  re.host_fuzzy_test = RegExp(untpl(re.tpl_host_fuzzy_test), "i");
+  const aliases = [];
+  self.__compiled__ = {};
+  function schemaError(name, val) {
+    throw new Error('(LinkifyIt) Invalid schema "' + name + '": ' + val);
+  }
+  __name(schemaError, "schemaError");
+  Object.keys(self.__schemas__).forEach(function(name) {
+    const val = self.__schemas__[name];
+    if (val === null) {
+      return;
+    }
+    const compiled = { validate: null, link: null };
+    self.__compiled__[name] = compiled;
+    if (isObject(val)) {
+      if (isRegExp(val.validate)) {
+        compiled.validate = createValidator(val.validate);
+      } else if (isFunction(val.validate)) {
+        compiled.validate = val.validate;
+      } else {
+        schemaError(name, val);
+      }
+      if (isFunction(val.normalize)) {
+        compiled.normalize = val.normalize;
+      } else if (!val.normalize) {
+        compiled.normalize = createNormalizer();
+      } else {
+        schemaError(name, val);
+      }
+      return;
+    }
+    if (isString(val)) {
+      aliases.push(name);
+      return;
+    }
+    schemaError(name, val);
+  });
+  aliases.forEach(function(alias) {
+    if (!self.__compiled__[self.__schemas__[alias]]) {
+      return;
+    }
+    self.__compiled__[alias].validate = self.__compiled__[self.__schemas__[alias]].validate;
+    self.__compiled__[alias].normalize = self.__compiled__[self.__schemas__[alias]].normalize;
+  });
+  self.__compiled__[""] = { validate: null, normalize: createNormalizer() };
+  const slist = Object.keys(self.__compiled__).filter(function(name) {
+    return name.length > 0 && self.__compiled__[name];
+  }).map(escapeRE).join("|");
+  self.re.schema_test = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "i");
+  self.re.schema_search = RegExp("(^|(?!_)(?:[><｜]|" + re.src_ZPCc + "))(" + slist + ")", "ig");
+  self.re.schema_at_start = RegExp("^" + self.re.schema_search.source, "i");
+  self.re.pretest = RegExp(
+    "(" + self.re.schema_test.source + ")|(" + self.re.host_fuzzy_test.source + ")|@",
+    "i"
+  );
+  resetScanCache(self);
+}
+__name(compile, "compile");
+function Match(self, shift) {
+  const start = self.__index__;
+  const end = self.__last_index__;
+  const text = self.__text_cache__.slice(start, end);
+  this.schema = self.__schema__.toLowerCase();
+  this.index = start + shift;
+  this.lastIndex = end + shift;
+  this.raw = text;
+  this.text = text;
+  this.url = text;
+}
+__name(Match, "Match");
+function createMatch(self, shift) {
+  const match2 = new Match(self, shift);
+  self.__compiled__[match2.schema].normalize(match2, self);
+  return match2;
+}
+__name(createMatch, "createMatch");
+function LinkifyIt(schemas, options) {
+  if (!(this instanceof LinkifyIt)) {
+    return new LinkifyIt(schemas, options);
+  }
+  if (!options) {
+    if (isOptionsObj(schemas)) {
+      options = schemas;
+      schemas = {};
+    }
+  }
+  this.__opts__ = assign({}, defaultOptions, options);
+  this.__index__ = -1;
+  this.__last_index__ = -1;
+  this.__schema__ = "";
+  this.__text_cache__ = "";
+  this.__schemas__ = assign({}, defaultSchemas, schemas);
+  this.__compiled__ = {};
+  this.__tlds__ = tlds_default;
+  this.__tlds_replaced__ = false;
+  this.re = {};
+  compile(this);
+}
+__name(LinkifyIt, "LinkifyIt");
+LinkifyIt.prototype.add = /* @__PURE__ */ __name(function add(schema, definition) {
+  this.__schemas__[schema] = definition;
+  compile(this);
+  return this;
+}, "add");
+LinkifyIt.prototype.set = /* @__PURE__ */ __name(function set(options) {
+  this.__opts__ = assign(this.__opts__, options);
+  return this;
+}, "set");
+LinkifyIt.prototype.test = /* @__PURE__ */ __name(function test(text) {
+  this.__text_cache__ = text;
+  this.__index__ = -1;
+  if (!text.length) {
+    return false;
+  }
+  let m, ml, me, len, shift, next, re, tld_pos, at_pos;
+  if (this.re.schema_test.test(text)) {
+    re = this.re.schema_search;
+    re.lastIndex = 0;
+    while ((m = re.exec(text)) !== null) {
+      len = this.testSchemaAt(text, m[2], re.lastIndex);
+      if (len) {
+        this.__schema__ = m[2];
+        this.__index__ = m.index + m[1].length;
+        this.__last_index__ = m.index + m[0].length + len;
+        break;
+      }
+    }
+  }
+  if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
+    tld_pos = text.search(this.re.host_fuzzy_test);
+    if (tld_pos >= 0) {
+      if (this.__index__ < 0 || tld_pos < this.__index__) {
+        if ((ml = text.match(this.__opts__.fuzzyIP ? this.re.link_fuzzy : this.re.link_no_ip_fuzzy)) !== null) {
+          shift = ml.index + ml[1].length;
+          if (this.__index__ < 0 || shift < this.__index__) {
+            this.__schema__ = "";
+            this.__index__ = shift;
+            this.__last_index__ = ml.index + ml[0].length;
+          }
+        }
+      }
+    }
+  }
+  if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
+    at_pos = text.indexOf("@");
+    if (at_pos >= 0) {
+      if ((me = text.match(this.re.email_fuzzy)) !== null) {
+        shift = me.index + me[1].length;
+        next = me.index + me[0].length;
+        if (this.__index__ < 0 || shift < this.__index__ || shift === this.__index__ && next > this.__last_index__) {
+          this.__schema__ = "mailto:";
+          this.__index__ = shift;
+          this.__last_index__ = next;
+        }
+      }
+    }
+  }
+  return this.__index__ >= 0;
+}, "test");
+LinkifyIt.prototype.pretest = /* @__PURE__ */ __name(function pretest(text) {
+  return this.re.pretest.test(text);
+}, "pretest");
+LinkifyIt.prototype.testSchemaAt = /* @__PURE__ */ __name(function testSchemaAt(text, schema, pos) {
+  if (!this.__compiled__[schema.toLowerCase()]) {
+    return 0;
+  }
+  return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
+}, "testSchemaAt");
+LinkifyIt.prototype.match = /* @__PURE__ */ __name(function match(text) {
+  const result = [];
+  let shift = 0;
+  if (this.__index__ >= 0 && this.__text_cache__ === text) {
+    result.push(createMatch(this, shift));
+    shift = this.__last_index__;
+  }
+  let tail = shift ? text.slice(shift) : text;
+  while (this.test(tail)) {
+    result.push(createMatch(this, shift));
+    tail = tail.slice(this.__last_index__);
+    shift += this.__last_index__;
+  }
+  if (result.length) {
+    return result;
+  }
+  return null;
+}, "match");
+LinkifyIt.prototype.matchAtStart = /* @__PURE__ */ __name(function matchAtStart(text) {
+  this.__text_cache__ = text;
+  this.__index__ = -1;
+  if (!text.length) return null;
+  const m = this.re.schema_at_start.exec(text);
+  if (!m) return null;
+  const len = this.testSchemaAt(text, m[2], m[0].length);
+  if (!len) return null;
+  this.__schema__ = m[2];
+  this.__index__ = m.index + m[1].length;
+  this.__last_index__ = m.index + m[0].length + len;
+  return createMatch(this, 0);
+}, "matchAtStart");
+LinkifyIt.prototype.tlds = /* @__PURE__ */ __name(function tlds(list, keepOld) {
+  list = Array.isArray(list) ? list : [list];
+  if (!keepOld) {
+    this.__tlds__ = list.slice();
+    this.__tlds_replaced__ = true;
+    compile(this);
+    return this;
+  }
+  this.__tlds__ = this.__tlds__.concat(list).sort().filter(function(el, idx, arr) {
+    return el !== arr[idx - 1];
+  }).reverse();
+  compile(this);
+  return this;
+}, "tlds");
+LinkifyIt.prototype.normalize = /* @__PURE__ */ __name(function normalize(match2) {
+  if (!match2.schema) {
+    match2.url = "http://" + match2.url;
+  }
+  if (match2.schema === "mailto:" && !/^mailto:/i.test(match2.url)) {
+    match2.url = "mailto:" + match2.url;
+  }
+}, "normalize");
+LinkifyIt.prototype.onCompile = /* @__PURE__ */ __name(function onCompile() {
+}, "onCompile");
+export {
+  LinkifyIt as default
+};

package/dist/node_modules/.pnpm/linkify-it@5.0.0/node_modules/linkify-it/lib/re.js

@@ -0,0 +1,50 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import Any from "../../../../uc.micro@2.1.0/node_modules/uc.micro/properties/Any/regex.js";
+import Cc from "../../../../uc.micro@2.1.0/node_modules/uc.micro/categories/Cc/regex.js";
+import P from "../../../../uc.micro@2.1.0/node_modules/uc.micro/categories/P/regex.js";
+import Z from "../../../../uc.micro@2.1.0/node_modules/uc.micro/categories/Z/regex.js";
+function reFactory(opts) {
+  const re = {};
+  opts = opts || {};
+  re.src_Any = Any.source;
+  re.src_Cc = Cc.source;
+  re.src_Z = Z.source;
+  re.src_P = P.source;
+  re.src_ZPCc = [re.src_Z, re.src_P, re.src_Cc].join("|");
+  re.src_ZCc = [re.src_Z, re.src_Cc].join("|");
+  const text_separators = "[><｜]";
+  re.src_pseudo_letter = "(?:(?!" + text_separators + "|" + re.src_ZPCc + ")" + re.src_Any + ")";
+  re.src_ip4 = "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
+  re.src_auth = "(?:(?:(?!" + re.src_ZCc + "|[@/\\[\\]()]).)+@)?";
+  re.src_port = "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
+  re.src_host_terminator = "(?=$|" + text_separators + "|" + re.src_ZPCc + ")(?!" + (opts["---"] ? "-(?!--)|" : "-|") + "_|:\\d|\\.-|\\.(?!$|" + re.src_ZPCc + "))";
+  re.src_path = "(?:[/?#](?:(?!" + re.src_ZCc + "|" + text_separators + `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` + re.src_ZCc + "|\\]).)*\\]|\\((?:(?!" + re.src_ZCc + "|[)]).)*\\)|\\{(?:(?!" + re.src_ZCc + '|[}]).)*\\}|\\"(?:(?!' + re.src_ZCc + `|["]).)+\\"|\\'(?:(?!` + re.src_ZCc + "|[']).)+\\'|\\'(?=" + re.src_pseudo_letter + "|[-])|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" + re.src_ZCc + "|[.]|$)|" + (opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") + // allow `,,,` in paths
+  ",(?!" + re.src_ZCc + "|$)|;(?!" + re.src_ZCc + "|$)|\\!+(?!" + re.src_ZCc + "|[!]|$)|\\?(?!" + re.src_ZCc + "|[?]|$))+|\\/)?";
+  re.src_email_name = '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
+  re.src_xn = "xn--[a-z0-9\\-]{1,59}";
+  re.src_domain_root = // Allow letters & digits (http://test1)
+  "(?:" + re.src_xn + "|" + re.src_pseudo_letter + "{1,63})";
+  re.src_domain = "(?:" + re.src_xn + "|(?:" + re.src_pseudo_letter + ")|(?:" + re.src_pseudo_letter + "(?:-|" + re.src_pseudo_letter + "){0,61}" + re.src_pseudo_letter + "))";
+  re.src_host = "(?:(?:(?:(?:" + re.src_domain + ")\\.)*" + re.src_domain + "))";
+  re.tpl_host_fuzzy = "(?:" + re.src_ip4 + "|(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%)))";
+  re.tpl_host_no_ip_fuzzy = "(?:(?:(?:" + re.src_domain + ")\\.)+(?:%TLDS%))";
+  re.src_host_strict = re.src_host + re.src_host_terminator;
+  re.tpl_host_fuzzy_strict = re.tpl_host_fuzzy + re.src_host_terminator;
+  re.src_host_port_strict = re.src_host + re.src_port + re.src_host_terminator;
+  re.tpl_host_port_fuzzy_strict = re.tpl_host_fuzzy + re.src_port + re.src_host_terminator;
+  re.tpl_host_port_no_ip_fuzzy_strict = re.tpl_host_no_ip_fuzzy + re.src_port + re.src_host_terminator;
+  re.tpl_host_fuzzy_test = "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" + re.src_ZPCc + "|>|$))";
+  re.tpl_email_fuzzy = "(^|" + text_separators + '|"|\\(|' + re.src_ZCc + ")(" + re.src_email_name + "@" + re.tpl_host_fuzzy_strict + ")";
+  re.tpl_link_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
+  // but can start with > (markdown blockquote)
+  "(^|(?![.:/\\-_@])(?:[$+<=>^`|｜]|" + re.src_ZPCc + "))((?![$+<=>^`|｜])" + re.tpl_host_port_fuzzy_strict + re.src_path + ")";
+  re.tpl_link_no_ip_fuzzy = // Fuzzy link can't be prepended with .:/\- and non punctuation.
+  // but can start with > (markdown blockquote)
+  "(^|(?![.:/\\-_@])(?:[$+<=>^`|｜]|" + re.src_ZPCc + "))((?![$+<=>^`|｜])" + re.tpl_host_port_no_ip_fuzzy_strict + re.src_path + ")";
+  return re;
+}
+__name(reFactory, "reFactory");
+export {
+  reFactory as default
+};

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

@@ -0,0 +1,67 @@
+const block_names = [
+  "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 {
+  block_names as default
+};

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

@@ -0,0 +1,18 @@
+const attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
+const unquoted = "[^\"'=<>`\\x00-\\x20]+";
+const single_quoted = "'[^']*'";
+const double_quoted = '"[^"]*"';
+const attr_value = "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
+const attribute = "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
+const open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
+const close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
+const comment = "<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->";
+const processing = "<[?][\\s\\S]*?[?]>";
+const declaration = "<![A-Za-z][^>]*>";
+const cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
+const HTML_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + "|" + comment + "|" + processing + "|" + declaration + "|" + cdata + ")");
+const HTML_OPEN_CLOSE_TAG_RE = new RegExp("^(?:" + open_tag + "|" + close_tag + ")");
+export {
+  HTML_OPEN_CLOSE_TAG_RE,
+  HTML_TAG_RE
+};