@codingame/monaco-vscode-api 19.1.4 → 20.0.0

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

@@ -6,10 +6,9 @@ import { StandardMouseEvent } from './mouseEvent.js';
 import { _runWhenIdle, AbstractIdleValue, IntervalTimer, TimeoutTimer } from '../common/async.js';
 import { onUnexpectedError, BugIndicatingError } from '../common/errors.js';
 import { Emitter, Event } from '../common/event.js';
-import dompurify from 'dompurify';
 import { KeyCode } from '../common/keyCodes.js';
 import { DisposableStore, Disposable, toDisposable } from '../common/lifecycle.js';
-import { RemoteAuthorities, Schemas } from '../common/network.js';
+import { RemoteAuthorities } from '../common/network.js';
 import { isIOS, isMacintosh, isLinux } from '../common/platform.js';
 import { URI } from '../common/uri.js';
 import { hash } from '../common/hash.js';
@@ -1012,6 +1011,25 @@ function triggerUpload() {
         setTimeout(() => input.remove());
     }));
 }
+async function triggerNotification(message, options) {
+    const permission = await Notification.requestPermission();
+    if (permission !== 'granted') {
+        return;
+    }
+    const disposables = ( new DisposableStore());
+    const notification = ( new Notification(message, {
+        body: options?.detail,
+        requireInteraction: options?.sticky
+    }));
+    const onClick = new Emitter();
+    disposables.add(addDisposableListener(notification, 'click', () => onClick.fire()));
+    disposables.add(addDisposableListener(notification, 'close', () => disposables.dispose()));
+    disposables.add(toDisposable(() => notification.close()));
+    return {
+        onClick: onClick.event,
+        dispose: () => disposables.dispose()
+    };
+}
 var DetectedFullscreenMode;
 (function (DetectedFullscreenMode) {
     DetectedFullscreenMode[DetectedFullscreenMode["DOCUMENT"] = 1] = "DOCUMENT";
@@ -1033,135 +1051,6 @@ function detectFullscreen(targetWindow, containerElement) {
     }
     return null;
 }
-function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = false) {
-    const anchor = createElement('a');
-    dompurify.addHook('afterSanitizeAttributes', (node) => {
-        for (const attr of ['href', 'src']) {
-            if (node.hasAttribute(attr)) {
-                const attrValue = node.getAttribute(attr);
-                if (attr === 'href' && attrValue.startsWith('#')) {
-                    continue;
-                }
-                anchor.href = attrValue;
-                if (!allowedProtocols.includes(anchor.protocol.replace(/:$/, ''))) {
-                    if (allowDataImages && attr === 'src' && anchor.href.startsWith('data:')) {
-                        continue;
-                    }
-                    node.removeAttribute(attr);
-                }
-            }
-        }
-    });
-    return toDisposable(() => {
-        dompurify.removeHook('afterSanitizeAttributes');
-    });
-}
-const defaultSafeProtocols = [
-    Schemas.http,
-    Schemas.https,
-    Schemas.command,
-];
-const basicMarkupHtmlTags = ( Object.freeze([
-    'a',
-    'abbr',
-    'b',
-    'bdo',
-    'blockquote',
-    'br',
-    'caption',
-    'cite',
-    'code',
-    'col',
-    'colgroup',
-    'dd',
-    'del',
-    'details',
-    'dfn',
-    'div',
-    'dl',
-    'dt',
-    'em',
-    'figcaption',
-    'figure',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'hr',
-    'i',
-    'img',
-    'input',
-    'ins',
-    'kbd',
-    'label',
-    'li',
-    'mark',
-    'ol',
-    'p',
-    'pre',
-    'q',
-    'rp',
-    'rt',
-    'ruby',
-    'samp',
-    'small',
-    'small',
-    'source',
-    'span',
-    'strike',
-    'strong',
-    'sub',
-    'summary',
-    'sup',
-    'table',
-    'tbody',
-    'td',
-    'tfoot',
-    'th',
-    'thead',
-    'time',
-    'tr',
-    'tt',
-    'u',
-    'ul',
-    'var',
-    'video',
-    'wbr',
-]));
-const defaultDomPurifyConfig = ( Object.freeze({
-    ALLOWED_TAGS: ['a', 'button', 'blockquote', 'code', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'input', 'label', 'li', 'p', 'pre', 'select', 'small', 'span', 'strong', 'textarea', 'ul', 'ol'],
-    ALLOWED_ATTR: ['href', 'data-href', 'data-command', 'target', 'title', 'name', 'src', 'alt', 'class', 'id', 'role', 'tabindex', 'style', 'data-code', 'width', 'height', 'align', 'x-dispatch', 'required', 'checked', 'placeholder', 'type', 'start'],
-    RETURN_DOM: false,
-    RETURN_DOM_FRAGMENT: false,
-    RETURN_TRUSTED_TYPE: true
-}));
-function safeInnerHtml(node, value, extraDomPurifyConfig) {
-    const hook = hookDomPurifyHrefAndSrcSanitizer(defaultSafeProtocols);
-    try {
-        const html = dompurify.sanitize(value, { ...defaultDomPurifyConfig, ...extraDomPurifyConfig });
-        node.innerHTML = html;
-    }
-    finally {
-        hook.dispose();
-    }
-}
-function toBinary(str) {
-    const codeUnits = ( new Uint16Array(str.length));
-    for (let i = 0; i < codeUnits.length; i++) {
-        codeUnits[i] = str.charCodeAt(i);
-    }
-    let binary = '';
-    const uint8array = ( new Uint8Array(codeUnits.buffer));
-    for (let i = 0; i < uint8array.length; i++) {
-        binary += String.fromCharCode(uint8array[i]);
-    }
-    return binary;
-}
-function multibyteAwareBtoa(str) {
-    return btoa(toBinary(str));
-}
 class ModifierKeyEmitter extends Emitter {
     constructor() {
         super();
@@ -1824,4 +1713,4 @@ function isObservable(obj) {
     return !!obj && obj.read !== undefined && obj.reportChanges !== undefined;
 }
 
-export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, LiveElement, ModifierKeyEmitter, Namespace, ObserverNode, ObserverNodeWithElement, SafeTriangle, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, basicMarkupHtmlTags, clearNode, computeScreenAwareSize, copyAttributes, createElement, createElementNS, createLinkElement, createMetaElement, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getRootContainer, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEditableElement, isElement, isElementInBottomRightQuarter, isEventLike, isHTMLAnchorElement, isHTMLButtonElement, isHTMLDivElement, isHTMLElement, isHTMLIframeElement, isHTMLInputElement, isHTMLTextAreaElement, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isSVGElement, isShadowRoot, measure, modify, multibyteAwareBtoa, n, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, svgElem, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };
+export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, LiveElement, ModifierKeyEmitter, Namespace, ObserverNode, ObserverNodeWithElement, SafeTriangle, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, clearNode, computeScreenAwareSize, copyAttributes, createElement, createElementNS, createLinkElement, createMetaElement, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getRootContainer, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hide, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEditableElement, isElement, isElementInBottomRightQuarter, isEventLike, isHTMLAnchorElement, isHTMLButtonElement, isHTMLDivElement, isHTMLElement, isHTMLIframeElement, isHTMLInputElement, isHTMLTextAreaElement, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isSVGElement, isShadowRoot, measure, modify, n, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, svgElem, trackAttributes, trackFocus, triggerDownload, triggerNotification, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };

package/vscode/src/vs/base/browser/domSanitize.d.ts

@@ -0,0 +1,28 @@
+import dompurify from "./dompurify/dompurify.js";
+export declare const basicMarkupHtmlTags: readonly string[];
+export declare const defaultAllowedAttrs: readonly string[];
+type UponSanitizeElementCb = (currentNode: Element, data: dompurify.SanitizeElementHookEvent, config: dompurify.Config) => void;
+type UponSanitizeAttributeCb = (currentNode: Element, data: dompurify.SanitizeAttributeHookEvent, config: dompurify.Config) => void;
+export interface DomSanitizerConfig {
+    readonly allowedTags?: {
+        readonly override?: readonly string[];
+        readonly augment?: readonly string[];
+    };
+    readonly allowedAttributes?: {
+        readonly override?: readonly string[];
+        readonly augment?: readonly string[];
+    };
+    readonly allowedLinkProtocols?: {
+        readonly override?: readonly string[] | "*";
+    };
+    readonly allowedMediaProtocols?: {
+        readonly override?: readonly string[];
+    };
+    readonly _do_not_use_hooks?: {
+        readonly uponSanitizeElement?: UponSanitizeElementCb;
+        readonly uponSanitizeAttribute?: UponSanitizeAttributeCb;
+    };
+}
+export declare function sanitizeHtml(untrusted: string, config?: DomSanitizerConfig): TrustedHTML;
+export declare function safeSetInnerHtml(node: HTMLElement, untrusted: string, config?: DomSanitizerConfig): void;
+export {};

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

@@ -0,0 +1,175 @@
+
+import { toDisposable, DisposableStore } from '../common/lifecycle.js';
+import { Schemas } from '../common/network.js';
+import { createElement } from './dom.js';
+import dompurify from 'dompurify';
+
+const basicMarkupHtmlTags = ( Object.freeze([
+    'a',
+    'abbr',
+    'b',
+    'bdo',
+    'blockquote',
+    'br',
+    'caption',
+    'cite',
+    'code',
+    'col',
+    'colgroup',
+    'dd',
+    'del',
+    'details',
+    'dfn',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'figcaption',
+    'figure',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'hr',
+    'i',
+    'img',
+    'ins',
+    'kbd',
+    'label',
+    'li',
+    'mark',
+    'ol',
+    'p',
+    'pre',
+    'q',
+    'rp',
+    'rt',
+    'ruby',
+    'samp',
+    'small',
+    'small',
+    'source',
+    'span',
+    'strike',
+    'strong',
+    'sub',
+    'summary',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'time',
+    'tr',
+    'tt',
+    'u',
+    'ul',
+    'var',
+    'video',
+    'wbr',
+]));
+const defaultAllowedAttrs = ( Object.freeze([
+    'href',
+    'target',
+    'src',
+    'alt',
+    'title',
+    'for',
+    'name',
+    'role',
+    'tabindex',
+    'x-dispatch',
+    'required',
+    'checked',
+    'placeholder',
+    'type',
+    'start',
+    'width',
+    'height',
+    'align',
+]));
+function addDompurifyHook(hook, cb) {
+    dompurify.addHook(hook, cb);
+    return toDisposable(() => dompurify.removeHook(hook));
+}
+function hookDomPurifyHrefAndSrcSanitizer(allowedLinkProtocols, allowedMediaProtocols) {
+    const anchor = createElement('a');
+    function validateLink(value, allowedProtocols) {
+        if (allowedProtocols === '*') {
+            return true;
+        }
+        anchor.href = value;
+        return allowedProtocols.includes(anchor.protocol.replace(/:$/, ''));
+    }
+    dompurify.addHook('afterSanitizeAttributes', (node) => {
+        for (const attr of ['href', 'src']) {
+            if (node.hasAttribute(attr)) {
+                const attrValue = node.getAttribute(attr);
+                if (attr === 'href') {
+                    if (!attrValue.startsWith('#') && !validateLink(attrValue, allowedLinkProtocols)) {
+                        node.removeAttribute(attr);
+                    }
+                }
+                else {
+                    if (!validateLink(attrValue, allowedMediaProtocols)) {
+                        node.removeAttribute(attr);
+                    }
+                }
+            }
+        }
+    });
+    return toDisposable(() => dompurify.removeHook('afterSanitizeAttributes'));
+}
+const defaultDomPurifyConfig = ( Object.freeze({
+    ALLOWED_TAGS: [...basicMarkupHtmlTags],
+    ALLOWED_ATTR: [...defaultAllowedAttrs],
+    RETURN_DOM: false,
+    RETURN_DOM_FRAGMENT: false,
+    RETURN_TRUSTED_TYPE: true,
+    ALLOW_UNKNOWN_PROTOCOLS: true,
+}));
+function sanitizeHtml(untrusted, config) {
+    const store = ( new DisposableStore());
+    try {
+        const resolvedConfig = { ...defaultDomPurifyConfig };
+        if (config?.allowedTags) {
+            if (config.allowedTags.override) {
+                resolvedConfig.ALLOWED_TAGS = [...config.allowedTags.override];
+            }
+            if (config.allowedTags.augment) {
+                resolvedConfig.ALLOWED_TAGS = [...(resolvedConfig.ALLOWED_TAGS ?? []), ...config.allowedTags.augment];
+            }
+        }
+        if (config?.allowedAttributes) {
+            if (config.allowedAttributes.override) {
+                resolvedConfig.ALLOWED_ATTR = [...config.allowedAttributes.override];
+            }
+            if (config.allowedAttributes.augment) {
+                resolvedConfig.ALLOWED_ATTR = [...(resolvedConfig.ALLOWED_ATTR ?? []), ...config.allowedAttributes.augment];
+            }
+        }
+        store.add(hookDomPurifyHrefAndSrcSanitizer(config?.allowedLinkProtocols?.override ?? [Schemas.http, Schemas.https], config?.allowedMediaProtocols?.override ?? [Schemas.http, Schemas.https]));
+        if (config?._do_not_use_hooks?.uponSanitizeElement) {
+            store.add(addDompurifyHook('uponSanitizeElement', config?._do_not_use_hooks.uponSanitizeElement));
+        }
+        if (config?._do_not_use_hooks?.uponSanitizeAttribute) {
+            store.add(addDompurifyHook('uponSanitizeAttribute', config._do_not_use_hooks.uponSanitizeAttribute));
+        }
+        return dompurify.sanitize(untrusted, {
+            ...resolvedConfig,
+            RETURN_TRUSTED_TYPE: true
+        });
+    }
+    finally {
+        store.dispose();
+    }
+}
+function safeSetInnerHtml(node, untrusted, config) {
+    node.innerHTML = sanitizeHtml(untrusted, config);
+}
+
+export { basicMarkupHtmlTags, defaultAllowedAttrs, safeSetInnerHtml, sanitizeHtml };

package/vscode/src/vs/base/browser/formattedTextRenderer.d.ts

@@ -6,11 +6,8 @@ export interface IContentActionHandler {
     readonly disposables: DisposableStore;
 }
 export interface FormattedTextRenderOptions {
-    readonly className?: string;
-    readonly inline?: boolean;
     readonly actionHandler?: IContentActionHandler;
     readonly renderCodeSegments?: boolean;
 }
-export declare function renderText(text: string, options?: FormattedTextRenderOptions): HTMLElement;
-export declare function renderFormattedText(formattedText: string, options?: FormattedTextRenderOptions): HTMLElement;
-export declare function createElement(options: FormattedTextRenderOptions): HTMLElement;
+export declare function renderText(text: string, _options?: FormattedTextRenderOptions, target?: HTMLElement): HTMLElement;
+export declare function renderFormattedText(formattedText: string, options?: FormattedTextRenderOptions, target?: HTMLElement): HTMLElement;

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

@@ -1,22 +1,15 @@
 
-import { createElement as createElement$1, addStandardDisposableListener } from './dom.js';
+import { createElement, addStandardDisposableListener } from './dom.js';
 
-function renderText(text, options = {}) {
-    const element = createElement(options);
+function renderText(text, _options, target) {
+    const element = target ?? createElement('div');
     element.textContent = text;
     return element;
 }
-function renderFormattedText(formattedText, options = {}) {
-    const element = createElement(options);
-    _renderFormattedText(element, parseFormattedText(formattedText, !!options.renderCodeSegments), options.actionHandler, options.renderCodeSegments);
-    return element;
-}
-function createElement(options) {
-    const tagName = options.inline ? 'span' : 'div';
-    const element = createElement$1(tagName);
-    if (options.className) {
-        element.className = options.className;
-    }
+function renderFormattedText(formattedText, options, target) {
+    const element = target ?? createElement('div');
+    element.textContent = '';
+    _renderFormattedText(element, parseFormattedText(formattedText, !!options?.renderCodeSegments), options?.actionHandler, options?.renderCodeSegments);
     return element;
 }
 class StringStream {
@@ -57,23 +50,23 @@ function _renderFormattedText(element, treeNode, actionHandler, renderCodeSegmen
         child = document.createTextNode(treeNode.content || '');
     }
     else if (treeNode.type === FormatType.Bold) {
-        child = createElement$1('b');
+        child = createElement('b');
     }
     else if (treeNode.type === FormatType.Italics) {
-        child = createElement$1('i');
+        child = createElement('i');
     }
     else if (treeNode.type === FormatType.Code && renderCodeSegments) {
-        child = createElement$1('code');
+        child = createElement('code');
     }
     else if (treeNode.type === FormatType.Action && actionHandler) {
-        const a = createElement$1('a');
+        const a = createElement('a');
         actionHandler.disposables.add(addStandardDisposableListener(a, 'click', (event) => {
             actionHandler.callback(String(treeNode.index), event);
         }));
         child = a;
     }
     else if (treeNode.type === FormatType.NewLine) {
-        child = createElement$1('br');
+        child = createElement('br');
     }
     else if (treeNode.type === FormatType.Root) {
         child = element;
@@ -173,4 +166,4 @@ function formatTagType(char, supportCodeSegments) {
     }
 }
 
-export { createElement, renderFormattedText, renderText };
+export { renderFormattedText, renderText };

package/vscode/src/vs/base/browser/markdownRenderer.d.ts

@@ -2,27 +2,37 @@ import { IMarkdownString } from "../common/htmlContent.js";
 import * as marked from "../common/marked/marked.js";
 import { URI } from "../common/uri.js";
 import { FormattedTextRenderOptions } from "./formattedTextRenderer.js";
-export interface MarkedOptions extends Readonly<Omit<marked.MarkedOptions, "extensions" | "baseUrl">> {
-    readonly markedExtensions?: marked.MarkedExtension[];
-}
 export interface MarkdownRenderOptions extends FormattedTextRenderOptions {
     readonly codeBlockRenderer?: (languageId: string, value: string) => Promise<HTMLElement>;
     readonly codeBlockRendererSync?: (languageId: string, value: string, raw?: string) => HTMLElement;
     readonly asyncRenderCallback?: () => void;
     readonly fillInIncompleteTokens?: boolean;
-    readonly remoteImageIsAllowed?: (uri: URI) => boolean;
-    readonly sanitizerOptions?: ISanitizerOptions;
+    readonly sanitizerConfig?: MarkdownSanitizerConfig;
+    readonly markedOptions?: MarkdownRendererMarkedOptions;
+    readonly markedExtensions?: marked.MarkedExtension[];
+}
+export interface MarkdownRendererMarkedOptions {
+    readonly gfm?: boolean;
+    readonly breaks?: boolean;
 }
-export interface ISanitizerOptions {
-    replaceWithPlaintext?: boolean;
-    allowedTags?: string[];
-    allowedProductProtocols?: string[];
+export interface MarkdownSanitizerConfig {
+    readonly replaceWithPlaintext?: boolean;
+    readonly allowedTags?: {
+        readonly override: readonly string[];
+    };
+    readonly customAttrSanitizer?: (attrName: string, attrValue: string) => boolean | string;
+    readonly allowedLinkSchemes?: {
+        readonly augment: readonly string[];
+    };
+    readonly remoteImageIsAllowed?: (uri: URI) => boolean;
 }
-export declare function renderMarkdown(markdown: IMarkdownString, options?: MarkdownRenderOptions, markedOptions?: MarkedOptions): {
+export declare function renderMarkdown(markdown: IMarkdownString, options?: MarkdownRenderOptions, target?: HTMLElement): {
     element: HTMLElement;
     dispose: () => void;
 };
-export declare const allowedMarkdownAttr: string[];
-export declare function renderStringAsPlaintext(string: IMarkdownString | string): string;
-export declare function renderMarkdownAsPlaintext(markdown: IMarkdownString, withCodeBlocks?: boolean): string;
+export declare const allowedMarkdownHtmlTags: readonly string[];
+export declare const allowedMarkdownHtmlAttributes: string[];
+export declare function renderAsPlaintext(str: IMarkdownString | string, options?: {
+    readonly includeCodeBlocksFences?: boolean;
+}): string;
 export declare function fillInIncompleteTokens(tokens: marked.TokensList): marked.TokensList;