@subiz/widget-v4 4.0.89 → 4.0.91

package/dist/441.js

@@ -37,7 +37,6 @@ __webpack_require__.r(__webpack_exports__);
 
 function getDefaults() {
   return {
-    async: false,
     baseUrl: null,
     breaks: false,
     extensions: null,
@@ -97,9 +96,6 @@ function escape(html, encode) {
 
 const unescapeTest = /&(#(?:\d+)|(?:#x[0-9A-Fa-f]+)|(?:\w+));?/ig;
 
-/**
- * @param {string} html
- */
 function unescape(html) {
   // explicitly match decimal, hex, and named HTML entities
   return html.replace(unescapeTest, (_, n) => {
@@ -115,13 +111,8 @@ function unescape(html) {
 }
 
 const caret = /(^|[^\[])\^/g;
-
-/**
- * @param {string | RegExp} regex
- * @param {string} opt
- */
 function edit(regex, opt) {
-  regex = typeof regex === 'string' ? regex : regex.source;
+  regex = regex.source || regex;
   opt = opt || '';
   const obj = {
     replace: (name, val) => {
@@ -139,12 +130,6 @@ function edit(regex, opt) {
 
 const nonWordAndColonTest = /[^\w:]/g;
 const originIndependentUrl = /^$|^[a-z][a-z0-9+.-]*:|^[?#]/i;
-
-/**
- * @param {boolean} sanitize
- * @param {string} base
- * @param {string} href
- */
 function cleanUrl(sanitize, base, href) {
   if (sanitize) {
     let prot;
@@ -175,10 +160,6 @@ const justDomain = /^[^:]+:\/*[^/]*$/;
 const protocol = /^([^:]+:)[\s\S]*$/;
 const domain = /^([^:]+:\/*[^/]*)[\s\S]*$/;
 
-/**
- * @param {string} base
- * @param {string} href
- */
 function resolveUrl(base, href) {
   if (!baseUrls[' ' + base]) {
     // we can ignore everything in base after the last slash of its path component,
@@ -263,14 +244,9 @@ function splitCells(tableRow, count) {
   return cells;
 }
 
-/**
- * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
- * /c*$/ is vulnerable to REDOS.
- *
- * @param {string} str
- * @param {string} c
- * @param {boolean} invert Remove suffix of non-c chars instead. Default falsey.
- */
+// Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
+// /c*$/ is vulnerable to REDOS.
+// invert: Remove suffix of non-c chars instead. Default falsey.
 function rtrim(str, c, invert) {
   const l = str.length;
   if (l === 0) {
@@ -292,7 +268,7 @@ function rtrim(str, c, invert) {
     }
   }
 
-  return str.slice(0, l - suffLen);
+  return str.substr(0, l - suffLen);
 }
 
 function findClosingBracket(str, b) {
@@ -324,10 +300,6 @@ function checkSanitizeDeprecation(opt) {
 }
 
 // copied from https://stackoverflow.com/a/5450113/806777
-/**
- * @param {string} pattern
- * @param {number} count
- */
 function repeatString(pattern, count) {
   if (count < 1) {
     return '';
@@ -356,18 +328,19 @@ function outputLink(cap, link, raw, lexer) {
       href,
       title,
       text,
-      tokens: lexer.inlineTokens(text)
+      tokens: lexer.inlineTokens(text, [])
     };
     lexer.state.inLink = false;
     return token;
+  } else {
+    return {
+      type: 'image',
+      raw,
+      href,
+      title,
+      text: escape(text)
+    };
   }
-  return {
-    type: 'image',
-    raw,
-    href,
-    title,
-    text: escape(text)
-  };
 }
 
 function indentCodeCompensation(raw, text) {
@@ -462,13 +435,15 @@ class Tokenizer {
         }
       }
 
-      return {
+      const token = {
         type: 'heading',
         raw: cap[0],
         depth: cap[1].length,
-        text,
-        tokens: this.lexer.inline(text)
+        text: text,
+        tokens: []
       };
+      this.lexer.inline(token.text, token.tokens);
+      return token;
     }
   }
 
@@ -485,7 +460,7 @@ class Tokenizer {
   blockquote(src) {
     const cap = this.rules.block.blockquote.exec(src);
     if (cap) {
-      const text = cap[0].replace(/^ *>[ \t]?/gm, '');
+      const text = cap[0].replace(/^ *> ?/gm, '');
 
       return {
         type: 'blockquote',
@@ -521,7 +496,7 @@ class Tokenizer {
       }
 
       // Get next list item
-      const itemRegex = new RegExp(`^( {0,3}${bull})((?:[\t ][^\\n]*)?(?:\\n|$))`);
+      const itemRegex = new RegExp(`^( {0,3}${bull})((?: [^\\n]*)?(?:\\n|$))`);
 
       // Check if current bullet point can start a new List Item
       while (src) {
@@ -559,10 +534,7 @@ class Tokenizer {
         }
 
         if (!endEarly) {
-          const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])((?: [^\\n]*)?(?:\\n|$))`);
-          const hrRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}((?:- *){3,}|(?:_ *){3,}|(?:\\* *){3,})(?:\\n+|$)`);
-          const fencesBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:\`\`\`|~~~)`);
-          const headingBeginRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}#`);
+          const nextBulletRegex = new RegExp(`^ {0,${Math.min(3, indent - 1)}}(?:[*+-]|\\d{1,9}[.)])`);
 
           // Check if following lines should be included in List Item
           while (src) {
@@ -574,26 +546,11 @@ class Tokenizer {
               line = line.replace(/^ {1,4}(?=( {4})*[^ ])/g, '  ');
             }
 
-            // End list item if found code fences
-            if (fencesBeginRegex.test(line)) {
-              break;
-            }
-
-            // End list item if found start of new heading
-            if (headingBeginRegex.test(line)) {
-              break;
-            }
-
             // End list item if found start of new bullet
             if (nextBulletRegex.test(line)) {
               break;
             }
 
-            // Horizontal rule found
-            if (hrRegex.test(src)) {
-              break;
-            }
-
             if (line.search(/[^ ]/) >= indent || !line.trim()) { // Dedent if possible
               itemContents += '\n' + line.slice(indent);
             } else if (!blankLine) { // Until blank line, item doesn't need indentation
@@ -631,7 +588,7 @@ class Tokenizer {
 
         list.items.push({
           type: 'list_item',
-          raw,
+          raw: raw,
           task: !!istask,
           checked: ischecked,
           loose: false,
@@ -690,10 +647,10 @@ class Tokenizer {
         text: cap[0]
       };
       if (this.options.sanitize) {
-        const text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
         token.type = 'paragraph';
-        token.text = text;
-        token.tokens = this.lexer.inline(text);
+        token.text = this.options.sanitizer ? this.options.sanitizer(cap[0]) : escape(cap[0]);
+        token.tokens = [];
+        this.lexer.inline(token.text, token.tokens);
       }
       return token;
     }
@@ -751,7 +708,8 @@ class Tokenizer {
         // header child tokens
         l = item.header.length;
         for (j = 0; j < l; j++) {
-          item.header[j].tokens = this.lexer.inline(item.header[j].text);
+          item.header[j].tokens = [];
+          this.lexer.inlineTokens(item.header[j].text, item.header[j].tokens);
         }
 
         // cell child tokens
@@ -759,7 +717,8 @@ class Tokenizer {
         for (j = 0; j < l; j++) {
           row = item.rows[j];
           for (k = 0; k < row.length; k++) {
-            row[k].tokens = this.lexer.inline(row[k].text);
+            row[k].tokens = [];
+            this.lexer.inlineTokens(row[k].text, row[k].tokens);
           }
         }
 
@@ -771,40 +730,45 @@ class Tokenizer {
   lheading(src) {
     const cap = this.rules.block.lheading.exec(src);
     if (cap) {
-      return {
+      const token = {
         type: 'heading',
         raw: cap[0],
         depth: cap[2].charAt(0) === '=' ? 1 : 2,
         text: cap[1],
-        tokens: this.lexer.inline(cap[1])
+        tokens: []
       };
+      this.lexer.inline(token.text, token.tokens);
+      return token;
     }
   }
 
   paragraph(src) {
     const cap = this.rules.block.paragraph.exec(src);
     if (cap) {
-      const text = cap[1].charAt(cap[1].length - 1) === '\n'
-        ? cap[1].slice(0, -1)
-        : cap[1];
-      return {
+      const token = {
         type: 'paragraph',
         raw: cap[0],
-        text,
-        tokens: this.lexer.inline(text)
+        text: cap[1].charAt(cap[1].length - 1) === '\n'
+          ? cap[1].slice(0, -1)
+          : cap[1],
+        tokens: []
       };
+      this.lexer.inline(token.text, token.tokens);
+      return token;
     }
   }
 
   text(src) {
     const cap = this.rules.block.text.exec(src);
     if (cap) {
-      return {
+      const token = {
         type: 'text',
         raw: cap[0],
         text: cap[0],
-        tokens: this.lexer.inline(cap[0])
+        tokens: []
       };
+      this.lexer.inline(token.text, token.tokens);
+      return token;
     }
   }
 
@@ -973,7 +937,7 @@ class Tokenizer {
             type: 'em',
             raw: src.slice(0, lLength + match.index + rLength + 1),
             text,
-            tokens: this.lexer.inlineTokens(text)
+            tokens: this.lexer.inlineTokens(text, [])
           };
         }
 
@@ -983,7 +947,7 @@ class Tokenizer {
           type: 'strong',
           raw: src.slice(0, lLength + match.index + rLength + 1),
           text,
-          tokens: this.lexer.inlineTokens(text)
+          tokens: this.lexer.inlineTokens(text, [])
         };
       }
     }
@@ -1024,7 +988,7 @@ class Tokenizer {
         type: 'del',
         raw: cap[0],
         text: cap[2],
-        tokens: this.lexer.inlineTokens(cap[2])
+        tokens: this.lexer.inlineTokens(cap[2], [])
       };
     }
   }
@@ -1119,10 +1083,10 @@ const block = {
   newline: /^(?: *(?:\n|$))+/,
   code: /^( {4}[^\n]+(?:\n(?: *(?:\n|$))*)?)+/,
   fences: /^ {0,3}(`{3,}(?=[^`\n]*\n)|~{3,})([^\n]*)\n(?:|([\s\S]*?)\n)(?: {0,3}\1[~`]* *(?=\n|$)|$)/,
-  hr: /^ {0,3}((?:-[\t ]*){3,}|(?:_[ \t]*){3,}|(?:\*[ \t]*){3,})(?:\n+|$)/,
+  hr: /^ {0,3}((?:- *){3,}|(?:_ *){3,}|(?:\* *){3,})(?:\n+|$)/,
   heading: /^ {0,3}(#{1,6})(?=\s|$)(.*)(?:\n+|$)/,
   blockquote: /^( {0,3}> ?(paragraph|[^\n]*)(?:\n|$))+/,
-  list: /^( {0,3}bull)([ \t][^\n]+?)?(?:\n|$)/,
+  list: /^( {0,3}bull)( [^\n]+?)?(?:\n|$)/,
   html: '^ {0,3}(?:' // optional indentation
     + '<(script|pre|style|textarea)[\\s>][\\s\\S]*?(?:</\\1>[^\\n]*\\n+|$)' // (1)
     + '|comment[^\\n]*(\\n+|$)' // (2)
@@ -1276,9 +1240,9 @@ const inline = {
   emStrong: {
     lDelim: /^(?:\*+(?:([punct_])|[^\s*]))|^_+(?:([punct*])|([^\s_]))/,
     //        (1) and (2) can only be a Right Delimiter. (3) and (4) can only be Left.  (5) and (6) can be either Left or Right.
-    //          () Skip orphan inside strong  () Consume to delim (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
-    rDelimAst: /^[^_*]*?\_\_[^_*]*?\*[^_*]*?(?=\_\_)|[^*]+(?=[^*])|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
-    rDelimUnd: /^[^_*]*?\*\*[^_*]*?\_[^_*]*?(?=\*\*)|[^_]+(?=[^_])|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
+    //        () Skip orphan delim inside strong    (1) #***                (2) a***#, a***                   (3) #***a, ***a                 (4) ***#              (5) #***#                 (6) a***a
+    rDelimAst: /^[^_*]*?\_\_[^_*]*?\*[^_*]*?(?=\_\_)|[punct_](\*+)(?=[\s]|$)|[^punct*_\s](\*+)(?=[punct_\s]|$)|[punct_\s](\*+)(?=[^punct*_\s])|[\s](\*+)(?=[punct_])|[punct_](\*+)(?=[punct_])|[^punct*_\s](\*+)(?=[^punct*_\s])/,
+    rDelimUnd: /^[^_*]*?\*\*[^_*]*?\_[^_*]*?(?=\*\*)|[punct*](\_+)(?=[\s]|$)|[^punct*_\s](\_+)(?=[punct*\s]|$)|[punct*\s](\_+)(?=[^punct*_\s])|[\s](\_+)(?=[punct*])|[punct*](\_+)(?=[punct*])/ // ^- Not allowed for _
   },
   code: /^(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/,
   br: /^( {2,}|\\)\n(?!\s*$)/,
@@ -1411,7 +1375,6 @@ inline.breaks = merge({}, inline.gfm, {
 
 /**
  * smartypants text replacement
- * @param {string} text
  */
 function smartypants(text) {
   return text
@@ -1433,7 +1396,6 @@ function smartypants(text) {
 
 /**
  * mangle email addresses
- * @param {string} text
  */
 function mangle(text) {
   let out = '',
@@ -1521,7 +1483,8 @@ class Lexer {
    */
   lex(src) {
     src = src
-      .replace(/\r\n|\r/g, '\n');
+      .replace(/\r\n|\r/g, '\n')
+      .replace(/\t/g, '    ');
 
     this.blockTokens(src, this.tokens);
 
@@ -1538,13 +1501,8 @@ class Lexer {
    */
   blockTokens(src, tokens = []) {
     if (this.options.pedantic) {
-      src = src.replace(/\t/g, '    ').replace(/^ +$/gm, '');
-    } else {
-      src = src.replace(/^( *)(\t+)/gm, (_, leading, tabs) => {
-        return leading + '    '.repeat(tabs.length);
-      });
+      src = src.replace(/^ +$/gm, '');
     }
-
     let token, lastToken, cutSrc, lastParagraphClipped;
 
     while (src) {
@@ -1722,9 +1680,8 @@ class Lexer {
     return tokens;
   }
 
-  inline(src, tokens = []) {
+  inline(src, tokens) {
     this.inlineQueue.push({ src, tokens });
-    return tokens;
   }
 
   /**
@@ -1941,31 +1898,29 @@ class Renderer {
       + '</code></pre>\n';
   }
 
-  /**
-   * @param {string} quote
-   */
   blockquote(quote) {
-    return `<blockquote>\n${quote}</blockquote>\n`;
+    return '<blockquote>\n' + quote + '</blockquote>\n';
   }
 
   html(html) {
     return html;
   }
 
-  /**
-   * @param {string} text
-   * @param {string} level
-   * @param {string} raw
-   * @param {any} slugger
-   */
   heading(text, level, raw, slugger) {
     if (this.options.headerIds) {
-      const id = this.options.headerPrefix + slugger.slug(raw);
-      return `<h${level} id="${id}">${text}</h${level}>\n`;
+      return '<h'
+        + level
+        + ' id="'
+        + this.options.headerPrefix
+        + slugger.slug(raw)
+        + '">'
+        + text
+        + '</h'
+        + level
+        + '>\n';
     }
-
     // ignore IDs
-    return `<h${level}>${text}</h${level}>\n`;
+    return '<h' + level + '>' + text + '</h' + level + '>\n';
   }
 
   hr() {
@@ -1978,11 +1933,8 @@ class Renderer {
     return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
   }
 
-  /**
-   * @param {string} text
-   */
   listitem(text) {
-    return `<li>${text}</li>\n`;
+    return '<li>' + text + '</li>\n';
   }
 
   checkbox(checked) {
@@ -1993,19 +1945,12 @@ class Renderer {
       + '> ';
   }
 
-  /**
-   * @param {string} text
-   */
   paragraph(text) {
-    return `<p>${text}</p>\n`;
+    return '<p>' + text + '</p>\n';
   }
 
-  /**
-   * @param {string} header
-   * @param {string} body
-   */
   table(header, body) {
-    if (body) body = `<tbody>${body}</tbody>`;
+    if (body) body = '<tbody>' + body + '</tbody>';
 
     return '<table>\n'
       + '<thead>\n'
@@ -2015,59 +1960,39 @@ class Renderer {
       + '</table>\n';
   }
 
-  /**
-   * @param {string} content
-   */
   tablerow(content) {
-    return `<tr>\n${content}</tr>\n`;
+    return '<tr>\n' + content + '</tr>\n';
   }
 
   tablecell(content, flags) {
     const type = flags.header ? 'th' : 'td';
     const tag = flags.align
-      ? `<${type} align="${flags.align}">`
-      : `<${type}>`;
-    return tag + content + `</${type}>\n`;
+      ? '<' + type + ' align="' + flags.align + '">'
+      : '<' + type + '>';
+    return tag + content + '</' + type + '>\n';
   }
 
-  /**
-   * span level renderer
-   * @param {string} text
-   */
+  // span level renderer
   strong(text) {
-    return `<strong>${text}</strong>`;
+    return '<strong>' + text + '</strong>';
   }
 
-  /**
-   * @param {string} text
-   */
   em(text) {
-    return `<em>${text}</em>`;
+    return '<em>' + text + '</em>';
   }
 
-  /**
-   * @param {string} text
-   */
   codespan(text) {
-    return `<code>${text}</code>`;
+    return '<code>' + text + '</code>';
   }
 
   br() {
     return this.options.xhtml ? '<br/>' : '<br>';
   }
 
-  /**
-   * @param {string} text
-   */
   del(text) {
-    return `<del>${text}</del>`;
+    return '<del>' + text + '</del>';
   }
 
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
   link(href, title, text) {
     href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
     if (href === null) {
@@ -2081,20 +2006,15 @@ class Renderer {
     return out;
   }
 
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
   image(href, title, text) {
     href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
     if (href === null) {
       return text;
     }
 
-    let out = `<img src="${href}" alt="${text}"`;
+    let out = '<img src="' + href + '" alt="' + text + '"';
     if (title) {
-      out += ` title="${title}"`;
+      out += ' title="' + title + '"';
     }
     out += this.options.xhtml ? '/>' : '>';
     return out;
@@ -2156,9 +2076,6 @@ class Slugger {
     this.seen = {};
   }
 
-  /**
-   * @param {string} value
-   */
   serialize(value) {
     return value
       .toLowerCase()
@@ -2172,8 +2089,6 @@ class Slugger {
 
   /**
    * Finds the next safe (unique) slug to use
-   * @param {string} originalSlug
-   * @param {boolean} isDryRun
    */
   getNextSafeSlug(originalSlug, isDryRun) {
     let slug = originalSlug;
@@ -2194,9 +2109,8 @@ class Slugger {
 
   /**
    * Convert string to unique id
-   * @param {object} [options]
-   * @param {boolean} [options.dryrun] Generates the next unique slug without
-   * updating the internal accumulator.
+   * @param {object} options
+   * @param {boolean} options.dryrun Generates the next unique slug without updating the internal accumulator.
    */
   slug(value, options = {}) {
     const slug = this.serialize(value);
@@ -2573,31 +2487,20 @@ function marked(src, opt, callback) {
     return;
   }
 
-  function onError(e) {
-    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
-    if (opt.silent) {
-      return '<p>An error occurred:</p><pre>'
-        + escape(e.message + '', true)
-        + '</pre>';
-    }
-    throw e;
-  }
-
   try {
     const tokens = Lexer.lex(src, opt);
     if (opt.walkTokens) {
-      if (opt.async) {
-        return Promise.all(marked.walkTokens(tokens, opt.walkTokens))
-          .then(() => {
-            return Parser.parse(tokens, opt);
-          })
-          .catch(onError);
-      }
       marked.walkTokens(tokens, opt.walkTokens);
     }
     return Parser.parse(tokens, opt);
   } catch (e) {
-    onError(e);
+    e.message += '\nPlease report this to https://github.com/markedjs/marked.';
+    if (opt.silent) {
+      return '<p>An error occurred:</p><pre>'
+        + escape(e.message + '', true)
+        + '</pre>';
+    }
+    throw e;
   }
 }
 
@@ -2715,12 +2618,10 @@ marked.use = function(...args) {
     if (pack.walkTokens) {
       const walkTokens = marked.defaults.walkTokens;
       opts.walkTokens = function(token) {
-        let values = [];
-        values.push(pack.walkTokens.call(this, token));
+        pack.walkTokens.call(this, token);
         if (walkTokens) {
-          values = values.concat(walkTokens.call(this, token));
+          walkTokens.call(this, token);
         }
-        return values;
       };
     }
 
@@ -2737,42 +2638,39 @@ marked.use = function(...args) {
  */
 
 marked.walkTokens = function(tokens, callback) {
-  let values = [];
   for (const token of tokens) {
-    values = values.concat(callback.call(marked, token));
+    callback.call(marked, token);
     switch (token.type) {
       case 'table': {
         for (const cell of token.header) {
-          values = values.concat(marked.walkTokens(cell.tokens, callback));
+          marked.walkTokens(cell.tokens, callback);
         }
         for (const row of token.rows) {
           for (const cell of row) {
-            values = values.concat(marked.walkTokens(cell.tokens, callback));
+            marked.walkTokens(cell.tokens, callback);
           }
         }
         break;
       }
       case 'list': {
-        values = values.concat(marked.walkTokens(token.items, callback));
+        marked.walkTokens(token.items, callback);
         break;
       }
       default: {
         if (marked.defaults.extensions && marked.defaults.extensions.childTokens && marked.defaults.extensions.childTokens[token.type]) { // Walk any extensions
           marked.defaults.extensions.childTokens[token.type].forEach(function(childTokens) {
-            values = values.concat(marked.walkTokens(token[childTokens], callback));
+            marked.walkTokens(token[childTokens], callback);
           });
         } else if (token.tokens) {
-          values = values.concat(marked.walkTokens(token.tokens, callback));
+          marked.walkTokens(token.tokens, callback);
         }
       }
     }
   }
-  return values;
 };
 
 /**
  * Parse Inline
- * @param {string} src
  */
 marked.parseInline = function(src, opt) {
   // throw error in case of non string input

package/dist/4aa58bb7a66bb44975aa.png

@@ -0,0 +1 @@
+module.exports = __webpack_public_path__ + "assets/img/emoji/messenger/sub_25.490_45.098.3dfbc08.png";

package/dist/56ce063bc6c81adb7322.png

@@ -0,0 +1 @@
+module.exports = __webpack_public_path__ + "assets/img/emoji/messenger/sub_60.784_27.451.46b54e5.png";