marked 7.0.1 → 7.0.2

package/lib/marked.cjs

@@ -1,5 +1,5 @@
 /**
- * marked v7.0.1 - a markdown parser
+ * marked v7.0.2 - a markdown parser
  * Copyright (c) 2011-2023, Christopher Jeffrey. (MIT Licensed)
  * https://github.com/markedjs/marked
  */
@@ -191,12 +191,14 @@ function splitCells(tableRow, count) {
     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
@@ -629,8 +631,7 @@ class _Tokenizer {
         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 };
                 }),
@@ -638,7 +639,6 @@ class _Tokenizer {
                 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++) {
@@ -1408,7 +1408,10 @@ class _Lexer {
                 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
@@ -2258,6 +2261,7 @@ class Marked {
                 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));
                         });
                     }
@@ -2337,14 +2341,16 @@ class Marked {
             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;
@@ -2352,10 +2358,12 @@ class Marked {
             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);
                         }
@@ -2368,21 +2376,23 @@ class Marked {
             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);
                             }