@codingame/monaco-vscode-api 5.3.0 → 6.0.0

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

@@ -37,31 +37,43 @@ class StringStream {
         this.index++;
     }
 }
+var FormatType;
+( (function(FormatType) {
+    FormatType[FormatType["Invalid"] = 0] = "Invalid";
+    FormatType[FormatType["Root"] = 1] = "Root";
+    FormatType[FormatType["Text"] = 2] = "Text";
+    FormatType[FormatType["Bold"] = 3] = "Bold";
+    FormatType[FormatType["Italics"] = 4] = "Italics";
+    FormatType[FormatType["Action"] = 5] = "Action";
+    FormatType[FormatType["ActionClose"] = 6] = "ActionClose";
+    FormatType[FormatType["Code"] = 7] = "Code";
+    FormatType[FormatType["NewLine"] = 8] = "NewLine";
+})(FormatType || (FormatType = {})));
 function _renderFormattedText(element, treeNode, actionHandler, renderCodeSegments) {
     let child;
-    if (treeNode.type === 2 ) {
+    if (treeNode.type === FormatType.Text) {
         child = document.createTextNode(treeNode.content || '');
     }
-    else if (treeNode.type === 3 ) {
+    else if (treeNode.type === FormatType.Bold) {
         child = document.createElement('b');
     }
-    else if (treeNode.type === 4 ) {
+    else if (treeNode.type === FormatType.Italics) {
         child = document.createElement('i');
     }
-    else if (treeNode.type === 7  && renderCodeSegments) {
+    else if (treeNode.type === FormatType.Code && renderCodeSegments) {
         child = document.createElement('code');
     }
-    else if (treeNode.type === 5  && actionHandler) {
+    else if (treeNode.type === FormatType.Action && actionHandler) {
         const a = document.createElement('a');
         actionHandler.disposables.add(addStandardDisposableListener(a, 'click', (event) => {
             actionHandler.callback(String(treeNode.index), event);
         }));
         child = a;
     }
-    else if (treeNode.type === 8 ) {
+    else if (treeNode.type === FormatType.NewLine) {
         child = document.createElement('br');
     }
-    else if (treeNode.type === 1 ) {
+    else if (treeNode.type === FormatType.Root) {
         child = element;
     }
     if (child && element !== child) {
@@ -75,7 +87,7 @@ function _renderFormattedText(element, treeNode, actionHandler, renderCodeSegmen
 }
 function parseFormattedText(content, parseCodeSegments) {
     const root = {
-        type: 1 ,
+        type: FormatType.Root,
         children: []
     };
     let actionViewItemIndex = 0;
@@ -84,17 +96,17 @@ function parseFormattedText(content, parseCodeSegments) {
     const stream = ( new StringStream(content));
     while (!stream.eos()) {
         let next = stream.next();
-        const isEscapedFormatType = ((next === '\\' && formatTagType(stream.peek(), parseCodeSegments) !== 0) );
+        const isEscapedFormatType = (next === '\\' && formatTagType(stream.peek(), parseCodeSegments) !== FormatType.Invalid);
         if (isEscapedFormatType) {
             next = stream.next();
         }
         if (!isEscapedFormatType && isFormatTag(next, parseCodeSegments) && next === stream.peek()) {
             stream.advance();
-            if (current.type === 2 ) {
+            if (current.type === FormatType.Text) {
                 current = stack.pop();
             }
             const type = formatTagType(next, parseCodeSegments);
-            if (current.type === type || ((current.type === 5  && type === 6) )) {
+            if (current.type === type || (current.type === FormatType.Action && type === FormatType.ActionClose)) {
                 current = stack.pop();
             }
             else {
@@ -102,7 +114,7 @@ function parseFormattedText(content, parseCodeSegments) {
                     type: type,
                     children: []
                 };
-                if (type === 5 ) {
+                if (type === FormatType.Action) {
                     newCurrent.index = actionViewItemIndex;
                     actionViewItemIndex++;
                 }
@@ -112,17 +124,17 @@ function parseFormattedText(content, parseCodeSegments) {
             }
         }
         else if (next === '\n') {
-            if (current.type === 2 ) {
+            if (current.type === FormatType.Text) {
                 current = stack.pop();
             }
             current.children.push({
-                type: 8
+                type: FormatType.NewLine
             });
         }
         else {
-            if (current.type !== 2 ) {
+            if (current.type !== FormatType.Text) {
                 const textCurrent = {
-                    type: 2 ,
+                    type: FormatType.Text,
                     content: next
                 };
                 current.children.push(textCurrent);
@@ -134,28 +146,28 @@ function parseFormattedText(content, parseCodeSegments) {
             }
         }
     }
-    if (current.type === 2 ) {
+    if (current.type === FormatType.Text) {
         current = stack.pop();
     }
     return root;
 }
 function isFormatTag(char, supportCodeSegments) {
-    return formatTagType(char, supportCodeSegments) !== 0 ;
+    return formatTagType(char, supportCodeSegments) !== FormatType.Invalid;
 }
 function formatTagType(char, supportCodeSegments) {
     switch (char) {
         case '*':
-            return 3 ;
+            return FormatType.Bold;
         case '_':
-            return 4 ;
+            return FormatType.Italics;
         case '[':
-            return 5 ;
+            return FormatType.Action;
         case ']':
-            return 6 ;
+            return FormatType.ActionClose;
         case '`':
-            return supportCodeSegments ? 7  : 0 ;
+            return supportCodeSegments ? FormatType.Code : FormatType.Invalid;
         default:
-            return 0 ;
+            return FormatType.Invalid;
     }
 }
 export { createElement, renderFormattedText, renderText };

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

@@ -1,5 +1,5 @@
 import { isFirefox, isWebKit } from './browser.js';
-import { KeyCodeUtils, EVENT_KEY_CODE_MAP } from '../common/keyCodes.js';
+import { KeyCode, KeyCodeUtils, EVENT_KEY_CODE_MAP, KeyMod as KeyMod$1 } from '../common/keyCodes.js';
 import { KeyCodeChord } from '../common/keybindings.js';
 import { isMacintosh, isLinux } from '../common/platform.js';
 function extractKeyCode(e) {
@@ -9,41 +9,41 @@ function extractKeyCode(e) {
     }
     const keyCode = e.keyCode;
     if (keyCode === 3) {
-        return 7 ;
+        return KeyCode.PauseBreak;
     }
     else if (isFirefox) {
         switch (keyCode) {
-            case 59: return 85 ;
+            case 59: return KeyCode.Semicolon;
             case 60:
                 if (isLinux) {
-                    return 97 ;
+                    return KeyCode.IntlBackslash;
                 }
                 break;
-            case 61: return 86 ;
-            case 107: return 109 ;
-            case 109: return 111 ;
-            case 173: return 88 ;
+            case 61: return KeyCode.Equal;
+            case 107: return KeyCode.NumpadAdd;
+            case 109: return KeyCode.NumpadSubtract;
+            case 173: return KeyCode.Minus;
             case 224:
                 if (isMacintosh) {
-                    return 57 ;
+                    return KeyCode.Meta;
                 }
                 break;
         }
     }
     else if (isWebKit) {
         if (isMacintosh && keyCode === 93) {
-            return 57 ;
+            return KeyCode.Meta;
         }
         else if (!isMacintosh && keyCode === 92) {
-            return 57 ;
+            return KeyCode.Meta;
         }
     }
-    return EVENT_KEY_CODE_MAP[keyCode] || 0 ;
+    return EVENT_KEY_CODE_MAP[keyCode] || KeyCode.Unknown;
 }
-const ctrlKeyMod = ((isMacintosh ? 256  : 2048) );
-const altKeyMod = 512 ;
-const shiftKeyMod = 1024 ;
-const metaKeyMod = ((isMacintosh ? 2048  : 256) );
+const ctrlKeyMod = (isMacintosh ? KeyMod$1.WinCtrl : KeyMod$1.CtrlCmd);
+const altKeyMod = KeyMod$1.Alt;
+const shiftKeyMod = KeyMod$1.Shift;
+const metaKeyMod = (isMacintosh ? KeyMod$1.CtrlCmd : KeyMod$1.WinCtrl);
 function printKeyboardEvent(e) {
     const modifiers = [];
     if (e.ctrlKey) {
@@ -89,10 +89,10 @@ class StandardKeyboardEvent {
         this.altGraphKey = e.getModifierState?.('AltGraph');
         this.keyCode = extractKeyCode(e);
         this.code = e.code;
-        this.ctrlKey = this.ctrlKey || this.keyCode === 5 ;
-        this.altKey = this.altKey || this.keyCode === 6 ;
-        this.shiftKey = this.shiftKey || this.keyCode === 4 ;
-        this.metaKey = this.metaKey || this.keyCode === 57 ;
+        this.ctrlKey = this.ctrlKey || this.keyCode === KeyCode.Ctrl;
+        this.altKey = this.altKey || this.keyCode === KeyCode.Alt;
+        this.shiftKey = this.shiftKey || this.keyCode === KeyCode.Shift;
+        this.metaKey = this.metaKey || this.keyCode === KeyCode.Meta;
         this._asKeybinding = this._computeKeybinding();
         this._asKeyCodeChord = this._computeKeyCodeChord();
     }
@@ -113,8 +113,8 @@ class StandardKeyboardEvent {
         return this._asKeybinding === other;
     }
     _computeKeybinding() {
-        let key = 0 ;
-        if (this.keyCode !== 5  && this.keyCode !== 4  && this.keyCode !== 6  && this.keyCode !== 57 ) {
+        let key = KeyCode.Unknown;
+        if (this.keyCode !== KeyCode.Ctrl && this.keyCode !== KeyCode.Shift && this.keyCode !== KeyCode.Alt && this.keyCode !== KeyCode.Meta) {
             key = this.keyCode;
         }
         let result = 0;
@@ -134,8 +134,8 @@ class StandardKeyboardEvent {
         return result;
     }
     _computeKeyCodeChord() {
-        let key = 0 ;
-        if (this.keyCode !== 5  && this.keyCode !== 4  && this.keyCode !== 6  && this.keyCode !== 57 ) {
+        let key = KeyCode.Unknown;
+        if (this.keyCode !== KeyCode.Ctrl && this.keyCode !== KeyCode.Shift && this.keyCode !== KeyCode.Alt && this.keyCode !== KeyCode.Meta) {
             key = this.keyCode;
         }
         return ( new KeyCodeChord(this.ctrlKey, this.shiftKey, this.altKey, this.metaKey, key));

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

@@ -1,5 +1,5 @@
 import { getWindow, addDisposableListener, $, reset, hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from './dom.js';
-import { addHook, sanitize, removeHook } from './dompurify/dompurify.js';
+import { sanitize, addHook, removeHook } from './dompurify/dompurify.js';
 import { DomEmitter } from './event.js';
 import { createElement } from './formattedTextRenderer.js';
 import { StandardKeyboardEvent } from './keyboardEvent.js';
@@ -10,8 +10,9 @@ import { Event } from '../common/event.js';
 import { parseHrefAndDimensions, escapeDoubleQuotes, removeMarkdownEscapes } from '../common/htmlContent.js';
 import { markdownEscapeEscapedIcons } from '../common/iconLabels.js';
 import { defaultGenerator } from '../common/idGenerator.js';
+import { KeyCode } from '../common/keyCodes.js';
 import { Lazy } from '../common/lazy.js';
-import { DisposableStore } from '../common/lifecycle.js';
+import { toDisposable, DisposableStore } from '../common/lifecycle.js';
 import marked_1 from '../../../../../external/vscode-marked/lib/marked.esm.js';
 import { parse } from '../common/marshalling.js';
 import { Schemas, FileAccess } from '../common/network.js';
@@ -163,7 +164,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
         }));
         options.actionHandler.disposables.add(addDisposableListener(element, 'keydown', (e) => {
             const keyboardEvent = ( new StandardKeyboardEvent(e));
-            if (!keyboardEvent.equals(10 ) && !keyboardEvent.equals(3 )) {
+            if (!keyboardEvent.equals(KeyCode.Space) && !keyboardEvent.equals(KeyCode.Enter)) {
                 return;
             }
             _activateLink(keyboardEvent);
@@ -171,6 +172,9 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
     }
     if (!markdown.supportHtml) {
         markedOptions.sanitizer = (html) => {
+            if (options.sanitizerOptions?.replaceWithPlaintext) {
+                return escape(html);
+            }
             const match = markdown.isTrusted ? html.match(/^(<span[^>]+>)|(<\/\s*span>)$/) : undefined;
             return match ? html : '';
         };
@@ -203,7 +207,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
         renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
     }
     const htmlParser = ( new DOMParser());
-    const markdownHtmlDoc = htmlParser.parseFromString(sanitizeRenderedMarkdown(markdown, renderedMarkdown), 'text/html');
+    const markdownHtmlDoc = htmlParser.parseFromString(sanitizeRenderedMarkdown({ isTrusted: markdown.isTrusted, ...options.sanitizerOptions }, renderedMarkdown), 'text/html');
     markdownHtmlDoc.body.querySelectorAll('img, audio, video, source')
         .forEach(img => {
         const src = img.getAttribute('src');
@@ -216,9 +220,9 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
             }
             catch (err) { }
             img.setAttribute('src', _href(href, true));
-            if (options.disallowRemoteImages) {
-                const uriScheme = ( URI.parse(href)).scheme;
-                if (uriScheme !== Schemas.file && uriScheme !== Schemas.data) {
+            if (options.remoteImageIsAllowed) {
+                const uri = ( URI.parse(href));
+                if (uri.scheme !== Schemas.file && uri.scheme !== Schemas.data && !options.remoteImageIsAllowed(uri)) {
                     img.replaceWith($('', undefined, img.outerHTML));
                 }
             }
@@ -242,7 +246,7 @@ function renderMarkdown(markdown, options = {}, markedOptions = {}) {
             a.dataset.href = resolvedHref;
         }
     });
-    element.innerHTML = sanitizeRenderedMarkdown(markdown, markdownHtmlDoc.body.innerHTML);
+    element.innerHTML = sanitizeRenderedMarkdown({ isTrusted: markdown.isTrusted, ...options.sanitizerOptions }, markdownHtmlDoc.body.innerHTML);
     if (codeBlocks.length > 0) {
         Promise.all(codeBlocks).then((tuples) => {
             if (isDisposed) {
@@ -307,9 +311,11 @@ function resolveWithBaseUri(baseUri, href) {
         return ( resolvePath(dirname(baseUri), href).toString());
     }
 }
+const selfClosingTags = ['area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 function sanitizeRenderedMarkdown(options, renderedMarkdown) {
     const { config, allowedSchemes } = getSanitizerOptions(options);
-    addHook('uponSanitizeAttribute', (element, e) => {
+    const store = ( new DisposableStore());
+    store.add(addDompurifyHook('uponSanitizeAttribute', (element, e) => {
         if (e.attrName === 'style' || e.attrName === 'class') {
             if (element.tagName === 'SPAN') {
                 if (e.attrName === 'style') {
@@ -331,24 +337,55 @@ function sanitizeRenderedMarkdown(options, renderedMarkdown) {
             }
             e.keepAttr = false;
         }
-    });
-    addHook('uponSanitizeElement', (element, e) => {
+    }));
+    store.add(addDompurifyHook('uponSanitizeElement', (element, e) => {
         if (e.tagName === 'input') {
             if (element.attributes.getNamedItem('type')?.value === 'checkbox') {
                 element.setAttribute('disabled', '');
             }
-            else {
+            else if (!options.replaceWithPlaintext) {
                 element.parentElement?.removeChild(element);
             }
         }
-    });
-    const hook = hookDomPurifyHrefAndSrcSanitizer(allowedSchemes);
+        if (options.replaceWithPlaintext && !e.allowedTags[e.tagName] && e.tagName !== 'body') {
+            if (element.parentElement) {
+                let startTagText;
+                let endTagText;
+                if (e.tagName === '#comment') {
+                    startTagText = `<!--${element.textContent}-->`;
+                }
+                else {
+                    const isSelfClosing = selfClosingTags.includes(e.tagName);
+                    const attrString = element.attributes.length ?
+                        ' ' + ( Array.from(element.attributes)
+                            .map(attr => `${attr.name}="${attr.value}"`))
+                            .join(' ')
+                        : '';
+                    startTagText = `<${e.tagName}${attrString}>`;
+                    if (!isSelfClosing) {
+                        endTagText = `</${e.tagName}>`;
+                    }
+                }
+                const fragment = document.createDocumentFragment();
+                const textNode = element.parentElement.ownerDocument.createTextNode(startTagText);
+                fragment.appendChild(textNode);
+                const endTagTextNode = endTagText ? element.parentElement.ownerDocument.createTextNode(endTagText) : undefined;
+                while (element.firstChild) {
+                    fragment.appendChild(element.firstChild);
+                }
+                if (endTagTextNode) {
+                    fragment.appendChild(endTagTextNode);
+                }
+                element.parentElement.replaceChild(fragment, element);
+            }
+        }
+    }));
+    store.add(hookDomPurifyHrefAndSrcSanitizer(allowedSchemes));
     try {
         return sanitize(renderedMarkdown, { ...config, RETURN_TRUSTED_TYPE: true });
     }
     finally {
-        removeHook('uponSanitizeAttribute');
-        hook.dispose();
+        store.dispose();
     }
 }
 const allowedMarkdownAttr = [
@@ -392,7 +429,7 @@ function getSanitizerOptions(options) {
     }
     return {
         config: {
-            ALLOWED_TAGS: [...basicMarkupHtmlTags],
+            ALLOWED_TAGS: options.allowedTags ?? [...basicMarkupHtmlTags],
             ALLOWED_ATTR: allowedMarkdownAttr,
             ALLOW_UNKNOWN_PROTOCOLS: true,
         },
@@ -402,12 +439,12 @@ function getSanitizerOptions(options) {
 function renderStringAsPlaintext(string) {
     return typeof string === 'string' ? string : renderMarkdownAsPlaintext(string);
 }
-function renderMarkdownAsPlaintext(markdown) {
+function renderMarkdownAsPlaintext(markdown, withCodeBlocks) {
     let value = markdown.value ?? '';
     if (value.length > 100_000) {
         value = `${value.substr(0, 100_000)}…`;
     }
-    const html = marked_1.parse(value, { renderer: plainTextRenderer.value }).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m);
+    const html = marked_1.parse(value, { renderer: withCodeBlocks ? plainTextWithCodeBlocksRenderer.value : plainTextRenderer.value }).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m);
     return ( sanitizeRenderedMarkdown({ isTrusted: false }, html).toString());
 }
 const unescapeInfo = ( new Map([
@@ -418,7 +455,7 @@ const unescapeInfo = ( new Map([
     ['&lt;', '<'],
     ['&gt;', '>'],
 ]));
-const plainTextRenderer = ( new Lazy(() => {
+function createRenderer() {
     const renderer = new marked_1.Renderer();
     renderer.code = (code) => {
         return code;
@@ -478,6 +515,14 @@ const plainTextRenderer = ( new Lazy(() => {
         return text;
     };
     return renderer;
+}
+const plainTextRenderer = ( new Lazy((withCodeBlocks) => createRenderer()));
+const plainTextWithCodeBlocksRenderer = ( new Lazy(() => {
+    const renderer = createRenderer();
+    renderer.code = (code) => {
+        return '\n' + '```' + code + '```' + '\n';
+    };
+    return renderer;
 }));
 function mergeRawTokenText(tokens) {
     let mergedTokenText = '';
@@ -487,7 +532,10 @@ function mergeRawTokenText(tokens) {
     return mergedTokenText;
 }
 function completeSingleLinePattern(token) {
-    for (let i = 0; i < token.tokens.length; i++) {
+    if (!token.tokens) {
+        return undefined;
+    }
+    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');
@@ -507,27 +555,68 @@ function completeSingleLinePattern(token) {
             else if (lastLine.match(/(^|\s)_\w/)) {
                 return completeUnderscore(token);
             }
-            else if (lastLine.match(/(^|\s)\[.*\]\(\w*/)) {
+            else if (
+            hasLinkTextAndStartOfLinkTarget(lastLine) ||
+                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(/^ *"[^"]*$/)) {
+                if (
+                nextTwoSubTokens[0]?.type === 'link' && nextTwoSubTokens[1]?.type === 'text' && nextTwoSubTokens[1].raw.match(/^ *"[^"]*$/) ||
+                    lastLine.match(/^[^"]* +"[^"]*$/)) {
                     return completeLinkTargetArg(token);
                 }
                 return completeLinkTarget(token);
             }
-            else if (hasStartOfLinkTarget(lastLine)) {
-                return completeLinkTarget(token);
-            }
-            else if (lastLine.match(/(^|\s)\[\w/) && !( token.tokens.slice(i + 1).some(t => hasStartOfLinkTarget(t.raw)))) {
+            else if (lastLine.match(/(^|\s)\[\w*/)) {
                 return completeLinkText(token);
             }
         }
     }
     return undefined;
 }
-function hasStartOfLinkTarget(str) {
+function hasLinkTextAndStartOfLinkTarget(str) {
+    return !!str.match(/(^|\s)\[.*\]\(\w*/);
+}
+function hasStartOfLinkTargetAndNoLinkText(str) {
     return !!str.match(/^[^\[]*\]\([^\)]*$/);
 }
+function completeListItemPattern(list) {
+    const lastListItem = list.items[list.items.length - 1];
+    const lastListSubToken = lastListItem.tokens ? lastListItem.tokens[lastListItem.tokens.length - 1] : undefined;
+    let newToken;
+    if (lastListSubToken?.type === 'text' && !('inRawBlock' in lastListItem)) {
+        newToken = completeSingleLinePattern(lastListSubToken);
+    }
+    if (!newToken || newToken.type !== 'paragraph') {
+        return;
+    }
+    const previousListItemsText = mergeRawTokenText(list.items.slice(0, -1));
+    const lastListItemLead = lastListItem.raw.match(/^(\s*(-|\d+\.) +)/)?.[0];
+    if (!lastListItemLead) {
+        return;
+    }
+    const newListItemText = lastListItemLead +
+        mergeRawTokenText(lastListItem.tokens.slice(0, -1)) +
+        newToken.raw;
+    const newList = marked_1.lexer(previousListItemsText + newListItemText)[0];
+    if (newList.type !== 'list') {
+        return;
+    }
+    return newList;
+}
+const maxIncompleteTokensFixRounds = 3;
 function fillInIncompleteTokens(tokens) {
+    for (let i = 0; i < maxIncompleteTokensFixRounds; i++) {
+        const newTokens = fillInIncompleteTokensOnce(tokens);
+        if (newTokens) {
+            tokens = newTokens;
+        }
+        else {
+            break;
+        }
+    }
+    return tokens;
+}
+function fillInIncompleteTokensOnce(tokens) {
     let i;
     let newTokens;
     for (i = 0; i < tokens.length; i++) {
@@ -542,6 +631,13 @@ function fillInIncompleteTokens(tokens) {
             newTokens = completeTable(tokens.slice(i));
             break;
         }
+        if (i === tokens.length - 1 && token.type === 'list') {
+            const newListToken = completeListItemPattern(token);
+            if (newListToken) {
+                newTokens = [newListToken];
+                break;
+            }
+        }
         if (i === tokens.length - 1 && token.type === 'paragraph') {
             const newToken = completeSingleLinePattern(token);
             if (newToken) {
@@ -558,7 +654,7 @@ function fillInIncompleteTokens(tokens) {
         newTokensList.links = tokens.links;
         return newTokensList;
     }
-    return tokens;
+    return null;
 }
 function completeCodeBlock(tokens, leader) {
     const mergedRawText = mergeRawTokenText(tokens);
@@ -580,7 +676,7 @@ function completeLinkTargetArg(tokens) {
     return completeWithString(tokens, '")');
 }
 function completeLinkText(tokens) {
-    return completeWithString(tokens, '](about:blank)');
+    return completeWithString(tokens, '](https://microsoft.com)');
 }
 function completeDoublestar(tokens) {
     return completeWithString(tokens, '**');
@@ -625,4 +721,8 @@ function completeTable(tokens) {
     }
     return undefined;
 }
+function addDompurifyHook(hook, cb) {
+    addHook(hook, cb);
+    return toDisposable(() => removeHook(hook));
+}
 export { allowedMarkdownAttr, fillInIncompleteTokens, renderMarkdown, renderMarkdownAsPlaintext, renderStringAsPlaintext };

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

@@ -5,42 +5,48 @@ var inputLatency;
     const totalRenderTime = { ...totalKeydownTime };
     const totalInputLatencyTime = { ...totalKeydownTime };
     let measurementsCount = 0;
+    let EventPhase;
+    ( (function(EventPhase) {
+        EventPhase[EventPhase["Before"] = 0] = "Before";
+        EventPhase[EventPhase["InProgress"] = 1] = "InProgress";
+        EventPhase[EventPhase["Finished"] = 2] = "Finished";
+    })(EventPhase || (EventPhase = {})));
     const state = {
-        keydown: 0 ,
-        input: 0 ,
-        render: 0 ,
+        keydown: EventPhase.Before,
+        input: EventPhase.Before,
+        render: EventPhase.Before,
     };
     function onKeyDown() {
         recordIfFinished();
         performance.mark('inputlatency/start');
         performance.mark('keydown/start');
-        state.keydown = 1 ;
+        state.keydown = EventPhase.InProgress;
         queueMicrotask(markKeyDownEnd);
     }
     inputLatency.onKeyDown = onKeyDown;
     function markKeyDownEnd() {
-        if (state.keydown === 1 ) {
+        if (state.keydown === EventPhase.InProgress) {
             performance.mark('keydown/end');
-            state.keydown = 2 ;
+            state.keydown = EventPhase.Finished;
         }
     }
     function onBeforeInput() {
         performance.mark('input/start');
-        state.input = 1 ;
+        state.input = EventPhase.InProgress;
         scheduleRecordIfFinishedTask();
     }
     inputLatency.onBeforeInput = onBeforeInput;
     function onInput() {
-        if (state.input === 0 ) {
+        if (state.input === EventPhase.Before) {
             onBeforeInput();
         }
         queueMicrotask(markInputEnd);
     }
     inputLatency.onInput = onInput;
     function markInputEnd() {
-        if (state.input === 1 ) {
+        if (state.input === EventPhase.InProgress) {
             performance.mark('input/end');
-            state.input = 2 ;
+            state.input = EventPhase.Finished;
         }
     }
     function onKeyUp() {
@@ -52,25 +58,25 @@ var inputLatency;
     }
     inputLatency.onSelectionChange = onSelectionChange;
     function onRenderStart() {
-        if (state.keydown === 2  && state.input === 2  && state.render === 0 ) {
+        if (state.keydown === EventPhase.Finished && state.input === EventPhase.Finished && state.render === EventPhase.Before) {
             performance.mark('render/start');
-            state.render = 1 ;
+            state.render = EventPhase.InProgress;
             queueMicrotask(markRenderEnd);
             scheduleRecordIfFinishedTask();
         }
     }
     inputLatency.onRenderStart = onRenderStart;
     function markRenderEnd() {
-        if (state.render === 1 ) {
+        if (state.render === EventPhase.InProgress) {
             performance.mark('render/end');
-            state.render = 2 ;
+            state.render = EventPhase.Finished;
         }
     }
     function scheduleRecordIfFinishedTask() {
         setTimeout(recordIfFinished);
     }
     function recordIfFinished() {
-        if (state.keydown === 2  && state.input === 2  && state.render === 2 ) {
+        if (state.keydown === EventPhase.Finished && state.input === EventPhase.Finished && state.render === EventPhase.Finished) {
             performance.mark('inputlatency/end');
             performance.measure('keydown', 'keydown/start', 'keydown/end');
             performance.measure('input', 'input/start', 'input/end');
@@ -103,9 +109,9 @@ var inputLatency;
         performance.clearMeasures('input');
         performance.clearMeasures('render');
         performance.clearMeasures('inputlatency');
-        state.keydown = 0 ;
-        state.input = 0 ;
-        state.render = 0 ;
+        state.keydown = EventPhase.Before;
+        state.input = EventPhase.Before;
+        state.render = EventPhase.Before;
     }
     function getAndClearMeasurements() {
         if (measurementsCount === 0) {