marked 7.0.1 → 7.0.2

package/lib/marked.umd.js

@@ -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
  */
@@ -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++) {
@@ -1412,7 +1412,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 +2265,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 +2345,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 +2362,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 +2380,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);
                                 }