marked 7.0.4 → 8.0.0

package/lib/marked.d.ts

@@ -152,44 +152,6 @@ declare module "Tokens" {
         links: Links;
     };
 }
-declare module "Tokenizer" {
-    import type { _Lexer } from "Lexer";
-    import type { Links, Tokens } from "Tokens";
-    import type { MarkedOptions } from "MarkedOptions";
-    /**
-     * Tokenizer
-     */
-    export class _Tokenizer {
-        options: MarkedOptions;
-        rules: any;
-        lexer: _Lexer;
-        constructor(options?: MarkedOptions);
-        space(src: string): Tokens.Space | undefined;
-        code(src: string): Tokens.Code | undefined;
-        fences(src: string): Tokens.Code | undefined;
-        heading(src: string): Tokens.Heading | undefined;
-        hr(src: string): Tokens.Hr | undefined;
-        blockquote(src: string): Tokens.Blockquote | undefined;
-        list(src: string): Tokens.List | undefined;
-        html(src: string): Tokens.HTML | Tokens.Paragraph | undefined;
-        def(src: string): Tokens.Def | undefined;
-        table(src: string): Tokens.Table | undefined;
-        lheading(src: string): Tokens.Heading | undefined;
-        paragraph(src: string): Tokens.Paragraph | undefined;
-        text(src: string): Tokens.Text | undefined;
-        escape(src: string): Tokens.Escape | undefined;
-        tag(src: string): Tokens.Tag | undefined;
-        link(src: string): Tokens.Link | Tokens.Image | undefined;
-        reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined;
-        emStrong(src: string, maskedSrc: string, prevChar?: string): Tokens.Em | Tokens.Strong | undefined;
-        codespan(src: string): Tokens.Codespan | undefined;
-        br(src: string): Tokens.Br | undefined;
-        del(src: string): Tokens.Del | undefined;
-        autolink(src: string, mangle: (cap: string) => string): Tokens.Link | undefined;
-        url(src: string, mangle: (cap: string) => string): Tokens.Link | undefined;
-        inlineText(src: string, smartypants: (cap: string) => string): Tokens.Text | undefined;
-    }
-}
 declare module "rules" {
     export type Rule = RegExp | string;
     export interface Rules {
@@ -208,128 +170,7 @@ declare module "rules" {
      */
     export const inline: Record<InlineRuleNames, Rule> & Record<InlineSubRuleNames, Rules> & Rules;
 }
-declare module "Lexer" {
-    import type { Token, TokensList } from "Tokens";
-    import type { MarkedOptions } from "MarkedOptions";
-    import type { Rules } from "rules";
-    /**
-     * Block Lexer
-     */
-    export class _Lexer {
-        tokens: TokensList;
-        options: MarkedOptions;
-        state: {
-            inLink: boolean;
-            inRawBlock: boolean;
-            top: boolean;
-        };
-        private tokenizer;
-        private inlineQueue;
-        constructor(options?: MarkedOptions);
-        /**
-         * Expose Rules
-         */
-        static get rules(): Rules;
-        /**
-         * Static Lex Method
-         */
-        static lex(src: string, options?: MarkedOptions): TokensList;
-        /**
-         * Static Lex Inline Method
-         */
-        static lexInline(src: string, options?: MarkedOptions): Token[];
-        /**
-         * Preprocessing
-         */
-        lex(src: string): TokensList;
-        /**
-         * Lexing
-         */
-        blockTokens(src: string, tokens?: Token[]): Token[];
-        blockTokens(src: string, tokens?: TokensList): TokensList;
-        inline(src: string, tokens?: Token[]): Token[];
-        /**
-         * Lexing/Compiling
-         */
-        inlineTokens(src: string, tokens?: Token[]): Token[];
-    }
-}
-declare module "TextRenderer" {
-    /**
-     * TextRenderer
-     * returns only the textual part of the token
-     */
-    export class _TextRenderer {
-        strong(text: string): string;
-        em(text: string): string;
-        codespan(text: string): string;
-        del(text: string): string;
-        html(text: string): string;
-        text(text: string): string;
-        link(href: string, title: string | null | undefined, text: string): string;
-        image(href: string, title: string | null, text: string): string;
-        br(): string;
-    }
-}
-declare module "Slugger" {
-    import type { SluggerOptions } from "MarkedOptions";
-    /**
-     * Slugger generates header id
-     */
-    export class _Slugger {
-        seen: {
-            [slugValue: string]: number;
-        };
-        constructor();
-        serialize(value: string): string;
-        /**
-         * Finds the next safe (unique) slug to use
-         */
-        getNextSafeSlug(originalSlug: string, isDryRun: boolean | undefined): string;
-        /**
-         * Convert string to unique id
-         */
-        slug(value: string, options?: SluggerOptions): string;
-    }
-}
-declare module "Instance" {
-    import { _Lexer } from "Lexer";
-    import { _Parser } from "Parser";
-    import { _Hooks } from "Hooks";
-    import { _Renderer } from "Renderer";
-    import { _Tokenizer } from "Tokenizer";
-    import { _TextRenderer } from "TextRenderer";
-    import { _Slugger } from "Slugger";
-    import type { MarkedExtension, MarkedOptions } from "MarkedOptions";
-    import type { Token, TokensList } from "Tokens";
-    export type ResultCallback = (error: Error | null, parseResult?: string) => undefined | void;
-    export class Marked {
-        #private;
-        defaults: MarkedOptions;
-        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;
-        parser: typeof _Parser.parse;
-        Renderer: typeof _Renderer;
-        TextRenderer: typeof _TextRenderer;
-        Lexer: typeof _Lexer;
-        lexer: typeof _Lexer.lex;
-        Tokenizer: typeof _Tokenizer;
-        Slugger: typeof _Slugger;
-        Hooks: typeof _Hooks;
-        constructor(...args: MarkedExtension[]);
-        /**
-         * Run callback for every token
-         */
-        walkTokens<T = void>(tokens: Token[] | TokensList, callback: (token: Token) => T | T[]): T[];
-        use(...args: MarkedExtension[]): this;
-        setOptions(opt: MarkedOptions): this;
-    }
-}
 declare module "helpers" {
-    import type { MarkedOptions } from "MarkedOptions";
-    import type { ResultCallback } from "Instance";
     import type { Rule } from "rules";
     export function escape(html: string, encode?: boolean): string;
     export function unescape(html: string): string;
@@ -337,8 +178,7 @@ declare module "helpers" {
         replace: (name: string | RegExp, val: string | RegExp) => any;
         getRegex: () => RegExp;
     };
-    export function cleanUrl(sanitize: boolean | undefined, base: string | undefined | null, href: string): string | null;
-    export function resolveUrl(base: string, href: string): string;
+    export function cleanUrl(href: string): string | null;
     export const noopTest: {
         exec: () => null;
     };
@@ -353,11 +193,9 @@ declare module "helpers" {
      */
     export function rtrim(str: string, c: string, invert?: boolean): string;
     export function findClosingBracket(str: string, b: string): number;
-    export function checkDeprecations(opt: MarkedOptions, callback?: ResultCallback): void;
 }
 declare module "Renderer" {
     import type { MarkedOptions } from "MarkedOptions";
-    import type { _Slugger } from "Slugger";
     /**
      * Renderer
      */
@@ -367,7 +205,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): string;
         hr(): string;
         list(body: string, ordered: boolean, start: number | ''): string;
         listitem(text: string, task: boolean, checked: boolean): string;
@@ -392,10 +230,26 @@ declare module "Renderer" {
         text(text: string): string;
     }
 }
+declare module "TextRenderer" {
+    /**
+     * TextRenderer
+     * returns only the textual part of the token
+     */
+    export class _TextRenderer {
+        strong(text: string): string;
+        em(text: string): string;
+        codespan(text: string): string;
+        del(text: string): string;
+        html(text: string): string;
+        text(text: string): string;
+        link(href: string, title: string | null | undefined, text: string): string;
+        image(href: string, title: string | null, text: string): string;
+        br(): string;
+    }
+}
 declare module "Parser" {
     import { _Renderer } from "Renderer";
     import { _TextRenderer } from "TextRenderer";
-    import { _Slugger } from "Slugger";
     import type { Token } from "Tokens";
     import type { MarkedOptions } from "MarkedOptions";
     /**
@@ -405,7 +259,6 @@ declare module "Parser" {
         options: MarkedOptions;
         renderer: _Renderer;
         textRenderer: _TextRenderer;
-        slugger: _Slugger;
         constructor(options?: MarkedOptions);
         /**
          * Static Parse Method
@@ -425,16 +278,96 @@ declare module "Parser" {
         parseInline(tokens: Token[], renderer?: _Renderer | _TextRenderer): string;
     }
 }
+declare module "Tokenizer" {
+    import type { _Lexer } from "Lexer";
+    import type { Links, Tokens } from "Tokens";
+    import type { MarkedOptions } from "MarkedOptions";
+    /**
+     * Tokenizer
+     */
+    export class _Tokenizer {
+        options: MarkedOptions;
+        rules: any;
+        lexer: _Lexer;
+        constructor(options?: MarkedOptions);
+        space(src: string): Tokens.Space | undefined;
+        code(src: string): Tokens.Code | undefined;
+        fences(src: string): Tokens.Code | undefined;
+        heading(src: string): Tokens.Heading | undefined;
+        hr(src: string): Tokens.Hr | undefined;
+        blockquote(src: string): Tokens.Blockquote | undefined;
+        list(src: string): Tokens.List | undefined;
+        html(src: string): Tokens.HTML | undefined;
+        def(src: string): Tokens.Def | undefined;
+        table(src: string): Tokens.Table | undefined;
+        lheading(src: string): Tokens.Heading | undefined;
+        paragraph(src: string): Tokens.Paragraph | undefined;
+        text(src: string): Tokens.Text | undefined;
+        escape(src: string): Tokens.Escape | undefined;
+        tag(src: string): Tokens.Tag | undefined;
+        link(src: string): Tokens.Link | Tokens.Image | undefined;
+        reflink(src: string, links: Links): Tokens.Link | Tokens.Image | Tokens.Text | undefined;
+        emStrong(src: string, maskedSrc: string, prevChar?: string): Tokens.Em | Tokens.Strong | undefined;
+        codespan(src: string): Tokens.Codespan | undefined;
+        br(src: string): Tokens.Br | undefined;
+        del(src: string): Tokens.Del | undefined;
+        autolink(src: string): Tokens.Link | undefined;
+        url(src: string): Tokens.Link | undefined;
+        inlineText(src: string): Tokens.Text | undefined;
+    }
+}
+declare module "Lexer" {
+    import type { Token, TokensList } from "Tokens";
+    import type { MarkedOptions } from "MarkedOptions";
+    import type { Rules } from "rules";
+    /**
+     * Block Lexer
+     */
+    export class _Lexer {
+        tokens: TokensList;
+        options: MarkedOptions;
+        state: {
+            inLink: boolean;
+            inRawBlock: boolean;
+            top: boolean;
+        };
+        private tokenizer;
+        private inlineQueue;
+        constructor(options?: MarkedOptions);
+        /**
+         * Expose Rules
+         */
+        static get rules(): Rules;
+        /**
+         * Static Lex Method
+         */
+        static lex(src: string, options?: MarkedOptions): TokensList;
+        /**
+         * Static Lex Inline Method
+         */
+        static lexInline(src: string, options?: MarkedOptions): Token[];
+        /**
+         * Preprocessing
+         */
+        lex(src: string): TokensList;
+        /**
+         * Lexing
+         */
+        blockTokens(src: string, tokens?: Token[]): Token[];
+        blockTokens(src: string, tokens?: TokensList): TokensList;
+        inline(src: string, tokens?: Token[]): Token[];
+        /**
+         * Lexing/Compiling
+         */
+        inlineTokens(src: string, tokens?: Token[]): Token[];
+    }
+}
 declare module "MarkedOptions" {
     import type { Token, Tokens, TokensList } from "Tokens";
     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;
-    }
     export interface TokenizerThis {
         lexer: _Lexer;
     }
@@ -469,11 +402,6 @@ declare module "MarkedOptions" {
          * 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.
          */
@@ -486,24 +414,6 @@ declare module "MarkedOptions" {
          * 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.
@@ -514,16 +424,6 @@ declare module "MarkedOptions" {
             postprocess: (html: string) => string | Promise<string>;
             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.
          */
@@ -534,29 +434,10 @@ declare module "MarkedOptions" {
          * 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.
          */
@@ -567,12 +448,7 @@ declare module "MarkedOptions" {
          * 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 | unknown | 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;
+        walkTokens?: ((token: Token) => void | Promise<void>) | undefined | null;
     }
     export interface MarkedOptions extends Omit<MarkedExtension, 'renderer' | 'tokenizer' | 'extensions' | 'walkTokens'> {
         /**
@@ -603,7 +479,7 @@ declare module "MarkedOptions" {
         /**
          * walkTokens function returns array of values for Promise.all
          */
-        walkTokens?: null | ((token: Token) => void | (unknown | Promise<void>)[]);
+        walkTokens?: null | ((token: Token) => void | Promise<void> | (void | Promise<void>)[]);
     }
 }
 declare module "defaults" {
@@ -631,18 +507,50 @@ declare module "Hooks" {
         postprocess(html: string): string;
     }
 }
+declare module "Instance" {
+    import { _Lexer } from "Lexer";
+    import { _Parser } from "Parser";
+    import { _Hooks } from "Hooks";
+    import { _Renderer } from "Renderer";
+    import { _Tokenizer } from "Tokenizer";
+    import { _TextRenderer } from "TextRenderer";
+    import type { MarkedExtension, MarkedOptions } from "MarkedOptions";
+    import type { Token, TokensList } from "Tokens";
+    export type MaybePromise = void | Promise<void>;
+    export class Marked {
+        #private;
+        defaults: MarkedOptions;
+        options: (opt: MarkedOptions) => this;
+        parse: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>;
+        parseInline: (src: string, options?: MarkedOptions | undefined | null) => string | Promise<string>;
+        Parser: typeof _Parser;
+        parser: typeof _Parser.parse;
+        Renderer: typeof _Renderer;
+        TextRenderer: typeof _TextRenderer;
+        Lexer: typeof _Lexer;
+        lexer: typeof _Lexer.lex;
+        Tokenizer: typeof _Tokenizer;
+        Hooks: typeof _Hooks;
+        constructor(...args: MarkedExtension[]);
+        /**
+         * Run callback for every token
+         */
+        walkTokens(tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]): MaybePromise[];
+        use(...args: MarkedExtension[]): this;
+        setOptions(opt: MarkedOptions): this;
+    }
+}
 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";
+    import type { MaybePromise } from "Instance";
     /**
      * Compiles markdown to HTML asynchronously.
      *
@@ -662,26 +570,11 @@ declare module "marked" {
      */
     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.
+     * Compiles markdown to HTML synchronously.
      *
      * @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
+     * @param options Optional hash of options
+     * @return String of compiled HTML
      */
     export namespace marked {
         var options: (options: MarkedOptions) => typeof marked;
@@ -689,8 +582,8 @@ declare module "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 walkTokens: (tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) => MaybePromise[];
+        var parseInline: (src: string, options?: MarkedOptions | null | undefined) => string | Promise<string>;
         var Parser: typeof _Parser;
         var parser: typeof _Parser.parse;
         var Renderer: typeof _Renderer;
@@ -698,15 +591,14 @@ declare module "marked" {
         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 walkTokens: (tokens: Token[] | TokensList, callback: (token: Token) => MaybePromise | MaybePromise[]) => MaybePromise[];
+    export const parseInline: (src: string, options?: MarkedOptions | null | undefined) => string | Promise<string>;
     export const parse: typeof marked;
     export const parser: typeof _Parser.parse;
     export const lexer: typeof _Lexer.lex;
@@ -716,7 +608,6 @@ declare module "marked" {
     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";