marked 5.1.2 → 7.0.0

package/src/{Instance.js → Instance.ts}

@@ -1,49 +1,56 @@
-import { getDefaults } from './defaults.js';
-import { Lexer } from './Lexer.js';
-import { Parser } from './Parser.js';
-import { Hooks } from './Hooks.js';
-import { Renderer } from './Renderer.js';
-import { Tokenizer } from './Tokenizer.js';
-import { TextRenderer } from './TextRenderer.js';
-import { Slugger } from './Slugger.js';
+import { _getDefaults } from './defaults.js';
+import { _Lexer } from './Lexer.ts';
+import { _Parser } from './Parser.ts';
+import { _Hooks } from './Hooks.ts';
+import { _Renderer } from './Renderer.ts';
+import { _Tokenizer } from './Tokenizer.ts';
+import { _TextRenderer } from './TextRenderer.ts';
+import { _Slugger } from './Slugger.ts';
 import {
   checkDeprecations,
   escape
-} from './helpers.js';
+} from './helpers.ts';
+import type { MarkedExtension, MarkedOptions } from './MarkedOptions.ts';
+import type { Token, TokensList } from './Tokens.ts';
+
+export type ResultCallback = (error: Error | null, parseResult?: string) => undefined | void;
 
 export class Marked {
-  defaults = getDefaults();
+  defaults = _getDefaults();
   options = this.setOptions;
 
-  parse = this.#parseMarkdown(Lexer.lex, Parser.parse);
-  parseInline = this.#parseMarkdown(Lexer.lexInline, Parser.parseInline);
+  parse = this.#parseMarkdown(_Lexer.lex, _Parser.parse);
+  parseInline = this.#parseMarkdown(_Lexer.lexInline, _Parser.parseInline);
 
-  Parser = Parser;
-  parser = Parser.parse;
-  Renderer = Renderer;
-  TextRenderer = TextRenderer;
-  Lexer = Lexer;
-  lexer = Lexer.lex;
-  Tokenizer = Tokenizer;
-  Slugger = Slugger;
-  Hooks = Hooks;
+  Parser = _Parser;
+  parser = _Parser.parse;
+  Renderer = _Renderer;
+  TextRenderer = _TextRenderer;
+  Lexer = _Lexer;
+  lexer = _Lexer.lex;
+  Tokenizer = _Tokenizer;
+  Slugger = _Slugger;
+  Hooks = _Hooks;
 
-  constructor(...args) {
+  constructor(...args: MarkedExtension[]) {
     this.use(...args);
   }
 
-  walkTokens(tokens, callback) {
-    let values = [];
+  /**
+   * Run callback for every token
+   */
+  walkTokens <T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]) {
+    let values: T[] = [];
     for (const token of tokens) {
       values = values.concat(callback.call(this, token));
       switch (token.type) {
         case 'table': {
           for (const cell of token.header) {
-            values = values.concat(this.walkTokens(cell.tokens, callback));
+            values = values.concat(this.walkTokens(cell.tokens!, callback));
           }
           for (const row of token.rows) {
             for (const cell of row) {
-              values = values.concat(this.walkTokens(cell.tokens, callback));
+              values = values.concat(this.walkTokens(cell.tokens!, callback));
             }
           }
           break;
@@ -66,12 +73,12 @@ export class Marked {
     return values;
   }
 
-  use(...args) {
-    const extensions = this.defaults.extensions || { renderers: {}, childTokens: {} };
+  use(...args: MarkedExtension[]) {
+    const extensions: NonNullable<MarkedOptions['extensions']> = this.defaults.extensions || { renderers: {}, childTokens: {} } as NonNullable<MarkedOptions['extensions']>;
 
     args.forEach((pack) => {
       // copy options to new object
-      const opts = { ...pack };
+      const opts = { ...pack } as MarkedOptions;
 
       // set async to true if it was set to true before
       opts.async = this.defaults.async || opts.async || false;
@@ -82,7 +89,7 @@ export class Marked {
           if (!ext.name) {
             throw new Error('extension name required');
           }
-          if (ext.renderer) { // Renderer extensions
+          if ('renderer' in ext) { // Renderer extensions
             const prevRenderer = extensions.renderers[ext.name];
             if (prevRenderer) {
               // Replace extension with func to run new extension but fall back if false
@@ -97,7 +104,7 @@ export class Marked {
               extensions.renderers[ext.name] = ext.renderer;
             }
           }
-          if (ext.tokenizer) { // Tokenizer Extensions
+          if ('tokenizer' in ext) { // Tokenizer Extensions
             if (!ext.level || (ext.level !== 'block' && ext.level !== 'inline')) {
               throw new Error("extension level must be 'block' or 'inline'");
             }
@@ -109,20 +116,20 @@ export class Marked {
             if (ext.start) { // Function to check for start of token
               if (ext.level === 'block') {
                 if (extensions.startBlock) {
-                  extensions.startBlock.push(ext.start);
+                  extensions.startBlock.push(ext.start!);
                 } else {
-                  extensions.startBlock = [ext.start];
+                  extensions.startBlock = [ext.start!];
                 }
               } else if (ext.level === 'inline') {
                 if (extensions.startInline) {
-                  extensions.startInline.push(ext.start);
+                  extensions.startInline.push(ext.start!);
                 } else {
-                  extensions.startInline = [ext.start];
+                  extensions.startInline = [ext.start!];
                 }
               }
             }
           }
-          if (ext.childTokens) { // Child tokens to be visited by walkTokens
+          if ('childTokens' in ext && ext.childTokens) { // Child tokens to be visited by walkTokens
             extensions.childTokens[ext.name] = ext.childTokens;
           }
         });
@@ -131,12 +138,12 @@ export class Marked {
 
       // ==-- Parse "overwrite" extensions --== //
       if (pack.renderer) {
-        const renderer = this.defaults.renderer || new Renderer(this.defaults);
+        const renderer = this.defaults.renderer || new _Renderer(this.defaults);
         for (const prop in pack.renderer) {
           const prevRenderer = renderer[prop];
           // Replace renderer with func to run extension, but fall back if false
-          renderer[prop] = (...args) => {
-            let ret = pack.renderer[prop].apply(renderer, args);
+          renderer[prop] = (...args: unknown[]) => {
+            let ret = pack.renderer![prop].apply(renderer, args);
             if (ret === false) {
               ret = prevRenderer.apply(renderer, args);
             }
@@ -146,12 +153,12 @@ export class Marked {
         opts.renderer = renderer;
       }
       if (pack.tokenizer) {
-        const tokenizer = this.defaults.tokenizer || new Tokenizer(this.defaults);
+        const tokenizer = this.defaults.tokenizer || new _Tokenizer(this.defaults);
         for (const prop in pack.tokenizer) {
           const prevTokenizer = tokenizer[prop];
           // Replace tokenizer with func to run extension, but fall back if false
-          tokenizer[prop] = (...args) => {
-            let ret = pack.tokenizer[prop].apply(tokenizer, args);
+          tokenizer[prop] = (...args: unknown[]) => {
+            let ret = pack.tokenizer![prop].apply(tokenizer, args);
             if (ret === false) {
               ret = prevTokenizer.apply(tokenizer, args);
             }
@@ -163,23 +170,23 @@ export class Marked {
 
       // ==-- Parse Hooks extensions --== //
       if (pack.hooks) {
-        const hooks = this.defaults.hooks || new Hooks();
+        const hooks = this.defaults.hooks || new _Hooks();
         for (const prop in pack.hooks) {
           const prevHook = hooks[prop];
-          if (Hooks.passThroughHooks.has(prop)) {
-            hooks[prop] = (arg) => {
+          if (_Hooks.passThroughHooks.has(prop)) {
+            hooks[prop as 'preprocess' | 'postprocess'] = (arg: string | undefined) => {
               if (this.defaults.async) {
-                return Promise.resolve(pack.hooks[prop].call(hooks, arg)).then(ret => {
+                return Promise.resolve(pack.hooks![prop].call(hooks, arg)).then(ret => {
                   return prevHook.call(hooks, ret);
                 });
               }
 
-              const ret = pack.hooks[prop].call(hooks, arg);
+              const ret = pack.hooks![prop].call(hooks, arg);
               return prevHook.call(hooks, ret);
             };
           } else {
             hooks[prop] = (...args) => {
-              let ret = pack.hooks[prop].apply(hooks, args);
+              let ret = pack.hooks![prop].apply(hooks, args);
               if (ret === false) {
                 ret = prevHook.apply(hooks, args);
               }
@@ -194,8 +201,8 @@ export class Marked {
       if (pack.walkTokens) {
         const walkTokens = this.defaults.walkTokens;
         opts.walkTokens = function(token) {
-          let values = [];
-          values.push(pack.walkTokens.call(this, token));
+          let values: Array<Promise<void> | void> = [];
+          values.push(pack.walkTokens!.call(this, token));
           if (walkTokens) {
             values = values.concat(walkTokens.call(this, token));
           }
@@ -214,16 +221,16 @@ export class Marked {
     return this;
   }
 
-  #parseMarkdown(lexer, parser) {
-    return (src, opt, callback) => {
-      if (typeof opt === 'function') {
-        callback = opt;
-        opt = null;
+  #parseMarkdown(lexer: (src: string, options?: MarkedOptions) => TokensList | Token[], parser: (tokens: Token[], options?: MarkedOptions) => string | undefined) {
+    return (src: string, optOrCallback?: MarkedOptions | ResultCallback | undefined | null, callback?: ResultCallback | undefined): string | Promise<string | undefined> | undefined => {
+      if (typeof optOrCallback === 'function') {
+        callback = optOrCallback;
+        optOrCallback = null;
       }
 
-      const origOpt = { ...opt };
-      opt = { ...this.defaults, ...origOpt };
-      const throwError = this.#onError(opt.silent, opt.async, callback);
+      const origOpt = { ...optOrCallback };
+      const opt = { ...this.defaults, ...origOpt };
+      const throwError = this.#onError(!!opt.silent, !!opt.async, callback);
 
       // throw error in case of non string input
       if (typeof src === 'undefined' || src === null) {
@@ -242,7 +249,7 @@ export class Marked {
 
       if (callback) {
         const highlight = opt.highlight;
-        let tokens;
+        let tokens: TokensList | Token[];
 
         try {
           if (opt.hooks) {
@@ -250,10 +257,10 @@ export class Marked {
           }
           tokens = lexer(src, opt);
         } catch (e) {
-          return throwError(e);
+          return throwError(e as Error);
         }
 
-        const done = (err) => {
+        const done = (err?: Error) => {
           let out;
 
           if (!err) {
@@ -261,12 +268,12 @@ export class Marked {
               if (opt.walkTokens) {
                 this.walkTokens(tokens, opt.walkTokens);
               }
-              out = parser(tokens, opt);
+              out = parser(tokens, opt)!;
               if (opt.hooks) {
                 out = opt.hooks.postprocess(out);
               }
             } catch (e) {
-              err = e;
+              err = e as Error;
             }
           }
 
@@ -274,7 +281,7 @@ export class Marked {
 
           return err
             ? throwError(err)
-            : callback(null, out);
+            : callback!(null, out) as undefined;
         };
 
         if (!highlight || highlight.length < 3) {
@@ -338,13 +345,13 @@ export class Marked {
         }
         return html;
       } catch (e) {
-        return throwError(e);
+        return throwError(e as Error);
       }
     };
   }
 
-  #onError(silent, async, callback) {
-    return (e) => {
+  #onError(silent: boolean, async: boolean, callback?: ResultCallback) {
+    return (e: Error): string | Promise<string> | undefined => {
       e.message += '\nPlease report this to https://github.com/markedjs/marked.';
 
       if (silent) {

package/src/{Lexer.js → Lexer.ts}

@@ -1,12 +1,14 @@
-import { Tokenizer } from './Tokenizer.js';
-import { defaults } from './defaults.js';
-import { block, inline } from './rules.js';
+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 { MarkedOptions, TokenizerExtension } from './MarkedOptions.ts';
+import type { Rules } from './rules.ts';
 
 /**
  * smartypants text replacement
- * @param {string} text
  */
-function smartypants(text) {
+function smartypants(text: string) {
   return text
     // em-dashes
     .replace(/---/g, '\u2014')
@@ -26,9 +28,8 @@ function smartypants(text) {
 
 /**
  * mangle email addresses
- * @param {string} text
  */
-function mangle(text) {
+function mangle(text: string) {
   let out = '',
     i,
     ch;
@@ -48,12 +49,25 @@ function mangle(text) {
 /**
  * Block Lexer
  */
-export class Lexer {
-  constructor(options) {
+export class _Lexer {
+  tokens: TokensList;
+  options: MarkedOptions;
+  state: {
+    inLink: boolean;
+    inRawBlock: boolean;
+    top: boolean;
+  };
+
+  private tokenizer: _Tokenizer;
+  private inlineQueue: {src: string, tokens: Token[]}[];
+
+  constructor(options?: MarkedOptions) {
+    // TokenList cannot be created in one go
+    // @ts-expect-error
     this.tokens = [];
     this.tokens.links = Object.create(null);
-    this.options = options || defaults;
-    this.options.tokenizer = this.options.tokenizer || new Tokenizer();
+    this.options = options || _defaults;
+    this.options.tokenizer = this.options.tokenizer || new _Tokenizer();
     this.tokenizer = this.options.tokenizer;
     this.tokenizer.options = this.options;
     this.tokenizer.lexer = this;
@@ -86,7 +100,7 @@ export class Lexer {
   /**
    * Expose Rules
    */
-  static get rules() {
+  static get rules(): Rules {
     return {
       block,
       inline
@@ -96,23 +110,23 @@ export class Lexer {
   /**
    * Static Lex Method
    */
-  static lex(src, options) {
-    const lexer = new Lexer(options);
+  static lex(src: string, options?: MarkedOptions) {
+    const lexer = new _Lexer(options);
     return lexer.lex(src);
   }
 
   /**
    * Static Lex Inline Method
    */
-  static lexInline(src, options) {
-    const lexer = new Lexer(options);
+  static lexInline(src: string, options?: MarkedOptions) {
+    const lexer = new _Lexer(options);
     return lexer.inlineTokens(src);
   }
 
   /**
    * Preprocessing
    */
-  lex(src) {
+  lex(src: string) {
     src = src
       .replace(/\r\n|\r/g, '\n');
 
@@ -129,7 +143,9 @@ export class Lexer {
   /**
    * Lexing
    */
-  blockTokens(src, tokens = []) {
+  blockTokens(src: string, tokens?: Token[]): Token[];
+  blockTokens(src: string, tokens?: TokensList): TokensList;
+  blockTokens(src: string, tokens: Token[] = []) {
     if (this.options.pedantic) {
       src = src.replace(/\t/g, '    ').replace(/^ +$/gm, '');
     } else {
@@ -143,7 +159,7 @@ export class Lexer {
     while (src) {
       if (this.options.extensions
         && this.options.extensions.block
-        && this.options.extensions.block.some((extTokenizer) => {
+        && this.options.extensions.block.some((extTokenizer: TokenizerExtension['tokenizer']) => {
           if (token = extTokenizer.call({ lexer: this }, src, tokens)) {
             src = src.substring(token.raw.length);
             tokens.push(token);
@@ -262,7 +278,7 @@ export class Lexer {
         let startIndex = Infinity;
         const tempSrc = src.slice(1);
         let tempStart;
-        this.options.extensions.startBlock.forEach(function(getStartIndex) {
+        this.options.extensions.startBlock.forEach((getStartIndex) => {
           tempStart = getStartIndex.call({ lexer: this }, tempSrc);
           if (typeof tempStart === 'number' && tempStart >= 0) { startIndex = Math.min(startIndex, tempStart); }
         });
@@ -315,7 +331,7 @@ export class Lexer {
     return tokens;
   }
 
-  inline(src, tokens = []) {
+  inline(src: string, tokens: Token[] = []) {
     this.inlineQueue.push({ src, tokens });
     return tokens;
   }
@@ -323,7 +339,7 @@ export class Lexer {
   /**
    * Lexing/Compiling
    */
-  inlineTokens(src, tokens = []) {
+  inlineTokens(src: string, tokens: Token[] = []): Token[] {
     let token, lastToken, cutSrc;
 
     // String with links masked to avoid interference with em and strong
@@ -461,7 +477,7 @@ export class Lexer {
         let startIndex = Infinity;
         const tempSrc = src.slice(1);
         let tempStart;
-        this.options.extensions.startInline.forEach(function(getStartIndex) {
+        this.options.extensions.startInline.forEach((getStartIndex) => {
           tempStart = getStartIndex.call({ lexer: this }, tempSrc);
           if (typeof tempStart === 'number' && tempStart >= 0) { startIndex = Math.min(startIndex, tempStart); }
         });

package/src/MarkedOptions.ts

@@ -0,0 +1,212 @@
+import type { Token, Tokens, TokensList } from './Tokens.ts';
+import { _Parser } from './Parser.ts';
+import { _Lexer } from './Lexer.ts';
+import { _Renderer } from './Renderer.ts';
+import { _Tokenizer } from './Tokenizer.ts';
+
+export interface SluggerOptions {
+  /** Generates the next unique slug without updating the internal accumulator. */
+  dryrun?: boolean;
+}
+
+export interface TokenizerThis {
+  lexer: _Lexer;
+}
+
+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;
+  childTokens?: string[] | undefined;
+}
+
+export interface RendererThis {
+  parser: _Parser;
+}
+
+export interface RendererExtension {
+  name: string;
+  renderer: (this: RendererThis, token: Tokens.Generic) => string | false | undefined;
+}
+
+export type TokenizerAndRendererExtension = TokenizerExtension | RendererExtension | (TokenizerExtension & RendererExtension);
+
+type RendererApi = Omit<_Renderer, 'constructor' | 'options'>;
+type RendererObject = {
+  [K in keyof RendererApi]?: (...args: Parameters<RendererApi[K]>) => ReturnType<RendererApi[K]> | false
+};
+
+type TokenizerApi = Omit<_Tokenizer, 'constructor' | 'options' | 'rules' | 'lexer'>;
+type TokenizerObject = {
+  [K in keyof TokenizerApi]?: (...args: Parameters<TokenizerApi[K]>) => ReturnType<TokenizerApi[K]> | false
+};
+
+export interface MarkedExtension {
+  /**
+   * True will tell marked to await any walkTokens functions before parsing the tokens and returning an HTML string.
+   */
+  async?: boolean;
+
+  /**
+   * A prefix URL for any relative link.
+   * @deprecated Deprecated in v5.0.0 use marked-base-url to prefix url for any relative link.
+   */
+  baseUrl?: string | undefined | null;
+
+  /**
+   * Enable GFM line breaks. This option requires the gfm option to be true.
+   */
+  breaks?: boolean | undefined;
+
+  /**
+   * Add tokenizers and renderers to marked
+   */
+  extensions?:
+    | TokenizerAndRendererExtension[]
+    | undefined | null;
+
+  /**
+   * Enable GitHub flavored markdown.
+   */
+  gfm?: boolean | undefined;
+
+  /**
+   * Include an id attribute when emitting headings.
+   * @deprecated Deprecated in v5.0.0 use marked-gfm-heading-id to include an id attribute when emitting headings (h1, h2, h3, etc).
+   */
+  headerIds?: boolean | undefined;
+
+  /**
+   * Set the prefix for header tag ids.
+   * @deprecated Deprecated in v5.0.0 use marked-gfm-heading-id to add a string to prefix the id attribute when emitting headings (h1, h2, h3, etc).
+   */
+  headerPrefix?: string | undefined;
+
+  /**
+   * A function to highlight code blocks. The function can either be
+   * synchronous (returning a string) or asynchronous (callback invoked
+   * with an error if any occurred during highlighting and a string
+   * if highlighting was successful)
+   * @deprecated Deprecated in v5.0.0 use marked-highlight to add highlighting to code blocks.
+   */
+  highlight?: ((code: string, lang: string | undefined, callback?: (error: Error, code?: string) => void) => string | void) | null;
+
+  /**
+   * Hooks are methods that hook into some part of marked.
+   * preprocess is called to process markdown before sending it to marked.
+   * postprocess is called to process html after marked has finished parsing.
+   */
+  hooks?: {
+    preprocess: (markdown: string) => string,
+    postprocess: (html: string | undefined) => string | undefined,
+    // eslint-disable-next-line no-use-before-define
+    options?: MarkedOptions
+  } | null;
+
+  /**
+   * Set the prefix for code block classes.
+   * @deprecated Deprecated in v5.0.0 use marked-highlight to prefix the className in a <code> block. Useful for syntax highlighting.
+   */
+  langPrefix?: string | undefined;
+
+  /**
+   * Mangle autolinks (<email@domain.com>).
+   * @deprecated Deprecated in v5.0.0 use marked-mangle to mangle email addresses.
+   */
+  mangle?: boolean | undefined;
+
+  /**
+   * Conform to obscure parts of markdown.pl as much as possible. Don't fix any of the original markdown bugs or poor behavior.
+   */
+  pedantic?: boolean | undefined;
+
+  /**
+   * Type: object Default: new Renderer()
+   *
+   * An object containing functions to render tokens to HTML.
+   */
+  renderer?: RendererObject | undefined | null;
+
+  /**
+   * Sanitize the output. Ignore any HTML that has been input. If true, sanitize the HTML passed into markdownString with the sanitizer function.
+   * @deprecated Warning: This feature is deprecated and it should NOT be used as it cannot be considered secure. Instead use a sanitize library, like DOMPurify (recommended), sanitize-html or insane on the output HTML!
+   */
+  sanitize?: boolean | undefined;
+
+  /**
+   * Optionally sanitize found HTML with a sanitizer function.
+   * @deprecated A function to sanitize the HTML passed into markdownString.
+   */
+  sanitizer?: ((html: string) => string) | null;
+
+  /**
+   * Shows an HTML error message when rendering fails.
+   */
+  silent?: boolean | undefined;
+
+  /**
+   * Use smarter list behavior than the original markdown. May eventually be default with the old behavior moved into pedantic.
+   */
+  smartLists?: boolean | undefined;
+
+  /**
+   * Use "smart" typograhic punctuation for things like quotes and dashes.
+   * @deprecated Deprecated in v5.0.0 use marked-smartypants to use "smart" typographic punctuation for things like quotes and dashes.
+   */
+  smartypants?: boolean | undefined;
+
+  /**
+   * The tokenizer defines how to turn markdown text into tokens.
+   */
+  tokenizer?: TokenizerObject | undefined | null;
+
+  /**
+   * The walkTokens function gets called with every token.
+   * Child tokens are called before moving on to sibling tokens.
+   * Each token is passed by reference so updates are persisted when passed to the parser.
+   * The return value of the function is ignored.
+   */
+  walkTokens?: ((token: Token) => void | Promise<void>) | undefined | null;
+  /**
+   * Generate closing slash for self-closing tags (<br/> instead of <br>)
+   * @deprecated Deprecated in v5.0.0 use marked-xhtml to emit self-closing HTML tags for void elements (<br/>, <img/>, etc.) with a "/" as required by XHTML.
+   */
+  xhtml?: boolean | undefined;
+}
+
+export interface MarkedOptions extends Omit<MarkedExtension, 'extensions' | 'renderer' | 'tokenizer' | 'walkTokens'> {
+  /**
+   * Type: object Default: new Renderer()
+   *
+   * An object containing functions to render tokens to HTML.
+   */
+  renderer?: Omit<_Renderer, 'constructor'> | undefined | null;
+
+  /**
+   * The tokenizer defines how to turn markdown text into tokens.
+   */
+  tokenizer?: Omit<_Tokenizer, 'constructor'> | undefined | null;
+
+  /**
+   * The walkTokens function gets called with every token.
+   * Child tokens are called before moving on to sibling tokens.
+   * Each token is passed by reference so updates are persisted when passed to the parser.
+   * The return value of the function is ignored.
+   */
+  walkTokens?: ((token: Token) => void | Promise<void> | Array<void | Promise<void>>) | undefined | null;
+
+  /**
+   * Add tokenizers and renderers to marked
+   */
+  extensions?:
+    | (TokenizerAndRendererExtension[] & {
+    renderers: Record<string, (this: RendererThis, token: Tokens.Generic) => string | false | undefined>,
+    childTokens: Record<string, string[]>,
+    block: any[],
+    inline: any[],
+    startBlock: Array<(this: TokenizerThis, src: string) => number | void>,
+    startInline: Array<(this: TokenizerThis, src: string) => number | void>
+  })
+    | undefined | null;
+}