@codingame/monaco-vscode-api 1.85.6 → 2.0.0-v2.1

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

@@ -0,0 +1,586 @@
+import { getWindow, addDisposableListener, reset, hookDomPurifyHrefAndSrcSanitizer, basicMarkupHtmlTags } from './dom.js';
+import { addHook, sanitize, removeHook } from './dompurify/dompurify.js';
+import { DomEmitter } from './event.js';
+import { createElement } from './formattedTextRenderer.js';
+import { StandardKeyboardEvent } from './keyboardEvent.js';
+import { StandardMouseEvent } from './mouseEvent.js';
+import { renderLabelWithIcons } from './ui/iconLabel/iconLabels.js';
+import { onUnexpectedError } from '../common/errors.js';
+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 { Lazy } from '../common/lazy.js';
+import { DisposableStore } from '../common/lifecycle.js';
+import marked from 'vscode-marked';
+import { parse } from '../common/marshalling.js';
+import { Schemas, FileAccess } from '../common/network.js';
+import { cloneAndChange } from '../common/objects.js';
+import { resolvePath, dirname } from '../common/resources.js';
+import { escape } from '../common/strings.js';
+import { URI } from '../common/uri.js';
+const defaultMarkedRenderers = ( Object.freeze({
+    image: (href, title, text) => {
+        let dimensions = [];
+        let attributes = [];
+        if (href) {
+            ({ href, dimensions } = parseHrefAndDimensions(href));
+            attributes.push(`src="${escapeDoubleQuotes(href)}"`);
+        }
+        if (text) {
+            attributes.push(`alt="${escapeDoubleQuotes(text)}"`);
+        }
+        if (title) {
+            attributes.push(`title="${escapeDoubleQuotes(title)}"`);
+        }
+        if (dimensions.length) {
+            attributes = attributes.concat(dimensions);
+        }
+        return '<img ' + attributes.join(' ') + '>';
+    },
+    paragraph: (text) => {
+        return `<p>${text}</p>`;
+    },
+    link: (href, title, text) => {
+        if (typeof href !== 'string') {
+            return '';
+        }
+        if (href === text) {
+            text = removeMarkdownEscapes(text);
+        }
+        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;');
+        return `<a href="${href}" title="${title || href}" draggable="false">${text}</a>`;
+    },
+}));
+function renderMarkdown(markdown, options = {}, markedOptions = {}) {
+    const disposables = ( new DisposableStore());
+    let isDisposed = false;
+    const element = createElement(options);
+    const _uriMassage = function (part) {
+        let data;
+        try {
+            data = parse(decodeURIComponent(part));
+        }
+        catch (e) {
+        }
+        if (!data) {
+            return part;
+        }
+        data = cloneAndChange(data, value => {
+            if (markdown.uris && markdown.uris[value]) {
+                return URI.revive(markdown.uris[value]);
+            }
+            else {
+                return undefined;
+            }
+        });
+        return encodeURIComponent(JSON.stringify(data));
+    };
+    const _href = function (href, isDomUri) {
+        const data = markdown.uris && markdown.uris[href];
+        let uri = URI.revive(data);
+        if (isDomUri) {
+            if (href.startsWith(Schemas.data + ':')) {
+                return href;
+            }
+            if (!uri) {
+                uri = ( URI.parse(href));
+            }
+            return ( FileAccess.uriToBrowserUri(uri).toString(true));
+        }
+        if (!uri) {
+            return href;
+        }
+        if (( ( URI.parse(href)).toString()) === ( uri.toString())) {
+            return href;
+        }
+        if (uri.query) {
+            uri = uri.with({ query: _uriMassage(uri.query) });
+        }
+        return ( uri.toString());
+    };
+    const renderer = new marked.Renderer();
+    renderer.image = defaultMarkedRenderers.image;
+    renderer.link = defaultMarkedRenderers.link;
+    renderer.paragraph = defaultMarkedRenderers.paragraph;
+    const codeBlocks = [];
+    const syncCodeBlocks = [];
+    if (options.codeBlockRendererSync) {
+        renderer.code = (code, lang) => {
+            const id = defaultGenerator.nextId();
+            const value = options.codeBlockRendererSync(postProcessCodeBlockLanguageId(lang), code);
+            syncCodeBlocks.push([id, value]);
+            return `<div class="code" data-code="${id}">${escape(code)}</div>`;
+        };
+    }
+    else if (options.codeBlockRenderer) {
+        renderer.code = (code, lang) => {
+            const id = defaultGenerator.nextId();
+            const value = options.codeBlockRenderer(postProcessCodeBlockLanguageId(lang), code);
+            codeBlocks.push(value.then(element => [id, element]));
+            return `<div class="code" data-code="${id}">${escape(code)}</div>`;
+        };
+    }
+    if (options.actionHandler) {
+        const _activateLink = function (event) {
+            let target = event.target;
+            if (target.tagName !== 'A') {
+                target = target.parentElement;
+                if (!target || target.tagName !== 'A') {
+                    return;
+                }
+            }
+            try {
+                let href = target.dataset['href'];
+                if (href) {
+                    if (markdown.baseUri) {
+                        href = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
+                    }
+                    options.actionHandler.callback(href, event);
+                }
+            }
+            catch (err) {
+                onUnexpectedError(err);
+            }
+            finally {
+                event.preventDefault();
+            }
+        };
+        const onClick = options.actionHandler.disposables.add(( new DomEmitter(element, 'click')));
+        const onAuxClick = options.actionHandler.disposables.add(( new DomEmitter(element, 'auxclick')));
+        options.actionHandler.disposables.add(Event.any(onClick.event, onAuxClick.event)(e => {
+            const mouseEvent = ( new StandardMouseEvent(getWindow(element), e));
+            if (!mouseEvent.leftButton && !mouseEvent.middleButton) {
+                return;
+            }
+            _activateLink(mouseEvent);
+        }));
+        options.actionHandler.disposables.add(addDisposableListener(element, 'keydown', (e) => {
+            const keyboardEvent = ( new StandardKeyboardEvent(e));
+            if (!keyboardEvent.equals(10 ) && !keyboardEvent.equals(3 )) {
+                return;
+            }
+            _activateLink(keyboardEvent);
+        }));
+    }
+    if (!markdown.supportHtml) {
+        markedOptions.sanitizer = (html) => {
+            const match = markdown.isTrusted ? html.match(/^(<span[^>]+>)|(<\/\s*span>)$/) : undefined;
+            return match ? html : '';
+        };
+        markedOptions.sanitize = true;
+        markedOptions.silent = true;
+    }
+    markedOptions.renderer = renderer;
+    let value = markdown.value ?? '';
+    if (value.length > 100000) {
+        value = `${value.substr(0, 100000)}…`;
+    }
+    if (markdown.supportThemeIcons) {
+        value = markdownEscapeEscapedIcons(value);
+    }
+    let renderedMarkdown;
+    if (options.fillInIncompleteTokens) {
+        const opts = {
+            ...marked.defaults,
+            ...markedOptions
+        };
+        const tokens = marked.lexer(value, opts);
+        const newTokens = fillInIncompleteTokens(tokens);
+        renderedMarkdown = marked.parser(newTokens, opts);
+    }
+    else {
+        renderedMarkdown = marked.parse(value, markedOptions);
+    }
+    if (markdown.supportThemeIcons) {
+        const elements = renderLabelWithIcons(renderedMarkdown);
+        renderedMarkdown = ( elements.map(e => typeof e === 'string' ? e : e.outerHTML)).join('');
+    }
+    const htmlParser = ( new DOMParser());
+    const markdownHtmlDoc = htmlParser.parseFromString(sanitizeRenderedMarkdown(markdown, renderedMarkdown), 'text/html');
+    markdownHtmlDoc.body.querySelectorAll('img')
+        .forEach(img => {
+        const src = img.getAttribute('src');
+        if (src) {
+            let href = src;
+            try {
+                if (markdown.baseUri) {
+                    href = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
+                }
+            }
+            catch (err) { }
+            img.src = _href(href, true);
+        }
+    });
+    markdownHtmlDoc.body.querySelectorAll('a')
+        .forEach(a => {
+        const href = a.getAttribute('href');
+        a.setAttribute('href', '');
+        if (!href
+            || /^data:|javascript:/i.test(href)
+            || (/^command:/i.test(href) && !markdown.isTrusted)
+            || /^command:(\/\/\/)?_workbench\.downloadResource/i.test(href)) {
+            a.replaceWith(...a.childNodes);
+        }
+        else {
+            let resolvedHref = _href(href, false);
+            if (markdown.baseUri) {
+                resolvedHref = resolveWithBaseUri(( URI.from(markdown.baseUri)), href);
+            }
+            a.dataset.href = resolvedHref;
+        }
+    });
+    element.innerHTML = sanitizeRenderedMarkdown(markdown, markdownHtmlDoc.body.innerHTML);
+    if (codeBlocks.length > 0) {
+        Promise.all(codeBlocks).then((tuples) => {
+            if (isDisposed) {
+                return;
+            }
+            const renderedElements = ( new Map(tuples));
+            const placeholderElements = element.querySelectorAll(`div[data-code]`);
+            for (const placeholderElement of placeholderElements) {
+                const renderedElement = renderedElements.get(placeholderElement.dataset['code'] ?? '');
+                if (renderedElement) {
+                    reset(placeholderElement, renderedElement);
+                }
+            }
+            options.asyncRenderCallback?.();
+        });
+    }
+    else if (syncCodeBlocks.length > 0) {
+        const renderedElements = ( new Map(syncCodeBlocks));
+        const placeholderElements = element.querySelectorAll(`div[data-code]`);
+        for (const placeholderElement of placeholderElements) {
+            const renderedElement = renderedElements.get(placeholderElement.dataset['code'] ?? '');
+            if (renderedElement) {
+                reset(placeholderElement, renderedElement);
+            }
+        }
+    }
+    if (options.asyncRenderCallback) {
+        for (const img of element.getElementsByTagName('img')) {
+            const listener = disposables.add(addDisposableListener(img, 'load', () => {
+                listener.dispose();
+                options.asyncRenderCallback();
+            }));
+        }
+    }
+    return {
+        element,
+        dispose: () => {
+            isDisposed = true;
+            disposables.dispose();
+        }
+    };
+}
+function postProcessCodeBlockLanguageId(lang) {
+    if (!lang) {
+        return '';
+    }
+    const parts = lang.split(/[\s+|:|,|\{|\?]/, 1);
+    if (parts.length) {
+        return parts[0];
+    }
+    return lang;
+}
+function resolveWithBaseUri(baseUri, href) {
+    const hasScheme = /^\w[\w\d+.-]*:/.test(href);
+    if (hasScheme) {
+        return href;
+    }
+    if (baseUri.path.endsWith('/')) {
+        return ( resolvePath(baseUri, href).toString());
+    }
+    else {
+        return ( resolvePath(dirname(baseUri), href).toString());
+    }
+}
+function sanitizeRenderedMarkdown(options, renderedMarkdown) {
+    const { config, allowedSchemes } = getSanitizerOptions(options);
+    addHook('uponSanitizeAttribute', (element, e) => {
+        if (e.attrName === 'style' || e.attrName === 'class') {
+            if (element.tagName === 'SPAN') {
+                if (e.attrName === 'style') {
+                    e.keepAttr = /^(color\:(#[0-9a-fA-F]+|var\(--vscode(-[a-zA-Z]+)+\));)?(background-color\:(#[0-9a-fA-F]+|var\(--vscode(-[a-zA-Z]+)+\));)?$/.test(e.attrValue);
+                    return;
+                }
+                else if (e.attrName === 'class') {
+                    e.keepAttr = /^codicon codicon-[a-z\-]+( codicon-modifier-[a-z\-]+)?$/.test(e.attrValue);
+                    return;
+                }
+            }
+            e.keepAttr = false;
+            return;
+        }
+    });
+    const hook = hookDomPurifyHrefAndSrcSanitizer(allowedSchemes);
+    try {
+        return sanitize(renderedMarkdown, { ...config, RETURN_TRUSTED_TYPE: true });
+    }
+    finally {
+        removeHook('uponSanitizeAttribute');
+        hook.dispose();
+    }
+}
+const allowedMarkdownAttr = [
+    'align',
+    'autoplay',
+    'alt',
+    'class',
+    'controls',
+    'data-code',
+    'data-href',
+    'draggable',
+    'height',
+    'href',
+    'loop',
+    'muted',
+    'playsinline',
+    'poster',
+    'src',
+    'style',
+    'target',
+    'title',
+    'width',
+    'start',
+];
+function getSanitizerOptions(options) {
+    const allowedSchemes = [
+        Schemas.http,
+        Schemas.https,
+        Schemas.mailto,
+        Schemas.data,
+        Schemas.file,
+        Schemas.vscodeFileResource,
+        Schemas.vscodeRemote,
+        Schemas.vscodeRemoteResource,
+    ];
+    if (options.isTrusted) {
+        allowedSchemes.push(Schemas.command);
+    }
+    return {
+        config: {
+            ALLOWED_TAGS: [...basicMarkupHtmlTags],
+            ALLOWED_ATTR: allowedMarkdownAttr,
+            ALLOW_UNKNOWN_PROTOCOLS: true,
+        },
+        allowedSchemes
+    };
+}
+function renderStringAsPlaintext(string) {
+    return typeof string === 'string' ? string : renderMarkdownAsPlaintext(string);
+}
+function renderMarkdownAsPlaintext(markdown) {
+    let value = markdown.value ?? '';
+    if (value.length > 100000) {
+        value = `${value.substr(0, 100000)}…`;
+    }
+    const html = marked.parse(value, { renderer: plainTextRenderer.value }).replace(/&(#\d+|[a-zA-Z]+);/g, m => unescapeInfo.get(m) ?? m);
+    return ( sanitizeRenderedMarkdown({ isTrusted: false }, html).toString());
+}
+const unescapeInfo = ( new Map([
+    ['&quot;', '"'],
+    ['&nbsp;', ' '],
+    ['&amp;', '&'],
+    ['&#39;', '\''],
+    ['&lt;', '<'],
+    ['&gt;', '>'],
+]));
+const plainTextRenderer = ( new Lazy(() => {
+    const renderer = new marked.Renderer();
+    renderer.code = (code) => {
+        return code;
+    };
+    renderer.blockquote = (quote) => {
+        return quote;
+    };
+    renderer.html = (_html) => {
+        return '';
+    };
+    renderer.heading = (text, _level, _raw) => {
+        return text + '\n';
+    };
+    renderer.hr = () => {
+        return '';
+    };
+    renderer.list = (body, _ordered) => {
+        return body;
+    };
+    renderer.listitem = (text) => {
+        return text + '\n';
+    };
+    renderer.paragraph = (text) => {
+        return text + '\n';
+    };
+    renderer.table = (header, body) => {
+        return header + body + '\n';
+    };
+    renderer.tablerow = (content) => {
+        return content;
+    };
+    renderer.tablecell = (content, _flags) => {
+        return content + ' ';
+    };
+    renderer.strong = (text) => {
+        return text;
+    };
+    renderer.em = (text) => {
+        return text;
+    };
+    renderer.codespan = (code) => {
+        return code;
+    };
+    renderer.br = () => {
+        return '\n';
+    };
+    renderer.del = (text) => {
+        return text;
+    };
+    renderer.image = (_href, _title, _text) => {
+        return '';
+    };
+    renderer.text = (text) => {
+        return text;
+    };
+    renderer.link = (_href, _title, text) => {
+        return text;
+    };
+    return renderer;
+}));
+function mergeRawTokenText(tokens) {
+    let mergedTokenText = '';
+    tokens.forEach(token => {
+        mergedTokenText += token.raw;
+    });
+    return mergedTokenText;
+}
+function completeSingleLinePattern(token) {
+    for (const subtoken of token.tokens) {
+        if (subtoken.type === 'text') {
+            const lines = subtoken.raw.split('\n');
+            const lastLine = lines[lines.length - 1];
+            if (lastLine.includes('`')) {
+                return completeCodespan(token);
+            }
+            else if (lastLine.includes('**')) {
+                return completeDoublestar(token);
+            }
+            else if (lastLine.match(/\*\w/)) {
+                return completeStar(token);
+            }
+            else if (lastLine.match(/(^|\s)__\w/)) {
+                return completeDoubleUnderscore(token);
+            }
+            else if (lastLine.match(/(^|\s)_\w/)) {
+                return completeUnderscore(token);
+            }
+            else if (lastLine.match(/(^|\s)\[.*\]\(\w*/)) {
+                return completeLinkTarget(token);
+            }
+            else if (lastLine.match(/(^|\s)\[\w/)) {
+                return completeLinkText(token);
+            }
+        }
+    }
+    return undefined;
+}
+function fillInIncompleteTokens(tokens) {
+    let i;
+    let newTokens;
+    for (i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === 'paragraph' && token.raw.match(/(\n|^)```/)) {
+            newTokens = completeCodeBlock(tokens.slice(i));
+            break;
+        }
+        if (token.type === 'paragraph' && token.raw.match(/(\n|^)\|/)) {
+            newTokens = completeTable(tokens.slice(i));
+            break;
+        }
+        if (i === tokens.length - 1 && token.type === 'paragraph') {
+            const newToken = completeSingleLinePattern(token);
+            if (newToken) {
+                newTokens = [newToken];
+                break;
+            }
+        }
+    }
+    if (newTokens) {
+        const newTokensList = [
+            ...tokens.slice(0, i),
+            ...newTokens
+        ];
+        newTokensList.links = tokens.links;
+        return newTokensList;
+    }
+    return tokens;
+}
+function completeCodeBlock(tokens) {
+    const mergedRawText = mergeRawTokenText(tokens);
+    return marked.lexer(mergedRawText + '\n```');
+}
+function completeCodespan(token) {
+    return completeWithString(token, '`');
+}
+function completeStar(tokens) {
+    return completeWithString(tokens, '*');
+}
+function completeUnderscore(tokens) {
+    return completeWithString(tokens, '_');
+}
+function completeLinkTarget(tokens) {
+    return completeWithString(tokens, ')');
+}
+function completeLinkText(tokens) {
+    return completeWithString(tokens, '](about:blank)');
+}
+function completeDoublestar(tokens) {
+    return completeWithString(tokens, '**');
+}
+function completeDoubleUnderscore(tokens) {
+    return completeWithString(tokens, '__');
+}
+function completeWithString(tokens, closingString) {
+    const mergedRawText = mergeRawTokenText(Array.isArray(tokens) ? tokens : [tokens]);
+    return marked.lexer(mergedRawText + closingString)[0];
+}
+function completeTable(tokens) {
+    const mergedRawText = mergeRawTokenText(tokens);
+    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*\|/)) {
+            const line1Matches = line.match(/(\|[^\|]+)(?=\||$)/g);
+            if (line1Matches) {
+                numCols = line1Matches.length;
+            }
+        }
+        else if (typeof numCols === 'number') {
+            if (line.match(/^\s*\|/)) {
+                if (i !== lines.length - 1) {
+                    return undefined;
+                }
+                hasSeparatorRow = true;
+            }
+            else {
+                return undefined;
+            }
+        }
+    }
+    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)}`;
+        return marked.lexer(newRawText);
+    }
+    return undefined;
+}
+export { allowedMarkdownAttr, fillInIncompleteTokens, renderMarkdown, renderMarkdownAsPlaintext, renderStringAsPlaintext };

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

@@ -0,0 +1,106 @@
+import { isFirefox, isSafari } from './browser.js';
+import { IframeUtils } from './iframe.js';
+import { isMacintosh, isWindows } from '../common/platform.js';
+class StandardMouseEvent {
+    constructor(targetWindow, e) {
+        this.timestamp = Date.now();
+        this.browserEvent = e;
+        this.leftButton = e.button === 0;
+        this.middleButton = e.button === 1;
+        this.rightButton = e.button === 2;
+        this.buttons = e.buttons;
+        this.target = e.target;
+        this.detail = e.detail || 1;
+        if (e.type === 'dblclick') {
+            this.detail = 2;
+        }
+        this.ctrlKey = e.ctrlKey;
+        this.shiftKey = e.shiftKey;
+        this.altKey = e.altKey;
+        this.metaKey = e.metaKey;
+        if (typeof e.pageX === 'number') {
+            this.posx = e.pageX;
+            this.posy = e.pageY;
+        }
+        else {
+            this.posx = e.clientX + this.target.ownerDocument.body.scrollLeft + this.target.ownerDocument.documentElement.scrollLeft;
+            this.posy = e.clientY + this.target.ownerDocument.body.scrollTop + this.target.ownerDocument.documentElement.scrollTop;
+        }
+        const iframeOffsets = IframeUtils.getPositionOfChildWindowRelativeToAncestorWindow(targetWindow, e.view);
+        this.posx -= iframeOffsets.left;
+        this.posy -= iframeOffsets.top;
+    }
+    preventDefault() {
+        this.browserEvent.preventDefault();
+    }
+    stopPropagation() {
+        this.browserEvent.stopPropagation();
+    }
+}
+class StandardWheelEvent {
+    constructor(e, deltaX = 0, deltaY = 0) {
+        this.browserEvent = e || null;
+        this.target = e ? (e.target || e.targetNode || e.srcElement) : null;
+        this.deltaY = deltaY;
+        this.deltaX = deltaX;
+        if (e) {
+            const e1 = e;
+            const e2 = e;
+            if (typeof e1.wheelDeltaY !== 'undefined') {
+                this.deltaY = e1.wheelDeltaY / 120;
+            }
+            else if (typeof e2.VERTICAL_AXIS !== 'undefined' && e2.axis === e2.VERTICAL_AXIS) {
+                this.deltaY = -e2.detail / 3;
+            }
+            else if (e.type === 'wheel') {
+                const ev = e;
+                if (ev.deltaMode === ev.DOM_DELTA_LINE) {
+                    if (isFirefox && !isMacintosh) {
+                        this.deltaY = -e.deltaY / 3;
+                    }
+                    else {
+                        this.deltaY = -e.deltaY;
+                    }
+                }
+                else {
+                    this.deltaY = -e.deltaY / 40;
+                }
+            }
+            if (typeof e1.wheelDeltaX !== 'undefined') {
+                if (isSafari && isWindows) {
+                    this.deltaX = -(e1.wheelDeltaX / 120);
+                }
+                else {
+                    this.deltaX = e1.wheelDeltaX / 120;
+                }
+            }
+            else if (typeof e2.HORIZONTAL_AXIS !== 'undefined' && e2.axis === e2.HORIZONTAL_AXIS) {
+                this.deltaX = -e.detail / 3;
+            }
+            else if (e.type === 'wheel') {
+                const ev = e;
+                if (ev.deltaMode === ev.DOM_DELTA_LINE) {
+                    if (isFirefox && !isMacintosh) {
+                        this.deltaX = -e.deltaX / 3;
+                    }
+                    else {
+                        this.deltaX = -e.deltaX;
+                    }
+                }
+                else {
+                    this.deltaX = -e.deltaX / 40;
+                }
+            }
+            if (this.deltaY === 0 && this.deltaX === 0 && e.wheelDelta) {
+                this.deltaY = e.wheelDelta / 120;
+            }
+        }
+    }
+    preventDefault() {
+        this.browserEvent?.preventDefault();
+    }
+    stopPropagation() {
+        this.browserEvent?.stopPropagation();
+    }
+}
+export { StandardMouseEvent, StandardWheelEvent };