marked 7.0.1 → 7.0.2

package/src/MarkedOptions.ts

@@ -1,212 +0,0 @@
-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;
-}

package/src/Parser.ts

@@ -1,291 +0,0 @@
-import { _Renderer } from './Renderer.ts';
-import { _TextRenderer } from './TextRenderer.ts';
-import { _Slugger } from './Slugger.ts';
-import { _defaults } from './defaults.ts';
-import {
-  unescape
-} from './helpers.ts';
-import type { Token, Tokens } from './Tokens.ts';
-import type { MarkedOptions } from './MarkedOptions.ts';
-
-/**
- * Parsing & Compiling
- */
-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();
-  }
-
-  /**
-   * Static Parse Method
-   */
-  static parse(tokens: Token[], options?: MarkedOptions) {
-    const parser = new _Parser(options);
-    return parser.parse(tokens);
-  }
-
-  /**
-   * Static Parse Inline Method
-   */
-  static parseInline(tokens: Token[], options?: MarkedOptions) {
-    const parser = new _Parser(options);
-    return parser.parseInline(tokens);
-  }
-
-  /**
-   * Parse Loop
-   */
-  parse(tokens: Token[], top = true): string {
-    let out = '',
-      i,
-      j,
-      k,
-      l2,
-      l3,
-      row,
-      cell,
-      header,
-      body,
-      token,
-      ordered,
-      start,
-      loose,
-      itemBody,
-      item,
-      checked,
-      task,
-      checkbox,
-      ret;
-
-    const l = tokens.length;
-    for (i = 0; i < l; i++) {
-      token = tokens[i];
-
-      // Run any renderer extensions
-      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-        ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-        if (ret !== false || !['space', 'hr', 'heading', 'code', 'table', 'blockquote', 'list', 'html', 'paragraph', 'text'].includes(token.type)) {
-          out += ret || '';
-          continue;
-        }
-      }
-
-      switch (token.type) {
-        case 'space': {
-          continue;
-        }
-        case 'hr': {
-          out += this.renderer.hr();
-          continue;
-        }
-        case 'heading': {
-          out += this.renderer.heading(
-            this.parseInline(token.tokens) as string,
-            token.depth,
-            unescape(this.parseInline(token.tokens, this.textRenderer) as string),
-            this.slugger);
-          continue;
-        }
-        case 'code': {
-          out += this.renderer.code(token.text,
-            token.lang,
-            !!token.escaped);
-          continue;
-        }
-        case 'table': {
-          header = '';
-
-          // header
-          cell = '';
-          l2 = token.header.length;
-          for (j = 0; j < l2; j++) {
-            cell += this.renderer.tablecell(
-              this.parseInline(token.header[j].tokens)!,
-              { header: true, align: token.align[j] }
-            );
-          }
-          header += this.renderer.tablerow(cell);
-
-          body = '';
-          l2 = token.rows.length;
-          for (j = 0; j < l2; j++) {
-            row = token.rows[j];
-
-            cell = '';
-            l3 = row.length;
-            for (k = 0; k < l3; k++) {
-              cell += this.renderer.tablecell(
-                this.parseInline(row[k].tokens)!,
-                { header: false, align: token.align[k] }
-              );
-            }
-
-            body += this.renderer.tablerow(cell);
-          }
-          out += this.renderer.table(header, body);
-          continue;
-        }
-        case 'blockquote': {
-          body = this.parse(token.tokens)!;
-          out += this.renderer.blockquote(body);
-          continue;
-        }
-        case 'list': {
-          ordered = token.ordered;
-          start = token.start;
-          loose = token.loose;
-          l2 = token.items.length;
-
-          body = '';
-          for (j = 0; j < l2; j++) {
-            item = token.items[j];
-            checked = item.checked;
-            task = item.task;
-
-            itemBody = '';
-            if (item.task) {
-              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;
-                  if (item.tokens[0].tokens && item.tokens[0].tokens.length > 0 && item.tokens[0].tokens[0].type === 'text') {
-                    item.tokens[0].tokens[0].text = checkbox + ' ' + item.tokens[0].tokens[0].text;
-                  }
-                } else {
-                  item.tokens.unshift({
-                    type: 'text',
-                    text: checkbox
-                  } as Tokens.Text);
-                }
-              } else {
-                itemBody += checkbox;
-              }
-            }
-
-            itemBody += this.parse(item.tokens, loose);
-            body += this.renderer.listitem(itemBody, task, !!checked);
-          }
-
-          out += this.renderer.list(body, ordered, start);
-          continue;
-        }
-        case 'html': {
-          out += this.renderer.html(token.text, token.block);
-          continue;
-        }
-        case 'paragraph': {
-          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];
-            body += '\n' + (token.tokens ? this.parseInline(token.tokens) : token.text);
-          }
-          out += top ? this.renderer.paragraph(body!) : body;
-          continue;
-        }
-
-        default: {
-          const errMsg = 'Token with "' + token.type + '" type was not found.';
-          if (this.options.silent) {
-            console.error(errMsg);
-            return '';
-          } else {
-            throw new Error(errMsg);
-          }
-        }
-      }
-    }
-
-    return out;
-  }
-
-  /**
-   * Parse Inline Tokens
-   */
-  parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): string {
-    renderer = renderer || this.renderer;
-    let out = '',
-      i,
-      token,
-      ret;
-
-    const l = tokens.length;
-    for (i = 0; i < l; i++) {
-      token = tokens[i];
-
-      // Run any renderer extensions
-      if (this.options.extensions && this.options.extensions.renderers && this.options.extensions.renderers[token.type]) {
-        ret = this.options.extensions.renderers[token.type].call({ parser: this }, token);
-        if (ret !== false || !['escape', 'html', 'link', 'image', 'strong', 'em', 'codespan', 'br', 'del', 'text'].includes(token.type)) {
-          out += ret || '';
-          continue;
-        }
-      }
-
-      switch (token.type) {
-        case 'escape': {
-          out += renderer.text(token.text);
-          break;
-        }
-        case 'html': {
-          out += renderer.html(token.text);
-          break;
-        }
-        case 'link': {
-          out += renderer.link(token.href, token.title, this.parseInline(token.tokens, renderer)!);
-          break;
-        }
-        case 'image': {
-          out += renderer.image(token.href, token.title, token.text);
-          break;
-        }
-        case 'strong': {
-          out += renderer.strong(this.parseInline(token.tokens, renderer)!);
-          break;
-        }
-        case 'em': {
-          out += renderer.em(this.parseInline(token.tokens, renderer)!);
-          break;
-        }
-        case 'codespan': {
-          out += renderer.codespan(token.text);
-          break;
-        }
-        case 'br': {
-          out += renderer.br();
-          break;
-        }
-        case 'del': {
-          out += renderer.del(this.parseInline(token.tokens, renderer)!);
-          break;
-        }
-        case 'text': {
-          out += renderer.text(token.text);
-          break;
-        }
-        default: {
-          const errMsg = 'Token with "' + token.type + '" type was not found.';
-          if (this.options.silent) {
-            console.error(errMsg);
-            return '';
-          } else {
-            throw new Error(errMsg);
-          }
-        }
-      }
-    }
-    return out;
-  }
-}

package/src/Renderer.ts

@@ -1,167 +0,0 @@
-import { _defaults } from './defaults.ts';
-import {
-  cleanUrl,
-  escape
-} from './helpers.ts';
-import type { MarkedOptions } from './MarkedOptions.ts';
-import { Slugger } from './marked.ts';
-
-/**
- * Renderer
- */
-export class _Renderer {
-  options: MarkedOptions;
-  constructor(options?: MarkedOptions) {
-    this.options = options || _defaults;
-  }
-
-  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) {
-        escaped = true;
-        code = out;
-      }
-    }
-
-    code = code.replace(/\n$/, '') + '\n';
-
-    if (!lang) {
-      return '<pre><code>'
-        + (escaped ? code : escape(code, true))
-        + '</code></pre>\n';
-    }
-
-    return '<pre><code class="'
-      + this.options.langPrefix
-      + escape(lang)
-      + '">'
-      + (escaped ? code : escape(code, true))
-      + '</code></pre>\n';
-  }
-
-  blockquote(quote: string): string {
-    return `<blockquote>\n${quote}</blockquote>\n`;
-  }
-
-  html(html: string, block?: boolean) : string {
-    return html;
-  }
-
-  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`;
-    }
-
-    // ignore IDs
-    return `<h${level}>${text}</h${level}>\n`;
-  }
-
-  hr(): string {
-    return this.options.xhtml ? '<hr/>\n' : '<hr>\n';
-  }
-
-  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';
-  }
-
-  listitem(text: string, task: boolean, checked: boolean): string {
-    return `<li>${text}</li>\n`;
-  }
-
-  checkbox(checked: boolean): string {
-    return '<input '
-      + (checked ? 'checked="" ' : '')
-      + 'disabled="" type="checkbox"'
-      + (this.options.xhtml ? ' /' : '')
-      + '> ';
-  }
-
-  paragraph(text: string): string {
-    return `<p>${text}</p>\n`;
-  }
-
-  table(header: string, body: string): string {
-    if (body) body = `<tbody>${body}</tbody>`;
-
-    return '<table>\n'
-      + '<thead>\n'
-      + header
-      + '</thead>\n'
-      + body
-      + '</table>\n';
-  }
-
-  tablerow(content: string): string {
-    return `<tr>\n${content}</tr>\n`;
-  }
-
-  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}">`
-      : `<${type}>`;
-    return tag + content + `</${type}>\n`;
-  }
-
-  /**
-   * span level renderer
-   */
-  strong(text: string): string {
-    return `<strong>${text}</strong>`;
-  }
-
-  em(text: string): string {
-    return `<em>${text}</em>`;
-  }
-
-  codespan(text: string): string {
-    return `<code>${text}</code>`;
-  }
-
-  br(): string {
-    return this.options.xhtml ? '<br/>' : '<br>';
-  }
-
-  del(text: string): string {
-    return `<del>${text}</del>`;
-  }
-
-  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;
-    }
-    let out = '<a href="' + href + '"';
-    if (title) {
-      out += ' title="' + title + '"';
-    }
-    out += '>' + text + '</a>';
-    return out;
-  }
-
-  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;
-    }
-
-    let out = `<img src="${href}" alt="${text}"`;
-    if (title) {
-      out += ` title="${title}"`;
-    }
-    out += this.options.xhtml ? '/>' : '>';
-    return out;
-  }
-
-  text(text: string) : string {
-    return text;
-  }
-}