marked 7.0.1 → 7.0.3

package/lib/marked.umd.js

@@ -1,5 +1,5 @@
 /**
- * marked v7.0.1 - a markdown parser
+ * marked v7.0.3 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -195,12 +195,14 @@
         if (cells.length > 0 && !cells[cells.length - 1].trim()) {
             cells.pop();
         }
-        if (cells.length > count) {
-            cells.splice(count);
-        }
-        else {
-            while (cells.length < count)
-                cells.push('');
+        if (count) {
+            if (cells.length > count) {
+                cells.splice(count);
+            }
+            else {
+                while (cells.length < count)
+                    cells.push('');
+            }
         }
         for (; i < cells.length; i++) {
             // leading or trailing whitespace is ignored per the gfm spec
@@ -633,8 +635,7 @@
             if (cap) {
                 const item = {
                     type: 'table',
-                    // splitCells expects a number as second argument
-                    // @ts-expect-error
+                    raw: cap[0],
                     header: splitCells(cap[1]).map(c => {
                         return { text: c };
                     }),
@@ -642,7 +643,6 @@
                     rows: cap[3] && cap[3].trim() ? cap[3].replace(/\n[ \t]*$/, '').split('\n') : []
                 };
                 if (item.header.length === item.align.length) {
-                    item.raw = cap[0];
                     let l = item.align.length;
                     let i, j, k, row;
                     for (i = 0; i < l; i++) {
@@ -842,7 +842,8 @@
                 return;
             const nextChar = match[1] || match[2] || '';
             if (!nextChar || !prevChar || this.rules.inline.punctuation.exec(prevChar)) {
-                const lLength = match[0].length - 1;
+                // unicode Regex counts emoji as 1 char; spread into array for proper count (used multiple times below)
+                const lLength = [...match[0]].length - 1;
                 let rDelim, rLength, delimTotal = lLength, midDelimTotal = 0;
                 const endReg = match[0][0] === '*' ? this.rules.inline.emStrong.rDelimAst : this.rules.inline.emStrong.rDelimUnd;
                 endReg.lastIndex = 0;
@@ -852,7 +853,7 @@
                     rDelim = match[1] || match[2] || match[3] || match[4] || match[5] || match[6];
                     if (!rDelim)
                         continue; // skip single * in __abc*abc__
-                    rLength = rDelim.length;
+                    rLength = [...rDelim].length;
                     if (match[3] || match[4]) { // found another Left Delim
                         delimTotal += rLength;
                         continue;
@@ -868,7 +869,7 @@
                         continue; // Haven't found enough closing delimiters
                     // Remove extra characters. *a*** -> *a*
                     rLength = Math.min(rLength, rLength + delimTotal + midDelimTotal);
-                    const raw = src.slice(0, lLength + match.index + rLength + 1);
+                    const raw = [...src].slice(0, lLength + match.index + rLength + 1).join('');
                     // Create `em` if smallest delimiter has odd char count. *a***
                     if (Math.min(lLength, rLength) % 2) {
                         const text = raw.slice(1, -1);
@@ -1412,7 +1413,10 @@
                     return leading + '    '.repeat(tabs.length);
                 });
             }
-            let token, lastToken, cutSrc, lastParagraphClipped;
+            let token;
+            let lastToken;
+            let cutSrc;
+            let lastParagraphClipped;
             while (src) {
                 if (this.options.extensions
                     && this.options.extensions.block
@@ -2262,6 +2266,7 @@
                     default: {
                         if (this.defaults.extensions && this.defaults.extensions.childTokens && this.defaults.extensions.childTokens[token.type]) { // Walk any extensions
                             this.defaults.extensions.childTokens[token.type].forEach((childTokens) => {
+                                // @ts-expect-error we assume token[childToken] is an array of tokens but we can't be sure
                                 values = values.concat(this.walkTokens(token[childTokens], callback));
                             });
                         }
@@ -2341,14 +2346,16 @@
                 if (pack.renderer) {
                     const renderer = this.defaults.renderer || new _Renderer(this.defaults);
                     for (const prop in pack.renderer) {
-                        const prevRenderer = renderer[prop];
+                        const rendererFunc = pack.renderer[prop];
+                        const rendererKey = prop;
+                        const prevRenderer = renderer[rendererKey];
                         // Replace renderer with func to run extension, but fall back if false
-                        renderer[prop] = (...args) => {
-                            let ret = pack.renderer[prop].apply(renderer, args);
+                        renderer[rendererKey] = (...args) => {
+                            let ret = rendererFunc.apply(renderer, args);
                             if (ret === false) {
                                 ret = prevRenderer.apply(renderer, args);
                             }
-                            return ret;
+                            return ret || '';
                         };
                     }
                     opts.renderer = renderer;
@@ -2356,10 +2363,12 @@
                 if (pack.tokenizer) {
                     const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
                     for (const prop in pack.tokenizer) {
-                        const prevTokenizer = tokenizer[prop];
+                        const tokenizerFunc = pack.tokenizer[prop];
+                        const tokenizerKey = prop;
+                        const prevTokenizer = tokenizer[tokenizerKey];
                         // Replace tokenizer with func to run extension, but fall back if false
-                        tokenizer[prop] = (...args) => {
-                            let ret = pack.tokenizer[prop].apply(tokenizer, args);
+                        tokenizer[tokenizerKey] = (...args) => {
+                            let ret = tokenizerFunc.apply(tokenizer, args);
                             if (ret === false) {
                                 ret = prevTokenizer.apply(tokenizer, args);
                             }
@@ -2372,21 +2381,23 @@
                 if (pack.hooks) {
                     const hooks = this.defaults.hooks || new _Hooks();
                     for (const prop in pack.hooks) {
-                        const prevHook = hooks[prop];
+                        const hooksFunc = pack.hooks[prop];
+                        const hooksKey = prop;
+                        const prevHook = hooks[hooksKey];
                         if (_Hooks.passThroughHooks.has(prop)) {
-                            hooks[prop] = (arg) => {
+                            hooks[hooksKey] = (arg) => {
                                 if (this.defaults.async) {
-                                    return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
+                                    return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {
                                         return prevHook.call(hooks, ret);
                                     });
                                 }
-                                const ret = pack.hooks[prop].call(hooks, arg);
+                                const ret = hooksFunc.call(hooks, arg);
                                 return prevHook.call(hooks, ret);
                             };
                         }
                         else {
-                            hooks[prop] = (...args) => {
-                                let ret = pack.hooks[prop].apply(hooks, args);
+                            hooks[hooksKey] = (...args) => {
+                                let ret = hooksFunc.apply(hooks, args);
                                 if (ret === false) {
                                     ret = prevHook.apply(hooks, args);
                                 }