@codingame/monaco-vscode-api 25.1.1 → 26.0.0

package/vscode/src/vs/base/browser/markdownRenderer.js

@@ -20,11 +20,20 @@ import { StandardMouseEvent } from './mouseEvent.js';
 import { renderIcon, renderLabelWithIcons } from './ui/iconLabel/iconLabels.js';
 
 const defaultMarkedRenderers = ( Object.freeze({
-    image: ({ href, title, text }) => {
+    image: (
+        {
+            href,
+            title,
+            text
+        }
+    ) => {
         let dimensions = [];
         let attributes = [];
         if (href) {
-            ({ href, dimensions } = parseHrefAndDimensions(href));
+            ({
+                href,
+                dimensions
+            } = parseHrefAndDimensions(href));
             attributes.push(`src="${escapeDoubleQuotes(href)}"`);
         }
         if (text) {
@@ -36,34 +45,42 @@ const defaultMarkedRenderers = ( Object.freeze({
         if (dimensions.length) {
             attributes = attributes.concat(dimensions);
         }
-        return '<img ' + attributes.join(' ') + '>';
+        return "<img " + attributes.join(" ") + ">";
     },
-    paragraph({ tokens }) {
+    paragraph(
+        {
+            tokens
+        }
+    ) {
         return `<p>${this.parser.parseInline(tokens)}</p>`;
     },
-    link({ href, title, tokens }) {
+    link(
+        {
+            href,
+            title,
+            tokens
+        }
+    ) {
         let text = this.parser.parseInline(tokens);
-        if (typeof href !== 'string') {
-            return '';
+        if (typeof href !== "string") {
+            return "";
         }
         if (href === text) {
             text = removeMarkdownEscapes(text);
         }
-        title = typeof title === 'string' ? escapeDoubleQuotes(removeMarkdownEscapes(title)) : '';
+        title = typeof title === "string" ? escapeDoubleQuotes(removeMarkdownEscapes(title)) : "";
         href = removeMarkdownEscapes(href);
-        href = href.replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;')
-            .replace(/'/g, '&#39;');
+        href = href.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
         return `<a href="${href}" title="${title || href}" draggable="false">${text}</a>`;
-    },
+    }
 }));
 function createAlertBlockquoteRenderer(fallbackRenderer) {
-    return function (token) {
-        const { tokens } = token;
+    return function(token) {
+        const {
+            tokens
+        } = token;
         const firstToken = tokens[0];
-        if (firstToken?.type !== 'paragraph') {
+        if (firstToken?.type !== "paragraph") {
             return fallbackRenderer.call(this, token);
         }
         const paragraphTokens = firstToken.tokens;
@@ -71,7 +88,7 @@ function createAlertBlockquoteRenderer(fallbackRenderer) {
             return fallbackRenderer.call(this, token);
         }
         const firstTextToken = paragraphTokens[0];
-        if (firstTextToken?.type !== 'text') {
+        if (firstTextToken?.type !== "text") {
             return fallbackRenderer.call(this, token);
         }
         const pattern = /^\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*?\n*/i;
@@ -79,19 +96,21 @@ function createAlertBlockquoteRenderer(fallbackRenderer) {
         if (!match) {
             return fallbackRenderer.call(this, token);
         }
-        firstTextToken.raw = firstTextToken.raw.replace(pattern, '');
-        firstTextToken.text = firstTextToken.text.replace(pattern, '');
+        firstTextToken.raw = firstTextToken.raw.replace(pattern, "");
+        firstTextToken.text = firstTextToken.text.replace(pattern, "");
         const alertIcons = {
-            'note': 'info',
-            'tip': 'light-bulb',
-            'important': 'comment',
-            'warning': 'alert',
-            'caution': 'stop'
+            "note": "info",
+            "tip": "light-bulb",
+            "important": "comment",
+            "warning": "alert",
+            "caution": "stop"
         };
         const type = match[1];
         const typeCapitalized = type.charAt(0).toUpperCase() + type.slice(1).toLowerCase();
         const severity = type.toLowerCase();
-        const iconHtml = renderIcon({ id: alertIcons[severity] }).outerHTML;
+        const iconHtml = renderIcon({
+            id: alertIcons[severity]
+        }).outerHTML;
         const content = this.parser.parse(tokens);
         return `<blockquote data-severity="${severity}"><p><span>${iconHtml}${typeCapitalized}</span>${content.substring(3)}</blockquote>\n`;
     };
@@ -100,7 +119,11 @@ function renderMarkdown(markdown, options = {}, target) {
     const disposables = ( new DisposableStore());
     let isDisposed = false;
     const markedInstance = new Marked(...(options.markedExtensions ?? []));
-    const { renderer, codeBlocks, syncCodeBlocks } = createMarkdownRenderer(markedInstance, options, markdown);
+    const {
+        renderer,
+        codeBlocks,
+        syncCodeBlocks
+    } = createMarkdownRenderer(markedInstance, options, markdown);
     const value = preprocessMarkdownString(markdown);
     let renderedMarkdown;
     if (options.fillInIncompleteTokens) {
@@ -112,15 +135,18 @@ function renderMarkdown(markdown, options = {}, target) {
         const tokens = markedInstance.lexer(value, opts);
         const newTokens = fillInIncompleteTokens(tokens);
         renderedMarkdown = markedInstance.parser(newTokens, opts);
-    }
-    else {
-        renderedMarkdown = markedInstance.parse(value, { ...options?.markedOptions, renderer, async: false });
+    } else {
+        renderedMarkdown = markedInstance.parse(value, {
+            ...options?.markedOptions,
+            renderer,
+            async: false
+        });
     }
     if (markdown.supportThemeIcons) {
         const elements = renderLabelWithIcons(renderedMarkdown);
-        renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
+        renderedMarkdown = ( elements.map(e => typeof e === "string" ? e : e.outerHTML)).join("");
     }
-    const renderedContent = createElement('div');
+    const renderedContent = createElement("div");
     const sanitizerConfig = getDomSanitizerConfig(markdown, options.sanitizerConfig ?? {});
     safeSetInnerHtml(renderedContent, renderedMarkdown, sanitizerConfig);
     rewriteRenderedLinks(markdown, options, renderedContent);
@@ -128,55 +154,53 @@ function renderMarkdown(markdown, options = {}, target) {
     if (target) {
         outElement = target;
         reset(target, ...renderedContent.childNodes);
-    }
-    else {
+    } else {
         outElement = renderedContent;
     }
     if (codeBlocks.length > 0) {
-        Promise.all(codeBlocks).then((tuples) => {
+        Promise.all(codeBlocks).then(tuples => {
             if (isDisposed) {
                 return;
             }
             const renderedElements = ( new Map(tuples));
             const placeholderElements = outElement.querySelectorAll(`div[data-code]`);
             for (const placeholderElement of placeholderElements) {
-                const renderedElement = renderedElements.get(placeholderElement.dataset['code'] ?? '');
+                const renderedElement = renderedElements.get(placeholderElement.dataset["code"] ?? "");
                 if (renderedElement) {
                     reset(placeholderElement, renderedElement);
                 }
             }
             options.asyncRenderCallback?.();
         });
-    }
-    else if (syncCodeBlocks.length > 0) {
+    } else if (syncCodeBlocks.length > 0) {
         const renderedElements = ( new Map(syncCodeBlocks));
         const placeholderElements = outElement.querySelectorAll(`div[data-code]`);
         for (const placeholderElement of placeholderElements) {
-            const renderedElement = renderedElements.get(placeholderElement.dataset['code'] ?? '');
+            const renderedElement = renderedElements.get(placeholderElement.dataset["code"] ?? "");
             if (renderedElement) {
                 reset(placeholderElement, renderedElement);
             }
         }
     }
     if (options.asyncRenderCallback) {
-        for (const img of outElement.getElementsByTagName('img')) {
-            const listener = disposables.add(addDisposableListener(img, 'load', () => {
+        for (const img of outElement.getElementsByTagName("img")) {
+            const listener = disposables.add(addDisposableListener(img, "load", () => {
                 listener.dispose();
                 options.asyncRenderCallback();
             }));
         }
     }
     if (options.actionHandler) {
-        const clickCb = (e) => {
+        const clickCb = e => {
             const mouseEvent = ( new StandardMouseEvent(getWindow(outElement), e));
             if (!mouseEvent.leftButton && !mouseEvent.middleButton) {
                 return;
             }
             activateLink(markdown, options, mouseEvent);
         };
-        disposables.add(addDisposableListener(outElement, 'click', clickCb));
-        disposables.add(addDisposableListener(outElement, 'auxclick', clickCb));
-        disposables.add(addDisposableListener(outElement, 'keydown', (e) => {
+        disposables.add(addDisposableListener(outElement, "click", clickCb));
+        disposables.add(addDisposableListener(outElement, "auxclick", clickCb));
+        disposables.add(addDisposableListener(outElement, "keydown", e => {
             const keyboardEvent = ( new StandardKeyboardEvent(e));
             if (!keyboardEvent.equals(KeyCode.Space) && !keyboardEvent.equals(KeyCode.Enter)) {
                 return;
@@ -184,21 +208,18 @@ function renderMarkdown(markdown, options = {}, target) {
             activateLink(markdown, options, keyboardEvent);
         }));
     }
-    for (const input of [...outElement.getElementsByTagName('input')]) {
-        if (input.attributes.getNamedItem('type')?.value === 'checkbox') {
-            input.setAttribute('disabled', '');
-        }
-        else {
+    for (const input of [...outElement.getElementsByTagName("input")]) {
+        if (input.attributes.getNamedItem("type")?.value === "checkbox") {
+            input.setAttribute("disabled", "");
+        } else {
             if (options.sanitizerConfig?.replaceWithPlaintext) {
                 const replacement = convertTagToPlaintext(input);
                 if (replacement) {
                     input.parentElement?.replaceChild(replacement, input);
-                }
-                else {
+                } else {
                     input.remove();
                 }
-            }
-            else {
+            } else {
                 input.remove();
             }
         }
@@ -212,35 +233,30 @@ function renderMarkdown(markdown, options = {}, target) {
     };
 }
 function rewriteRenderedLinks(markdown, options, root) {
-    for (const el of root.querySelectorAll('img, audio, video, source')) {
-        const src = el.getAttribute('src');
+    for (const el of root.querySelectorAll("img, audio, video, source")) {
+        const src = el.getAttribute("src");
         if (src) {
             let href = src;
             try {
                 if (markdown.baseUri) {
                     href = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
                 }
-            }
-            catch (err) { }
-            el.setAttribute('src', massageHref(markdown, href, true));
+            } catch (err) {}
+            el.setAttribute("src", massageHref(markdown, href, true));
             if (options.sanitizerConfig?.remoteImageIsAllowed) {
                 const uri = ( URI.parse(href));
                 if (uri.scheme !== Schemas.file && uri.scheme !== Schemas.data && !options.sanitizerConfig.remoteImageIsAllowed(uri)) {
-                    el.replaceWith($('', undefined, el.outerHTML));
+                    el.replaceWith($("", undefined, el.outerHTML));
                 }
             }
         }
     }
-    for (const el of root.querySelectorAll('a')) {
-        const href = el.getAttribute('href');
-        el.setAttribute('href', '');
-        if (!href
-            || /^data:|javascript:/i.test(href)
-            || (/^command:/i.test(href) && !markdown.isTrusted)
-            || /^command:(\/\/\/)?_workbench\.downloadResource/i.test(href)) {
+    for (const el of root.querySelectorAll("a")) {
+        const href = el.getAttribute("href");
+        el.setAttribute("href", "");
+        if (!href || /^data:|javascript:/i.test(href) || (/^command:/i.test(href) && !markdown.isTrusted) || /^command:(\/\/\/)?_workbench\.downloadResource/i.test(href)) {
             el.replaceWith(...el.childNodes);
-        }
-        else {
+        } else {
             let resolvedHref = massageHref(markdown, href, false);
             if (markdown.baseUri) {
                 resolvedHref = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
@@ -260,15 +276,25 @@ function createMarkdownRenderer(marked, options, markdown) {
     const codeBlocks = [];
     const syncCodeBlocks = [];
     if (options.codeBlockRendererSync) {
-        renderer.code = ({ text, lang, raw }) => {
+        renderer.code = (
+            {
+                text,
+                lang,
+                raw
+            }
+        ) => {
             const id = defaultGenerator.nextId();
             const value = options.codeBlockRendererSync(postProcessCodeBlockLanguageId(lang), text, raw);
             syncCodeBlocks.push([id, value]);
             return `<div class="code" data-code="${id}">${escape(text)}</div>`;
         };
-    }
-    else if (options.codeBlockRenderer) {
-        renderer.code = ({ text, lang }) => {
+    } else if (options.codeBlockRenderer) {
+        renderer.code = (
+            {
+                text,
+                lang
+            }
+        ) => {
             const id = defaultGenerator.nextId();
             const value = options.codeBlockRenderer(postProcessCodeBlockLanguageId(lang), text);
             codeBlocks.push(value.then(element => [id, element]));
@@ -276,15 +302,23 @@ function createMarkdownRenderer(marked, options, markdown) {
         };
     }
     if (!markdown.supportHtml) {
-        renderer.html = ({ text }) => {
+        renderer.html = (
+            {
+                text
+            }
+        ) => {
             if (options.sanitizerConfig?.replaceWithPlaintext) {
                 return escape(text);
             }
             const match = markdown.isTrusted ? text.match(/^(<span[^>]+>)|(<\/\s*span>)$/) : undefined;
-            return match ? text : '';
+            return match ? text : "";
         };
     }
-    return { renderer, codeBlocks, syncCodeBlocks };
+    return {
+        renderer,
+        codeBlocks,
+        syncCodeBlocks
+    };
 }
 function preprocessMarkdownString(markdown) {
     let value = markdown.value;
@@ -297,23 +331,21 @@ function preprocessMarkdownString(markdown) {
     return value;
 }
 function activateLink(mdStr, options, event) {
-    const target = event.target.closest('a[data-href]');
+    const target = event.target.closest("a[data-href]");
     if (!isHTMLElement(target)) {
         return;
     }
     try {
-        let href = target.dataset['href'];
+        let href = target.dataset["href"];
         if (href) {
             if (mdStr.baseUri) {
                 href = resolveWithBaseUri(( URI.from(mdStr.baseUri)), href);
             }
             options.actionHandler?.(href, mdStr);
         }
-    }
-    catch (err) {
+    } catch (err) {
         onUnexpectedError(err);
-    }
-    finally {
+    } finally {
         event.preventDefault();
         event.stopPropagation();
     }
@@ -322,17 +354,14 @@ function uriMassage(markdown, part) {
     let data;
     try {
         data = parse(decodeURIComponent(part));
-    }
-    catch (e) {
-    }
+    } catch (e) {}
     if (!data) {
         return part;
     }
     data = cloneAndChange(data, value => {
         if (markdown.uris && markdown.uris[value]) {
             return URI.revive(markdown.uris[value]);
-        }
-        else {
+        } else {
             return undefined;
         }
     });
@@ -342,7 +371,7 @@ function massageHref(markdown, href, isDomUri) {
     const data = markdown.uris && markdown.uris[href];
     let uri = URI.revive(data);
     if (isDomUri) {
-        if (href.startsWith(Schemas.data + ':')) {
+        if (href.startsWith(Schemas.data + ":")) {
             return href;
         }
         if (!uri) {
@@ -357,13 +386,15 @@ function massageHref(markdown, href, isDomUri) {
         return href;
     }
     if (uri.query) {
-        uri = uri.with({ query: uriMassage(markdown, uri.query) });
+        uri = uri.with({
+            query: uriMassage(markdown, uri.query)
+        });
     }
     return ( uri.toString());
 }
 function postProcessCodeBlockLanguageId(lang) {
     if (!lang) {
-        return '';
+        return "";
     }
     const parts = lang.split(/[\s+|:|,|\{|\?]/, 1);
     if (parts.length) {
@@ -376,10 +407,9 @@ function resolveWithBaseUri(baseUri, href) {
     if (hasScheme) {
         return href;
     }
-    if (baseUri.path.endsWith('/')) {
+    if (baseUri.path.endsWith("/")) {
         return ( resolvePath(baseUri, href).toString());
-    }
-    else {
+    } else {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
@@ -389,39 +419,39 @@ function sanitizeRenderedMarkdown(renderedMarkdown, originalMdStrConfig, options
 }
 const allowedMarkdownHtmlTags = ( Object.freeze([
     ...basicMarkupHtmlTags,
-    'input',
+    "input"
 ]));
 const allowedMarkdownHtmlAttributes = ( Object.freeze([
-    'align',
-    'autoplay',
-    'alt',
-    'colspan',
-    'controls',
-    'draggable',
-    'height',
-    'href',
-    'loop',
-    'muted',
-    'playsinline',
-    'poster',
-    'rowspan',
-    'src',
-    'target',
-    'title',
-    'type',
-    'width',
-    'start',
-    'checked',
-    'disabled',
-    'value',
-    'data-code',
-    'data-href',
-    'data-severity',
+    "align",
+    "autoplay",
+    "alt",
+    "colspan",
+    "controls",
+    "draggable",
+    "height",
+    "href",
+    "loop",
+    "muted",
+    "playsinline",
+    "poster",
+    "rowspan",
+    "src",
+    "target",
+    "title",
+    "type",
+    "width",
+    "start",
+    "checked",
+    "disabled",
+    "value",
+    "data-code",
+    "data-href",
+    "data-severity",
     {
-        attributeName: 'style',
+        attributeName: "style",
         shouldKeep: (element, data) => {
-            if (element.tagName === 'SPAN') {
-                if (data.attrName === 'style') {
+            if (element.tagName === "SPAN") {
+                if (data.attrName === "style") {
                     return /^(color\:(#[0-9a-fA-F]+|var\(--vscode(-[a-zA-Z0-9]+)+\));)?(background-color\:(#[0-9a-fA-F]+|var\(--vscode(-[a-zA-Z0-9]+)+\));)?(border-radius:[0-9]+px;)?$/.test(data.attrValue);
                 }
             }
@@ -429,16 +459,16 @@ const allowedMarkdownHtmlAttributes = ( Object.freeze([
         }
     },
     {
-        attributeName: 'class',
+        attributeName: "class",
         shouldKeep: (element, data) => {
-            if (element.tagName === 'SPAN') {
-                if (data.attrName === 'class') {
+            if (element.tagName === "SPAN") {
+                if (data.attrName === "class") {
                     return /^codicon codicon-[a-z\-]+( codicon-modifier-[a-z\-]+)?$/.test(data.attrValue);
                 }
             }
             return false;
-        },
-    },
+        }
+    }
 ]));
 function getDomSanitizerConfig(mdStrConfig, options) {
     const isTrusted = mdStrConfig.isTrusted ?? false;
@@ -451,7 +481,7 @@ function getDomSanitizerConfig(mdStrConfig, options) {
         Schemas.vscodeRemote,
         Schemas.vscodeRemoteResource,
         Schemas.vscodeNotebookCell,
-        Schemas.internal,
+        Schemas.internal
     ];
     if (isTrusted) {
         allowedLinkSchemes.push(Schemas.command);
@@ -464,10 +494,10 @@ function getDomSanitizerConfig(mdStrConfig, options) {
             override: options.allowedTags?.override ?? allowedMarkdownHtmlTags
         },
         allowedAttributes: {
-            override: options.allowedAttributes?.override ?? allowedMarkdownHtmlAttributes,
+            override: options.allowedAttributes?.override ?? allowedMarkdownHtmlAttributes
         },
         allowedLinkProtocols: {
-            override: allowedLinkSchemes,
+            override: allowedLinkSchemes
         },
         allowRelativeLinkPaths: !!mdStrConfig.baseUri,
         allowedMediaProtocols: {
@@ -478,18 +508,18 @@ function getDomSanitizerConfig(mdStrConfig, options) {
                 Schemas.file,
                 Schemas.vscodeFileResource,
                 Schemas.vscodeRemote,
-                Schemas.vscodeRemoteResource,
+                Schemas.vscodeRemoteResource
             ]
         },
         allowRelativeMediaPaths: !!mdStrConfig.baseUri,
-        replaceWithPlaintext: options.replaceWithPlaintext,
+        replaceWithPlaintext: options.replaceWithPlaintext
     };
 }
 function renderAsPlaintext(str, options) {
-    if (typeof str === 'string') {
+    if (typeof str === "string") {
         return str;
     }
-    let value = str.value ?? '';
+    let value = str.value ?? "";
     if (value.length > 100_000) {
         value = `${value.substr(0, 100_000)}…`;
     }
@@ -500,98 +530,169 @@ function renderAsPlaintext(str, options) {
     if (options?.useLinkFormatter) {
         renderer.link = linkFormatter;
     }
-    const html = parse$1(value, { async: false, renderer });
-    return ( sanitizeRenderedMarkdown(html, { isTrusted: false }, {})
-        .toString())
-        .replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m)
-        .trim();
+    const html = parse$1(value, {
+        async: false,
+        renderer
+    });
+    return ( sanitizeRenderedMarkdown(html, {
+        isTrusted: false
+    }, {}).toString()).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m).trim();
 }
 const unescapeInfo = ( new Map([
-    ['&quot;', '"'],
-    ['&nbsp;', ' '],
-    ['&amp;', '&'],
-    ['&#39;', '\''],
-    ['&lt;', '<'],
-    ['&gt;', '>'],
+    ["&quot;", "\""],
+    ["&nbsp;", " "],
+    ["&amp;", "&"],
+    ["&#39;", "'"],
+    ["&lt;", "<"],
+    ["&gt;", ">"]
 ]));
 function createPlainTextRenderer() {
     const renderer = new Renderer();
-    renderer.code = ({ text }) => {
+    renderer.code = (
+        {
+            text
+        }
+    ) => {
         return escape(text);
     };
-    renderer.blockquote = ({ text }) => {
-        return text + '\n';
+    renderer.blockquote = (
+        {
+            text
+        }
+    ) => {
+        return text + "\n";
     };
-    renderer.html = (_) => {
-        return '';
+    renderer.html = _ => {
+        return "";
     };
-    renderer.heading = function ({ tokens }) {
-        return this.parser.parseInline(tokens) + '\n';
+    renderer.heading = function(
+        {
+            tokens
+        }
+    ) {
+        return this.parser.parseInline(tokens) + "\n";
     };
     renderer.hr = () => {
-        return '';
+        return "";
     };
-    renderer.list = function ({ items }) {
-        return ( items.map(x => this.listitem(x))).join('\n') + '\n';
+    renderer.list = function(
+        {
+            items
+        }
+    ) {
+        return ( items.map(x => this.listitem(x))).join("\n") + "\n";
     };
-    renderer.listitem = ({ text }) => {
-        return text + '\n';
+    renderer.listitem = (
+        {
+            text
+        }
+    ) => {
+        return text + "\n";
     };
-    renderer.paragraph = function ({ tokens }) {
-        return this.parser.parseInline(tokens) + '\n';
+    renderer.paragraph = function(
+        {
+            tokens
+        }
+    ) {
+        return this.parser.parseInline(tokens) + "\n";
     };
-    renderer.table = function ({ header, rows }) {
-        return ( header.map(cell => this.tablecell(cell))).join(' ') + '\n' + ( rows.map(cells => ( cells.map(cell => this.tablecell(cell))).join(' '))).join('\n') + '\n';
+    renderer.table = function(
+        {
+            header,
+            rows
+        }
+    ) {
+        return ( header.map(cell => this.tablecell(cell))).join(" ") + "\n" + ( rows.map(cells => ( cells.map(cell => this.tablecell(cell))).join(" "))).join("\n") + "\n";
     };
-    renderer.tablerow = ({ text }) => {
+    renderer.tablerow = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
-    renderer.tablecell = function ({ tokens }) {
+    renderer.tablecell = function(
+        {
+            tokens
+        }
+    ) {
         return this.parser.parseInline(tokens);
     };
-    renderer.strong = ({ text }) => {
+    renderer.strong = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
-    renderer.em = ({ text }) => {
+    renderer.em = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
-    renderer.codespan = ({ text }) => {
+    renderer.codespan = (
+        {
+            text
+        }
+    ) => {
         return escape(text);
     };
-    renderer.br = (_) => {
-        return '\n';
+    renderer.br = _ => {
+        return "\n";
     };
-    renderer.del = ({ text }) => {
+    renderer.del = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
-    renderer.image = (_) => {
-        return '';
+    renderer.image = _ => {
+        return "";
     };
-    renderer.text = ({ text }) => {
+    renderer.text = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
-    renderer.link = ({ text }) => {
+    renderer.link = (
+        {
+            text
+        }
+    ) => {
         return text;
     };
     return renderer;
 }
-const codeBlockFences = ({ text }) => {
+const codeBlockFences = (
+    {
+        text
+    }
+) => {
     return `\n\`\`\`\n${escape(text)}\n\`\`\`\n`;
 };
-const linkFormatter = ({ text, href }) => {
+const linkFormatter = (
+    {
+        text,
+        href
+    }
+) => {
     try {
         if (href) {
             const uri = ( URI.parse(href));
             return text.trim() || basename(uri);
         }
-    }
-    catch (e) {
+    } catch (e) {
         return text.trim() || basename$1(href);
     }
     return text;
 };
 function mergeRawTokenText(tokens) {
-    let mergedTokenText = '';
+    let mergedTokenText = "";
     tokens.forEach(token => {
         mergedTokenText += token.raw;
     });
@@ -603,31 +704,26 @@ function completeSingleLinePattern(token) {
     }
     for (let i = token.tokens.length - 1; i >= 0; i--) {
         const subtoken = token.tokens[i];
-        if (subtoken.type === 'text') {
-            const lines = subtoken.raw.split('\n');
+        if (subtoken.type === "text") {
+            const lines = subtoken.raw.split("\n");
             const lastLine = lines[lines.length - 1];
-            if (lastLine.includes('`')) {
+            if (lastLine.includes("`")) {
                 return completeCodespan(token);
-            }
-            else if (lastLine.includes('**')) {
+            } else if (lastLine.includes("**")) {
                 return completeDoublestar(token);
-            }
-            else if (lastLine.match(/\*\w/)) {
+            } else if (lastLine.match(/\*\w/)) {
                 return completeStar(token);
-            }
-            else if (lastLine.match(/(^|\s)__\w/)) {
+            } else if (lastLine.match(/(^|\s)__\w/)) {
                 return completeDoubleUnderscore(token);
-            }
-            else if (lastLine.match(/(^|\s)_\w/)) {
+            } else if (lastLine.match(/(^|\s)_\w/)) {
                 return completeUnderscore(token);
-            }
-            else if (
+            } else if (
             hasLinkTextAndStartOfLinkTarget(lastLine) ||
-                hasStartOfLinkTargetAndNoLinkText(lastLine) && ( token.tokens.slice(0, i).some(t => t.type === 'text' && t.raw.match(/\[[^\]]*$/)))) {
+            hasStartOfLinkTargetAndNoLinkText(lastLine) && ( token.tokens.slice(0, i).some(t => t.type === "text" && t.raw.match(/\[[^\]]*$/)))) {
                 const nextTwoSubTokens = token.tokens.slice(i + 1);
                 if (
-                nextTwoSubTokens[0]?.type === 'link' && nextTwoSubTokens[1]?.type === 'text' && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/) ||
-                    lastLine.match(/^[^"]* +"[^"]*$/)) {
+                nextTwoSubTokens[0]?.type === "link" && nextTwoSubTokens[1]?.type === "text" && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/) ||
+                lastLine.match(/^[^"]* +"[^"]*$/)) {
                     return completeLinkTargetArg(token);
                 }
                 return completeLinkTarget(token);
@@ -648,23 +744,22 @@ function hasStartOfLinkTargetAndNoLinkText(str) {
 function completeListItemPattern(list) {
     const lastListItem = list.items[list.items.length - 1];
     const lastListSubToken = lastListItem.tokens ? lastListItem.tokens[lastListItem.tokens.length - 1] : undefined;
-    const listEndsInHeading = (list) => {
+    const listEndsInHeading = list => {
         const lastItem = list.items.at(-1);
         const lastToken = lastItem?.tokens.at(-1);
-        return lastToken?.type === 'heading' || lastToken?.type === 'list' && listEndsInHeading(lastToken);
+        return lastToken?.type === "heading" || lastToken?.type === "list" && listEndsInHeading(lastToken);
     };
     let newToken;
-    if (lastListSubToken?.type === 'text' && !('inRawBlock' in lastListItem)) {
+    if (lastListSubToken?.type === "text" && !("inRawBlock" in lastListItem)) {
         newToken = completeSingleLinePattern(lastListSubToken);
-    }
-    else if (listEndsInHeading(list)) {
-        const newList = lexer(list.raw.trim() + ' &nbsp;')[0];
-        if (newList.type !== 'list') {
+    } else if (listEndsInHeading(list)) {
+        const newList = lexer(list.raw.trim() + " &nbsp;")[0];
+        if (newList.type !== "list") {
             return;
         }
         return newList;
     }
-    if (!newToken || newToken.type !== 'paragraph') {
+    if (!newToken || newToken.type !== "paragraph") {
         return;
     }
     const previousListItemsText = mergeRawTokenText(list.items.slice(0, -1));
@@ -672,18 +767,16 @@ function completeListItemPattern(list) {
     if (!lastListItemLead) {
         return;
     }
-    const newListItemText = lastListItemLead +
-        mergeRawTokenText(lastListItem.tokens.slice(0, -1)) +
-        newToken.raw;
+    const newListItemText = lastListItemLead + mergeRawTokenText(lastListItem.tokens.slice(0, -1)) + newToken.raw;
     const newList = lexer(previousListItemsText + newListItemText)[0];
-    if (newList.type !== 'list') {
+    if (newList.type !== "list") {
         return;
     }
     return newList;
 }
 function completeHeading(token, fullRawText) {
     if (token.raw.match(/-\s*$/)) {
-        return lexer(fullRawText + ' &nbsp;');
+        return lexer(fullRawText + " &nbsp;");
     }
 }
 const maxIncompleteTokensFixRounds = 3;
@@ -692,8 +785,7 @@ function fillInIncompleteTokens(tokens) {
         const newTokens = fillInIncompleteTokensOnce(tokens);
         if (newTokens) {
             tokens = newTokens;
-        }
-        else {
+        } else {
             break;
         }
     }
@@ -704,20 +796,20 @@ function fillInIncompleteTokensOnce(tokens) {
     let newTokens;
     for (i = 0; i < tokens.length; i++) {
         const token = tokens[i];
-        if (token.type === 'paragraph' && token.raw.match(/(\n|^)\|/)) {
+        if (token.type === "paragraph" && token.raw.match(/(\n|^)\|/)) {
             newTokens = completeTable(tokens.slice(i));
             break;
         }
     }
     const lastToken = tokens.at(-1);
-    if (!newTokens && lastToken?.type === 'list') {
+    if (!newTokens && lastToken?.type === "list") {
         const newListToken = completeListItemPattern(lastToken);
         if (newListToken) {
             newTokens = [newListToken];
             i = tokens.length - 1;
         }
     }
-    if (!newTokens && lastToken?.type === 'paragraph') {
+    if (!newTokens && lastToken?.type === "paragraph") {
         const newToken = completeSingleLinePattern(lastToken);
         if (newToken) {
             newTokens = [newToken];
@@ -725,14 +817,11 @@ function fillInIncompleteTokensOnce(tokens) {
         }
     }
     if (newTokens) {
-        const newTokensList = [
-            ...tokens.slice(0, i),
-            ...newTokens
-        ];
+        const newTokensList = [...tokens.slice(0, i), ...newTokens];
         newTokensList.links = tokens.links;
         return newTokensList;
     }
-    if (lastToken?.type === 'heading') {
+    if (lastToken?.type === "heading") {
         const completeTokens = completeHeading(lastToken, mergeRawTokenText(tokens));
         if (completeTokens) {
             return completeTokens;
@@ -741,28 +830,28 @@ function fillInIncompleteTokensOnce(tokens) {
     return null;
 }
 function completeCodespan(token) {
-    return completeWithString(token, '`');
+    return completeWithString(token, "`");
 }
 function completeStar(tokens) {
-    return completeWithString(tokens, '*');
+    return completeWithString(tokens, "*");
 }
 function completeUnderscore(tokens) {
-    return completeWithString(tokens, '_');
+    return completeWithString(tokens, "_");
 }
 function completeLinkTarget(tokens) {
-    return completeWithString(tokens, ')', false);
+    return completeWithString(tokens, ")", false);
 }
 function completeLinkTargetArg(tokens) {
-    return completeWithString(tokens, '")', false);
+    return completeWithString(tokens, "\")", false);
 }
 function completeLinkText(tokens) {
-    return completeWithString(tokens, '](https://microsoft.com)', false);
+    return completeWithString(tokens, "](https://microsoft.com)", false);
 }
 function completeDoublestar(tokens) {
-    return completeWithString(tokens, '**');
+    return completeWithString(tokens, "**");
 }
 function completeDoubleUnderscore(tokens) {
-    return completeWithString(tokens, '__');
+    return completeWithString(tokens, "__");
 }
 function completeWithString(tokens, closingString, shouldTrim = true) {
     const mergedRawText = mergeRawTokenText(Array.isArray(tokens) ? tokens : [tokens]);
@@ -771,33 +860,31 @@ function completeWithString(tokens, closingString, shouldTrim = true) {
 }
 function completeTable(tokens) {
     const mergedRawText = mergeRawTokenText(tokens);
-    const lines = mergedRawText.split('\n');
+    const lines = mergedRawText.split("\n");
     let numCols;
     let hasSeparatorRow = false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i].trim();
-        if (typeof numCols === 'undefined' && line.match(/^\s*\|/)) {
+        if (typeof numCols === "undefined" && line.match(/^\s*\|/)) {
             const line1Matches = line.match(/(\|[^\|]+)(?=\||$)/g);
             if (line1Matches) {
                 numCols = line1Matches.length;
             }
-        }
-        else if (typeof numCols === 'number') {
+        } else if (typeof numCols === "number") {
             if (line.match(/^\s*\|/)) {
                 if (i !== lines.length - 1) {
                     return undefined;
                 }
                 hasSeparatorRow = true;
-            }
-            else {
+            } else {
                 return undefined;
             }
         }
     }
-    if (typeof numCols === 'number' && numCols > 0) {
-        const prefixText = hasSeparatorRow ? lines.slice(0, -1).join('\n') : mergedRawText;
+    if (typeof numCols === "number" && numCols > 0) {
+        const prefixText = hasSeparatorRow ? lines.slice(0, -1).join("\n") : mergedRawText;
         const line1EndsInPipe = !!prefixText.match(/\|\s*$/);
-        const newRawText = prefixText + (line1EndsInPipe ? '' : '|') + `\n|${' --- |'.repeat(numCols)}`;
+        const newRawText = prefixText + (line1EndsInPipe ? "" : "|") + `\n|${" --- |".repeat(numCols)}`;
         return lexer(newRawText);
     }
     return undefined;