marked 5.1.2 → 7.0.0

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

@@ -1,44 +1,50 @@
-import { Renderer } from './Renderer.js';
-import { TextRenderer } from './TextRenderer.js';
-import { Slugger } from './Slugger.js';
-import { defaults } from './defaults.js';
+import { _Renderer } from './Renderer.ts';
+import { _TextRenderer } from './TextRenderer.ts';
+import { _Slugger } from './Slugger.ts';
+import { _defaults } from './defaults.ts';
 import {
   unescape
-} from './helpers.js';
+} from './helpers.ts';
+import type { Token, Tokens } from './Tokens.ts';
+import type { MarkedOptions } from './MarkedOptions.ts';
 
 /**
  * Parsing & Compiling
  */
-export class Parser {
-  constructor(options) {
-    this.options = options || defaults;
-    this.options.renderer = this.options.renderer || new Renderer();
+export class _Parser {
+  options: MarkedOptions;
+  renderer: _Renderer;
+  textRenderer: _TextRenderer;
+  slugger: _Slugger;
+  constructor(options?: MarkedOptions) {
+    this.options = options || _defaults;
+    this.options.renderer = this.options.renderer || new _Renderer();
     this.renderer = this.options.renderer;
     this.renderer.options = this.options;
-    this.textRenderer = new TextRenderer();
-    this.slugger = new Slugger();
+    this.textRenderer = new _TextRenderer();
+    this.slugger = new _Slugger();
   }
 
   /**
    * Static Parse Method
    */
-  static parse(tokens, options) {
-    const parser = new Parser(options);
+  static parse(tokens: Token[], options?: MarkedOptions) {
+    const parser = new _Parser(options);
     return parser.parse(tokens);
   }
 
   /**
    * Static Parse Inline Method
    */
-  static parseInline(tokens, options) {
-    const parser = new Parser(options);
+  static parseInline(tokens: Token[], options?: MarkedOptions) {
+    const parser = new _Parser(options);
     return parser.parseInline(tokens);
   }
 
   /**
    * Parse Loop
    */
-  parse(tokens, top = true) {
+  parse(tokens: Token[], top = true): string {
     let out = '',
       i,
       j,
@@ -83,16 +89,16 @@ export class Parser {
         }
         case 'heading': {
           out += this.renderer.heading(
-            this.parseInline(token.tokens),
+            this.parseInline(token.tokens) as string,
             token.depth,
-            unescape(this.parseInline(token.tokens, this.textRenderer)),
+            unescape(this.parseInline(token.tokens, this.textRenderer) as string),
             this.slugger);
           continue;
         }
         case 'code': {
           out += this.renderer.code(token.text,
             token.lang,
-            token.escaped);
+            !!token.escaped);
           continue;
         }
         case 'table': {
@@ -103,7 +109,7 @@ export class Parser {
           l2 = token.header.length;
           for (j = 0; j < l2; j++) {
             cell += this.renderer.tablecell(
-              this.parseInline(token.header[j].tokens),
+              this.parseInline(token.header[j].tokens)!,
               { header: true, align: token.align[j] }
             );
           }
@@ -118,7 +124,7 @@ export class Parser {
             l3 = row.length;
             for (k = 0; k < l3; k++) {
               cell += this.renderer.tablecell(
-                this.parseInline(row[k].tokens),
+                this.parseInline(row[k].tokens)!,
                 { header: false, align: token.align[k] }
               );
             }
@@ -129,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;
         }
@@ -147,7 +153,7 @@ export class Parser {
 
             itemBody = '';
             if (item.task) {
-              checkbox = this.renderer.checkbox(checked);
+              checkbox = this.renderer.checkbox(!!checked);
               if (loose) {
                 if (item.tokens.length > 0 && item.tokens[0].type === 'paragraph') {
                   item.tokens[0].text = checkbox + ' ' + item.tokens[0].text;
@@ -158,7 +164,7 @@ export class Parser {
                   item.tokens.unshift({
                     type: 'text',
                     text: checkbox
-                  });
+                  } as Tokens.Text);
                 }
               } else {
                 itemBody += checkbox;
@@ -166,7 +172,7 @@ export class Parser {
             }
 
             itemBody += this.parse(item.tokens, loose);
-            body += this.renderer.listitem(itemBody, task, checked);
+            body += this.renderer.listitem(itemBody, task, !!checked);
           }
 
           out += this.renderer.list(body, ordered, start);
@@ -177,7 +183,7 @@ 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': {
@@ -186,7 +192,7 @@ export class Parser {
             token = tokens[++i];
             body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
           }
-          out += top ? this.renderer.paragraph(body) : body;
+          out += top ? this.renderer.paragraph(body!) : body;
           continue;
         }
 
@@ -194,7 +200,7 @@ export class Parser {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
-            return;
+            return '';
           } else {
             throw new Error(errMsg);
           }
@@ -208,7 +214,7 @@ export class Parser {
   /**
    * Parse Inline Tokens
    */
-  parseInline(tokens, renderer) {
+  parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): string {
     renderer = renderer || this.renderer;
     let out = '',
       i,
@@ -238,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': {
@@ -246,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': {
@@ -262,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': {
@@ -273,7 +279,7 @@ export class Parser {
           const errMsg = 'Token with "' + token.type + '" type was not found.';
           if (this.options.silent) {
             console.error(errMsg);
-            return;
+            return '';
           } else {
             throw new Error(errMsg);
           }

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

@@ -1,19 +1,22 @@
-import { defaults } from './defaults.js';
+import { _defaults } from './defaults.ts';
 import {
   cleanUrl,
   escape
-} from './helpers.js';
+} from './helpers.ts';
+import type { MarkedOptions } from './MarkedOptions.ts';
+import { Slugger } from './marked.ts';
 
 /**
  * Renderer
  */
-export class Renderer {
-  constructor(options) {
-    this.options = options || defaults;
+export class _Renderer {
+  options: MarkedOptions;
+  constructor(options?: MarkedOptions) {
+    this.options = options || _defaults;
   }
 
-  code(code, infostring, escaped) {
-    const lang = (infostring || '').match(/\S*/)[0];
+  code(code: string, infostring: string | undefined, escaped: boolean): string {
+    const lang = (infostring || '').match(/\S*/)![0];
     if (this.options.highlight) {
       const out = this.options.highlight(code, lang);
       if (out != null && out !== code) {
@@ -38,24 +41,15 @@ export class Renderer {
       + '</code></pre>\n';
   }
 
-  /**
-   * @param {string} quote
-   */
-  blockquote(quote) {
+  blockquote(quote: string): string {
     return `<blockquote>\n${quote}</blockquote>\n`;
   }
 
-  html(html, block) {
+  html(html: string, block?: boolean) : string {
     return html;
   }
 
-  /**
-   * @param {string} text
-   * @param {string} level
-   * @param {string} raw
-   * @param {any} slugger
-   */
-  heading(text, level, raw, slugger) {
+  heading(text: string, level: number, raw: string, slugger: Slugger): string {
     if (this.options.headerIds) {
       const id = this.options.headerPrefix + slugger.slug(raw);
       return `<h${level} id="${id}">${text}</h${level}>\n`;
@@ -65,24 +59,21 @@ export class Renderer {
     return `<h${level}>${text}</h${level}>\n`;
   }
 
-  hr() {
+  hr(): string {
     return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
   }
 
-  list(body, ordered, start) {
+  list(body: string, ordered: boolean, start: number | ''): string {
     const type = ordered ? 'ol' : 'ul',
       startatt = (ordered && start !== 1) ? (' start="' + start + '"') : '';
     return '<' + type + startatt + '>\n' + body + '</' + type + '>\n';
   }
 
-  /**
-   * @param {string} text
-   */
-  listitem(text) {
+  listitem(text: string, task: boolean, checked: boolean): string {
     return `<li>${text}</li>\n`;
   }
 
-  checkbox(checked) {
+  checkbox(checked: boolean): string {
     return '<input '
       + (checked ? 'checked="" ' : '')
       + 'disabled="" type="checkbox"'
@@ -90,18 +81,11 @@ export class Renderer {
       + '> ';
   }
 
-  /**
-   * @param {string} text
-   */
-  paragraph(text) {
+  paragraph(text: string): string {
     return `<p>${text}</p>\n`;
   }
 
-  /**
-   * @param {string} header
-   * @param {string} body
-   */
-  table(header, body) {
+  table(header: string, body: string): string {
     if (body) body = `<tbody>${body}</tbody>`;
 
     return '<table>\n'
@@ -112,14 +96,14 @@ export class Renderer {
       + '</table>\n';
   }
 
-  /**
-   * @param {string} content
-   */
-  tablerow(content) {
+  tablerow(content: string): string {
     return `<tr>\n${content}</tr>\n`;
   }
 
-  tablecell(content, flags) {
+  tablecell(content: string, flags: {
+    header: boolean;
+    align: 'center' | 'left' | 'right' | null;
+  }): string {
     const type = flags.header ? 'th' : 'td';
     const tag = flags.align
       ? `<${type} align="${flags.align}">`
@@ -129,44 +113,29 @@ export class Renderer {
 
   /**
    * span level renderer
-   * @param {string} text
    */
-  strong(text) {
+  strong(text: string): string {
     return `<strong>${text}</strong>`;
   }
 
-  /**
-   * @param {string} text
-   */
-  em(text) {
+  em(text: string): string {
     return `<em>${text}</em>`;
   }
 
-  /**
-   * @param {string} text
-   */
-  codespan(text) {
+  codespan(text: string): string {
     return `<code>${text}</code>`;
   }
 
-  br() {
+  br(): string {
     return this.options.xhtml ? '<br/>' : '<br>';
   }
 
-  /**
-   * @param {string} text
-   */
-  del(text) {
+  del(text: string): string {
     return `<del>${text}</del>`;
   }
 
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
-  link(href, title, text) {
-    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+  link(href: string, title: string | null | undefined, text: string): string {
+    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href) as any;
     if (href === null) {
       return text;
     }
@@ -178,13 +147,8 @@ export class Renderer {
     return out;
   }
 
-  /**
-   * @param {string} href
-   * @param {string} title
-   * @param {string} text
-   */
-  image(href, title, text) {
-    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href);
+  image(href: string, title: string | null, text: string): string {
+    href = cleanUrl(this.options.sanitize, this.options.baseUrl, href) as any;
     if (href === null) {
       return text;
     }
@@ -197,7 +161,7 @@ export class Renderer {
     return out;
   }
 
-  text(text) {
+  text(text: string) : string {
     return text;
   }
 }

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

@@ -1,15 +1,16 @@
+import type { SluggerOptions } from './MarkedOptions.ts';
+
 /**
  * Slugger generates header id
  */
-export class Slugger {
+export class _Slugger {
+  seen: { [slugValue: string]: number };
+
   constructor() {
     this.seen = {};
   }
 
-  /**
-   * @param {string} value
-   */
-  serialize(value) {
+  serialize(value: string) {
     return value
       .toLowerCase()
       .trim()
@@ -22,10 +23,8 @@ export class Slugger {
 
   /**
    * Finds the next safe (unique) slug to use
-   * @param {string} originalSlug
-   * @param {boolean} isDryRun
    */
-  getNextSafeSlug(originalSlug, isDryRun) {
+  getNextSafeSlug(originalSlug: string, isDryRun: boolean | undefined) {
     let slug = originalSlug;
     let occurenceAccumulator = 0;
     if (this.seen.hasOwnProperty(slug)) {
@@ -44,11 +43,8 @@ export class Slugger {
 
   /**
    * Convert string to unique id
-   * @param {object} [options]
-   * @param {boolean} [options.dryrun] Generates the next unique slug without
-   * updating the internal accumulator.
    */
-  slug(value, options = {}) {
+  slug(value: string, options: SluggerOptions = {}) {
     const slug = this.serialize(value);
     return this.getNextSafeSlug(slug, options.dryrun);
   }

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

@@ -2,37 +2,37 @@
  * TextRenderer
  * returns only the textual part of the token
  */
-export class TextRenderer {
+export class _TextRenderer {
   // no need for block level renderers
-  strong(text) {
+  strong(text: string) {
     return text;
   }
 
-  em(text) {
+  em(text: string) {
     return text;
   }
 
-  codespan(text) {
+  codespan(text: string) {
     return text;
   }
 
-  del(text) {
+  del(text: string) {
     return text;
   }
 
-  html(text) {
+  html(text: string) {
     return text;
   }
 
-  text(text) {
+  text(text: string) {
     return text;
   }
 
-  link(href, title, text) {
+  link(href: string, title: string | null | undefined, text: string) {
     return '' + text;
   }
 
-  image(href, title, text) {
+  image(href: string, title: string | null, text: string) {
     return '' + text;
   }