fix: noImplicitAny: true (#2891)

lib/marked.cjs

@@ -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);
                             }

lib/marked.d.ts

@@ -1,5 +1,5 @@
 declare module "Tokens" {
-    export type Token = (Tokens.Space | Tokens.Code | Tokens.Heading | Tokens.Table | Tokens.Hr | Tokens.Blockquote | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.HTML | Tokens.Text | Tokens.Def | Tokens.Escape | Tokens.Tag | Tokens.Image | Tokens.Link | Tokens.Strong | Tokens.Em | Tokens.Codespan | Tokens.Br | Tokens.Del) & {
+    export type Token = (Tokens.Space | Tokens.Code | Tokens.Heading | Tokens.Table | Tokens.Hr | Tokens.Blockquote | Tokens.List | Tokens.ListItem | Tokens.Paragraph | Tokens.HTML | Tokens.Text | Tokens.Def | Tokens.Escape | Tokens.Tag | Tokens.Image | Tokens.Link | Tokens.Strong | Tokens.Em | Tokens.Codespan | Tokens.Br | Tokens.Del | Tokens.Generic) & {
         loose?: boolean;
         tokens?: Token[];
     };
@@ -25,7 +25,7 @@ declare module "Tokens" {
         }
         interface Table {
             type: 'table';
-            raw?: string;
+            raw: string;
             align: Array<'center' | 'left' | 'right' | null>;
             header: TableCell[];
             rows: TableCell[][];
@@ -156,7 +156,7 @@ declare module "Tokens" {
     };
 }
 declare module "Tokenizer" {
-    import { _Lexer } from "Lexer";
+    import type { _Lexer } from "Lexer";
     import type { Links, Tokens } from "Tokens";
     import type { MarkedOptions } from "MarkedOptions";
     /**
@@ -309,7 +309,7 @@ declare module "Instance" {
     export class Marked {
         #private;
         defaults: MarkedOptions;
-        options: (opt: any) => this;
+        options: (opt: MarkedOptions) => this;
         parse: (src: string, optOrCallback?: MarkedOptions | ResultCallback | undefined | null, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
         parseInline: (src: string, optOrCallback?: MarkedOptions | ResultCallback | undefined | null, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
         Parser: typeof _Parser;
@@ -327,7 +327,7 @@ declare module "Instance" {
          */
         walkTokens<T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]): T[];
         use(...args: MarkedExtension[]): this;
-        setOptions(opt: any): this;
+        setOptions(opt: MarkedOptions): this;
     }
 }
 declare module "helpers" {
@@ -345,7 +345,7 @@ declare module "helpers" {
     export const noopTest: {
         exec: () => null;
     };
-    export function splitCells(tableRow: string, count: number): string[];
+    export function splitCells(tableRow: string, count?: number): string[];
     /**
      * Remove trailing 'c's. Equivalent to str.replace(/c*$/, '').
      * /c*$/ is vulnerable to REDOS.
@@ -358,101 +358,9 @@ declare module "helpers" {
     export function findClosingBracket(str: string, b: string): number;
     export function checkDeprecations(opt: MarkedOptions, callback?: ResultCallback): void;
 }
-declare module "marked" {
-    import { _Lexer } from "Lexer";
-    import { _Parser } from "Parser";
-    import { _Tokenizer } from "Tokenizer";
-    import { _Renderer } from "Renderer";
-    import { _TextRenderer } from "TextRenderer";
-    import { _Slugger } from "Slugger";
-    import { _Hooks } from "Hooks";
-    import { _getDefaults } from "defaults";
-    import type { MarkedExtension, MarkedOptions } from "MarkedOptions";
-    import type { Token, TokensList } from "Tokens";
-    import type { ResultCallback } from "Instance";
-    /**
-     * Compiles markdown to HTML asynchronously.
-     *
-     * @param src String of markdown source to be compiled
-     * @param options Hash of options, having async: true
-     * @return Promise of string of compiled HTML
-     */
-    export function marked(src: string, options: MarkedOptions & {
-        async: true;
-    }): Promise<string>;
-    /**
-     * Compiles markdown to HTML synchronously.
-     *
-     * @param src String of markdown source to be compiled
-     * @param options Optional hash of options
-     * @return String of compiled HTML
-     */
-    export function marked(src: string, options?: MarkedOptions): string;
-    /**
-     * Compiles markdown to HTML asynchronously with a callback.
-     *
-     * @param src String of markdown source to be compiled
-     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
-     */
-    export function marked(src: string, callback: ResultCallback): void;
-    /**
-     * Compiles markdown to HTML asynchronously with a callback.
-     *
-     * @param src String of markdown source to be compiled
-     * @param options Hash of options
-     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
-     */
-    export function marked(src: string, options: MarkedOptions, callback: ResultCallback): void;
-    /**
-     * Compiles markdown to HTML asynchronously with a callback.
-     *
-     * @param src String of markdown source to be compiled
-     * @param options Hash of options
-     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
-     */
-    export namespace marked {
-        var options: (options: MarkedOptions) => typeof marked;
-        var setOptions: (options: MarkedOptions) => typeof marked;
-        var getDefaults: typeof _getDefaults;
-        var defaults: MarkedOptions;
-        var use: (...args: MarkedExtension[]) => typeof marked;
-        var walkTokens: <T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]) => T[];
-        var parseInline: (src: string, optOrCallback?: MarkedOptions | ResultCallback | null | undefined, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
-        var Parser: typeof _Parser;
-        var parser: typeof _Parser.parse;
-        var Renderer: typeof _Renderer;
-        var TextRenderer: typeof _TextRenderer;
-        var Lexer: typeof _Lexer;
-        var lexer: typeof _Lexer.lex;
-        var Tokenizer: typeof _Tokenizer;
-        var Slugger: typeof _Slugger;
-        var Hooks: typeof _Hooks;
-        var parse: typeof marked;
-    }
-    export const options: (options: MarkedOptions) => typeof marked;
-    export const setOptions: (options: MarkedOptions) => typeof marked;
-    export const use: (...args: MarkedExtension[]) => typeof marked;
-    export const walkTokens: <T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]) => T[];
-    export const parseInline: (src: string, optOrCallback?: MarkedOptions | ResultCallback | null | undefined, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
-    export const parse: typeof marked;
-    export const parser: typeof _Parser.parse;
-    export const lexer: typeof _Lexer.lex;
-    export { _defaults as defaults, _getDefaults as getDefaults } from "defaults";
-    export { _Lexer as Lexer } from "Lexer";
-    export { _Parser as Parser } from "Parser";
-    export { _Tokenizer as Tokenizer } from "Tokenizer";
-    export { _Renderer as Renderer } from "Renderer";
-    export { _TextRenderer as TextRenderer } from "TextRenderer";
-    export { _Slugger as Slugger } from "Slugger";
-    export { _Hooks as Hooks } from "Hooks";
-    export { Marked } from "Instance";
-    export type * from "MarkedOptions";
-    export type * from "rules";
-    export type * from "Tokens";
-}
 declare module "Renderer" {
     import type { MarkedOptions } from "MarkedOptions";
-    import { Slugger } from "marked";
+    import type { _Slugger } from "Slugger";
     /**
      * Renderer
      */
@@ -462,7 +370,7 @@ declare module "Renderer" {
         code(code: string, infostring: string | undefined, escaped: boolean): string;
         blockquote(quote: string): string;
         html(html: string, block?: boolean): string;
-        heading(text: string, level: number, raw: string, slugger: Slugger): string;
+        heading(text: string, level: number, raw: string, slugger: _Slugger): string;
         hr(): string;
         list(body: string, ordered: boolean, start: number | ''): string;
         listitem(text: string, task: boolean, checked: boolean): string;
@@ -522,10 +430,10 @@ declare module "Parser" {
 }
 declare module "MarkedOptions" {
     import type { Token, Tokens, TokensList } from "Tokens";
-    import { _Parser } from "Parser";
-    import { _Lexer } from "Lexer";
-    import { _Renderer } from "Renderer";
-    import { _Tokenizer } from "Tokenizer";
+    import type { _Parser } from "Parser";
+    import type { _Lexer } from "Lexer";
+    import type { _Renderer } from "Renderer";
+    import type { _Tokenizer } from "Tokenizer";
     export interface SluggerOptions {
         /** Generates the next unique slug without updating the internal accumulator. */
         dryrun?: boolean;
@@ -537,15 +445,16 @@ declare module "MarkedOptions" {
         name: string;
         level: 'block' | 'inline';
         start?: ((this: TokenizerThis, src: string) => number | void) | undefined;
-        tokenizer: (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | void;
+        tokenizer: (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | undefined;
         childTokens?: string[] | undefined;
     }
     export interface RendererThis {
         parser: _Parser;
     }
+    export type RendererExtensionFunction = (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
     export interface RendererExtension {
         name: string;
-        renderer: (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
+        renderer: RendererExtensionFunction;
     }
     export type TokenizerAndRendererExtension = TokenizerExtension | RendererExtension | (TokenizerExtension & RendererExtension);
     type RendererApi = Omit<_Renderer, 'constructor' | 'options'>;
@@ -602,8 +511,8 @@ declare module "MarkedOptions" {
          * postprocess is called to process html after marked has finished parsing.
          */
         hooks?: {
-            preprocess: (markdown: string) => string;
-            postprocess: (html: string | undefined) => string | undefined;
+            preprocess: (markdown: string) => string | Promise<string>;
+            postprocess: (html: string) => string | Promise<string>;
             options?: MarkedOptions;
         } | null;
         /**
@@ -688,7 +597,7 @@ declare module "MarkedOptions" {
          * Add tokenizers and renderers to marked
          */
         extensions?: (TokenizerAndRendererExtension[] & {
-            renderers: Record<string, (this: RendererThis, token: Tokens.Generic) => string | false | undefined>;
+            renderers: Record<string, RendererExtensionFunction>;
             childTokens: Record<string, string[]>;
             block: any[];
             inline: any[];
@@ -719,6 +628,98 @@ declare module "Hooks" {
         /**
          * Process HTML after marked is finished
          */
-        postprocess(html: string | undefined): string | undefined;
+        postprocess(html: string): string;
     }
 }
+declare module "marked" {
+    import { _Lexer } from "Lexer";
+    import { _Parser } from "Parser";
+    import { _Tokenizer } from "Tokenizer";
+    import { _Renderer } from "Renderer";
+    import { _TextRenderer } from "TextRenderer";
+    import { _Slugger } from "Slugger";
+    import { _Hooks } from "Hooks";
+    import { _getDefaults } from "defaults";
+    import type { MarkedExtension, MarkedOptions } from "MarkedOptions";
+    import type { Token, TokensList } from "Tokens";
+    import type { ResultCallback } from "Instance";
+    /**
+     * Compiles markdown to HTML asynchronously.
+     *
+     * @param src String of markdown source to be compiled
+     * @param options Hash of options, having async: true
+     * @return Promise of string of compiled HTML
+     */
+    export function marked(src: string, options: MarkedOptions & {
+        async: true;
+    }): Promise<string>;
+    /**
+     * Compiles markdown to HTML synchronously.
+     *
+     * @param src String of markdown source to be compiled
+     * @param options Optional hash of options
+     * @return String of compiled HTML
+     */
+    export function marked(src: string, options?: MarkedOptions): string;
+    /**
+     * Compiles markdown to HTML asynchronously with a callback.
+     *
+     * @param src String of markdown source to be compiled
+     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
+     */
+    export function marked(src: string, callback: ResultCallback): void;
+    /**
+     * Compiles markdown to HTML asynchronously with a callback.
+     *
+     * @param src String of markdown source to be compiled
+     * @param options Hash of options
+     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
+     */
+    export function marked(src: string, options: MarkedOptions, callback: ResultCallback): void;
+    /**
+     * Compiles markdown to HTML asynchronously with a callback.
+     *
+     * @param src String of markdown source to be compiled
+     * @param options Hash of options
+     * @param callback Function called when the markdownString has been fully parsed when using async highlighting
+     */
+    export namespace marked {
+        var options: (options: MarkedOptions) => typeof marked;
+        var setOptions: (options: MarkedOptions) => typeof marked;
+        var getDefaults: typeof _getDefaults;
+        var defaults: MarkedOptions;
+        var use: (...args: MarkedExtension[]) => typeof marked;
+        var walkTokens: <T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]) => T[];
+        var parseInline: (src: string, optOrCallback?: MarkedOptions | ResultCallback | null | undefined, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
+        var Parser: typeof _Parser;
+        var parser: typeof _Parser.parse;
+        var Renderer: typeof _Renderer;
+        var TextRenderer: typeof _TextRenderer;
+        var Lexer: typeof _Lexer;
+        var lexer: typeof _Lexer.lex;
+        var Tokenizer: typeof _Tokenizer;
+        var Slugger: typeof _Slugger;
+        var Hooks: typeof _Hooks;
+        var parse: typeof marked;
+    }
+    export const options: (options: MarkedOptions) => typeof marked;
+    export const setOptions: (options: MarkedOptions) => typeof marked;
+    export const use: (...args: MarkedExtension[]) => typeof marked;
+    export const walkTokens: <T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]) => T[];
+    export const parseInline: (src: string, optOrCallback?: MarkedOptions | ResultCallback | null | undefined, callback?: ResultCallback | undefined) => string | Promise<string | undefined> | undefined;
+    export const parse: typeof marked;
+    export const parser: typeof _Parser.parse;
+    export const lexer: typeof _Lexer.lex;
+    export { _defaults as defaults, _getDefaults as getDefaults } from "defaults";
+    export { _Lexer as Lexer } from "Lexer";
+    export { _Parser as Parser } from "Parser";
+    export { _Tokenizer as Tokenizer } from "Tokenizer";
+    export { _Renderer as Renderer } from "Renderer";
+    export { _TextRenderer as TextRenderer } from "TextRenderer";
+    export { _Slugger as Slugger } from "Slugger";
+    export { _Hooks as Hooks } from "Hooks";
+    export { Marked } from "Instance";
+    export type * from "MarkedOptions";
+    export type * from "rules";
+    export type * from "Tokens";
+}

lib/marked.esm.js

@@ -189,12 +189,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
@@ -627,8 +629,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 };
                 }),
@@ -636,7 +637,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++) {
@@ -1406,7 +1406,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
@@ -2256,6 +2259,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));
                         });
                     }
@@ -2335,14 +2339,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;
@@ -2350,10 +2356,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);
                         }
@@ -2366,21 +2374,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);
                             }

lib/marked.umd.js

@@ -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);
                                 }

package-lock.json

@@ -10490,9 +10490,9 @@
       }
     },
     "node_modules/tslib": {
-      "version": "1.14.1",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
-      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.1.tgz",
+      "integrity": "sha512-t0hLfiEKfMUoqhG+U1oid7Pva4bbDPHYfJNiB7BiIjRkj1pyC++4N3huJfqY6aRH6VTB0rvtzQwjM4K6qpfOig==",
       "dev": true,
       "optional": true,
       "peer": true

package.json

@@ -89,7 +89,7 @@
     "bench": "npm run build && node test/bench.js",
     "lint": "eslint --fix .",
     "build:reset": "git checkout upstream/master lib/marked.cjs lib/marked.umd.js lib/marked.esm.js marked.min.js",
-    "build": "npm run rollup && npm run minify",
+    "build": "npm run rollup && npm run minify && npm run build:types",
     "build:docs": "node build-docs.js",
     "build:types": "tsc --project tsconfig-types.json",
     "rollup": "rollup -c rollup.config.js",

src/Hooks.ts

@@ -23,7 +23,7 @@ export class _Hooks {
   /**
    * Process HTML after marked is finished
    */
-  postprocess(html: string | undefined) {
+  postprocess(html: string) {
     return html;
   }
 }

src/Instance.ts

@@ -1,4 +1,4 @@
-import { _getDefaults } from './defaults.js';
+import { _getDefaults } from './defaults.ts';
 import { _Lexer } from './Lexer.ts';
 import { _Parser } from './Parser.ts';
 import { _Hooks } from './Hooks.ts';
@@ -15,6 +15,9 @@ import type { Token, TokensList } from './Tokens.ts';
 
 export type ResultCallback = (error: Error | null, parseResult?: string) => undefined | void;
 
+type UnknownFunction = (...args: unknown[]) => unknown;
+type GenericRendererFunction = (...args: unknown[]) => string | false;
+
 export class Marked {
   defaults = _getDefaults();
   options = this.setOptions;
@@ -62,6 +65,7 @@ export 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));
             });
           } else if (token.tokens) {
@@ -140,14 +144,16 @@ export 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 as keyof MarkedExtension['renderer']] as GenericRendererFunction;
+          const rendererKey = prop as keyof _Renderer;
+          const prevRenderer = renderer[rendererKey] as GenericRendererFunction;
           // Replace renderer with func to run extension, but fall back if false
-          renderer[prop] = (...args: unknown[]) => {
-            let ret = pack.renderer![prop].apply(renderer, args);
+          renderer[rendererKey] = (...args: unknown[]) => {
+            let ret = rendererFunc.apply(renderer, args);
             if (ret === false) {
               ret = prevRenderer.apply(renderer, args);
             }
-            return ret;
+            return ret || '';
           };
         }
         opts.renderer = renderer;
@@ -155,10 +161,12 @@ export 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 as keyof MarkedExtension['tokenizer']] as UnknownFunction;
+          const tokenizerKey = prop as keyof _Tokenizer;
+          const prevTokenizer = tokenizer[tokenizerKey] as UnknownFunction;
           // Replace tokenizer with func to run extension, but fall back if false
-          tokenizer[prop] = (...args: unknown[]) => {
-            let ret = pack.tokenizer![prop].apply(tokenizer, args);
+          tokenizer[tokenizerKey] = (...args: unknown[]) => {
+            let ret = tokenizerFunc.apply(tokenizer, args);
             if (ret === false) {
               ret = prevTokenizer.apply(tokenizer, args);
             }
@@ -172,25 +180,27 @@ export 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 as keyof MarkedExtension['hooks']] as UnknownFunction;
+          const hooksKey = prop as keyof _Hooks;
+          const prevHook = hooks[hooksKey] as UnknownFunction;
           if (_Hooks.passThroughHooks.has(prop)) {
-            hooks[prop as 'preprocess' | 'postprocess'] = (arg: string | undefined) => {
+            hooks[hooksKey as 'preprocess' | 'postprocess'] = (arg: string | undefined) => {
               if (this.defaults.async) {
-                return Promise.resolve(pack.hooks![prop].call(hooks, arg)).then(ret => {
-                  return prevHook.call(hooks, ret);
+                return Promise.resolve(hooksFunc.call(hooks, arg)).then(ret => {
+                  return prevHook.call(hooks, ret) as string;
                 });
               }
 
-              const ret = pack.hooks![prop].call(hooks, arg);
-              return prevHook.call(hooks, ret);
+              const ret = hooksFunc.call(hooks, arg);
+              return prevHook.call(hooks, ret) as string;
             };
           } else {
-            hooks[prop] = (...args) => {
-              let ret = pack.hooks![prop].apply(hooks, args);
+            hooks[hooksKey] = (...args: unknown[]) => {
+              let ret = hooksFunc.apply(hooks, args);
               if (ret === false) {
                 ret = prevHook.apply(hooks, args);
               }
-              return ret;
+              return ret as string;
             };
           }
         }
@@ -216,12 +226,12 @@ export class Marked {
     return this;
   }
 
-  setOptions(opt) {
+  setOptions(opt: MarkedOptions) {
     this.defaults = { ...this.defaults, ...opt };
     return this;
   }
 
-  #parseMarkdown(lexer: (src: string, options?: MarkedOptions) => TokensList | Token[], parser: (tokens: Token[], options?: MarkedOptions) => string | undefined) {
+  #parseMarkdown(lexer: (src: string, options?: MarkedOptions) => TokensList | Token[], parser: (tokens: Token[], options?: MarkedOptions) => string) {
     return (src: string, optOrCallback?: MarkedOptions | ResultCallback | undefined | null, callback?: ResultCallback | undefined): string | Promise<string | undefined> | undefined => {
       if (typeof optOrCallback === 'function') {
         callback = optOrCallback;
@@ -253,7 +263,7 @@ export class Marked {
 
         try {
           if (opt.hooks) {
-            src = opt.hooks.preprocess(src);
+            src = opt.hooks.preprocess(src) as string;
           }
           tokens = lexer(src, opt);
         } catch (e) {
@@ -270,7 +280,7 @@ export class Marked {
               }
               out = parser(tokens, opt)!;
               if (opt.hooks) {
-                out = opt.hooks.postprocess(out);
+                out = opt.hooks.postprocess(out) as string;
               }
             } catch (e) {
               err = e as Error;
@@ -333,7 +343,7 @@ export class Marked {
 
       try {
         if (opt.hooks) {
-          src = opt.hooks.preprocess(src);
+          src = opt.hooks.preprocess(src) as string;
         }
         const tokens = lexer(src, opt);
         if (opt.walkTokens) {
@@ -341,7 +351,7 @@ export class Marked {
         }
         let html = parser(tokens, opt);
         if (opt.hooks) {
-          html = opt.hooks.postprocess(html);
+          html = opt.hooks.postprocess(html) as string;
         }
         return html;
       } catch (e) {

src/Lexer.ts

@@ -1,7 +1,7 @@
 import { _Tokenizer } from './Tokenizer.ts';
 import { _defaults } from './defaults.ts';
 import { block, inline } from './rules.ts';
-import type { Token, TokensList } from './Tokens.ts';
+import type { Token, TokensList, Tokens } from './Tokens.ts';
 import type { MarkedOptions, TokenizerExtension } from './MarkedOptions.ts';
 import type { Rules } from './rules.ts';
 
@@ -154,7 +154,10 @@ export class _Lexer {
       });
     }
 
-    let token, lastToken, cutSrc, lastParagraphClipped;
+    let token: Tokens.Generic | undefined;
+    let lastToken;
+    let cutSrc;
+    let lastParagraphClipped;
 
     while (src) {
       if (this.options.extensions

src/MarkedOptions.ts

@@ -17,7 +17,7 @@ export interface TokenizerExtension {
   name: string;
   level: 'block' | 'inline';
   start?: ((this: TokenizerThis, src: string) => number | void) | undefined;
-  tokenizer: (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | void;
+  tokenizer: (this: TokenizerThis, src: string, tokens: Token[] | TokensList) => Tokens.Generic | undefined;
   childTokens?: string[] | undefined;
 }
 
@@ -25,9 +25,11 @@ export interface RendererThis {
   parser: _Parser;
 }
 
+export type RendererExtensionFunction = (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
+
 export interface RendererExtension {
   name: string;
-  renderer: (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
+  renderer: RendererExtensionFunction;
 }
 
 export type TokenizerAndRendererExtension = TokenizerExtension | RendererExtension | (TokenizerExtension & RendererExtension);
@@ -98,8 +100,8 @@ export interface MarkedExtension {
    * postprocess is called to process html after marked has finished parsing.
    */
   hooks?: {
-    preprocess: (markdown: string) => string,
-    postprocess: (html: string | undefined) => string | undefined,
+    preprocess: (markdown: string) => string | Promise<string>,
+    postprocess: (html: string) => string | Promise<string>,
     // eslint-disable-next-line no-use-before-define
     options?: MarkedOptions
   } | null;
@@ -201,7 +203,7 @@ export interface MarkedOptions extends Omit<MarkedExtension, 'extensions' | 'ren
    */
   extensions?:
     | (TokenizerAndRendererExtension[] & {
-    renderers: Record<string, (this: RendererThis, token: Tokens.Generic) => string | false | undefined>,
+    renderers: Record<string, RendererExtensionFunction>,
     childTokens: Record<string, string[]>,
     block: any[],
     inline: any[],

src/Parser.ts

@@ -89,9 +89,9 @@ export class _Parser {
         }
         case 'heading': {
           out += this.renderer.heading(
-            this.parseInline(token.tokens) as string,
+            this.parseInline(token.tokens!),
             token.depth,
-            unescape(this.parseInline(token.tokens, this.textRenderer) as string),
+            unescape(this.parseInline(token.tokens!, this.textRenderer)),
             this.slugger);
           continue;
         }
@@ -135,7 +135,7 @@ export class _Parser {
           continue;
         }
         case 'blockquote': {
-          body = this.parse(token.tokens)!;
+          body = this.parse(token.tokens!);
           out += this.renderer.blockquote(body);
           continue;
         }
@@ -183,13 +183,13 @@ export class _Parser {
           continue;
         }
         case 'paragraph': {
-          out += this.renderer.paragraph(this.parseInline(token.tokens)!);
+          out += this.renderer.paragraph(this.parseInline(token.tokens!)!);
           continue;
         }
         case 'text': {
           body = token.tokens ? this.parseInline(token.tokens) : token.text;
           while (i + 1 < l && tokens[i + 1].type === 'text') {
-            token = tokens[++i];
+            token = tokens[++i] as Tokens.Text;
             body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
           }
           out += top ? this.renderer.paragraph(body!) : body;
@@ -244,7 +244,7 @@ export class _Parser {
           break;
         }
         case 'link': {
-          out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer)!);
+          out += renderer.link(token.href, token.title, this.parseInline(token.tokens!, renderer)!);
           break;
         }
         case 'image': {
@@ -252,11 +252,11 @@ export class _Parser {
           break;
         }
         case 'strong': {
-          out += renderer.strong(this.parseInline(token.tokens, renderer)!);
+          out += renderer.strong(this.parseInline(token.tokens!, renderer)!);
           break;
         }
         case 'em': {
-          out += renderer.em(this.parseInline(token.tokens, renderer)!);
+          out += renderer.em(this.parseInline(token.tokens!, renderer)!);
           break;
         }
         case 'codespan': {
@@ -268,7 +268,7 @@ export class _Parser {
           break;
         }
         case 'del': {
-          out += renderer.del(this.parseInline(token.tokens, renderer)!);
+          out += renderer.del(this.parseInline(token.tokens!, renderer)!);
           break;
         }
         case 'text': {

src/Tokenizer.ts

@@ -407,8 +407,7 @@ export class _Tokenizer {
     if (cap) {
       const item: Tokens.Table = {
         type: 'table',
-        // splitCells expects a number as second argument
-        // @ts-expect-error
+        raw: cap[0],
         header: splitCells(cap[1]).map(c => {
           return { text: c };
         }),
@@ -417,8 +416,6 @@ export class _Tokenizer {
       };
 
       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++) {

src/Tokens.ts

@@ -19,7 +19,8 @@ export type Token = (Tokens.Space
     | Tokens.Em
     | Tokens.Codespan
     | Tokens.Br
-    | Tokens.Del) & { loose?: boolean, tokens?: Token[] };
+    | Tokens.Del
+    | Tokens.Generic) & { loose?: boolean, tokens?: Token[] };
 
 export namespace Tokens {
     export interface Space {
@@ -46,7 +47,7 @@ export namespace Tokens {
 
     export interface Table {
         type: 'table';
-        raw?: string;
+        raw: string;
         align: Array<'center' | 'left' | 'right' | null>;
         header: TableCell[];
         rows: TableCell[][];

src/helpers.ts

@@ -9,7 +9,7 @@ const escapeTest = /[&<>"']/;
 const escapeReplace = new RegExp(escapeTest.source, 'g');
 const escapeTestNoEncode = /[<>"']|&(?!(#\d{1,7}|#[Xx][a-fA-F0-9]{1,6}|\w+);)/;
 const escapeReplaceNoEncode = new RegExp(escapeTestNoEncode.source, 'g');
-const escapeReplacements = {
+const escapeReplacements: {[index: string]: string} = {
   '&': '&amp;',
   '<': '&lt;',
   '>': '&gt;',
@@ -131,7 +131,7 @@ export function resolveUrl(base: string, href: string) {
 
 export const noopTest = { exec: () => null };
 
-export function splitCells(tableRow: string, count: number) {
+export function splitCells(tableRow: string, count?: number) {
   // ensure that every cell-delimiting pipe has a space
   // before it to distinguish it from an escaped pipe
   const row = tableRow.replace(/\|/g, (match, offset, str) => {
@@ -158,10 +158,12 @@ export function splitCells(tableRow: string, count: number) {
     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++) {

test/types/marked.ts

@@ -186,7 +186,7 @@ marked.use({
   }
 });
 
-interface NameToken {
+interface NameToken extends Tokens.Generic {
     type: 'name';
     raw: string;
     text: string;
@@ -198,7 +198,7 @@ const tokenizerExtension: TokenizerExtension = {
   name: 'name',
   level: 'block',
   start: (src: string) => src.match(/name/)?.index,
-  tokenizer(src: string): NameToken | void {
+  tokenizer(src: string): NameToken | undefined {
     if (src === 'name') {
       const token: NameToken = {
         type: 'name',

tsconfig-type-test.json

@@ -8,7 +8,6 @@
     "noEmit": true,
     "allowSyntheticDefaultImports": true,
     "moduleResolution": "NodeNext",
-    "noImplicitAny": false,
     "baseUrl": ".",
     "paths": {
       "marked": [

tsconfig-types.json

@@ -7,7 +7,6 @@
     "emitDeclarationOnly": true,
     "allowSyntheticDefaultImports": true,
     "moduleResolution": "NodeNext",
-    "noImplicitAny": false,
     "allowImportingTsExtensions": true,
     "outFile": "lib/marked.d.ts"
   },

tsconfig.json

@@ -8,7 +8,6 @@
     "noEmit": true,
     "allowSyntheticDefaultImports": true,
     "moduleResolution": "NodeNext",
-    "noImplicitAny": false,
     "allowImportingTsExtensions": true,
     "sourceMap": false
   },