@codingame/monaco-vscode-api 4.1.0 → 4.1.1

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

@@ -1,15 +0,0 @@
-import { VSBuffer } from '../common/buffer.js';
-import { toHexString, StringSHA1 } from '../common/hash.js';
-async function sha1Hex(str) {
-    if (globalThis?.crypto?.subtle) {
-        const buffer = VSBuffer.fromString(str, { dontUseNodeBuffer: true }).buffer;
-        const hash = await globalThis.crypto.subtle.digest({ name: 'sha-1' }, buffer);
-        return toHexString(hash);
-    }
-    else {
-        const computer = ( new StringSHA1());
-        computer.update(str);
-        return computer.digest();
-    }
-}
-export { sha1Hex };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.css.js

@@ -1,4 +0,0 @@
-import n from '../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
-var css = ".icon-select-box>.icon-select-box-container{height:100%}.icon-select-box .icon-select-icons-container{height:100%;outline:0!important}.icon-select-box .icon-select-icons-container>.icon-container{align-items:center;border-radius:5px;cursor:pointer;display:inline-flex;font-size:20px;justify-content:center}.icon-select-box .icon-select-icons-container>.icon-container.focused{background-color:var(--vscode-quickInputList-focusBackground);color:var(--vscode-quickInputList-focusForeground)}.icon-select-box .icon-select-icons-container>.icon-container:hover:not(.focused){background-color:var(--vscode-toolbar-hoverBackground);color:var(--vscode-list-hoverForeground)}.icon-select-box .icon-select-id-container .icon-select-id-label{height:24px;opacity:.8;padding:10px}.icon-select-box .icon-select-id-container .icon-select-id-label .highlight{color:var(--vscode-list-highlightForeground);font-weight:700}";
-n(css,{});
-export { css, css as default };

package/vscode/src/vs/base/browser/ui/icons/iconSelectBox.js

@@ -1,246 +0,0 @@
-import './iconSelectBox.css.js';
-import { $, append, clearNode, addDisposableListener, EventType } from '../../dom.js';
-import { alert } from '../aria/aria.js';
-import { InputBox } from '../inputbox/inputBox.js';
-import { DomScrollableElement } from '../scrollbar/scrollableElement.js';
-import { Emitter } from '../../../common/event.js';
-import { Disposable, MutableDisposable, DisposableStore } from '../../../common/lifecycle.js';
-import { ThemeIcon } from '../../../common/themables.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { HighlightedLabel } from '../highlightedlabel/highlightedLabel.js';
-class IconSelectBox extends Disposable {
-    static { this.InstanceCount = 0; }
-    constructor(options) {
-        super();
-        this.options = options;
-        this.domId = `icon_select_box_id_${++IconSelectBox.InstanceCount}`;
-        this._onDidSelect = this._register(( new Emitter()));
-        this.onDidSelect = this._onDidSelect.event;
-        this.renderedIcons = [];
-        this.focusedItemIndex = 0;
-        this.numberOfElementsPerRow = 1;
-        this.iconContainerWidth = 36;
-        this.iconContainerHeight = 36;
-        this.domNode = $('.icon-select-box');
-        this._register(this.create());
-    }
-    create() {
-        const disposables = ( new DisposableStore());
-        const iconSelectBoxContainer = append(this.domNode, $('.icon-select-box-container'));
-        iconSelectBoxContainer.style.margin = '10px 15px';
-        const iconSelectInputContainer = append(iconSelectBoxContainer, $('.icon-select-input-container'));
-        iconSelectInputContainer.style.paddingBottom = '10px';
-        this.inputBox = disposables.add(( new InputBox(iconSelectInputContainer, undefined, {
-            placeholder: ( localizeWithPath(
-                'vs/base/browser/ui/icons/iconSelectBox',
-                'iconSelect.placeholder',
-                "Search icons"
-            )),
-            inputBoxStyles: this.options.inputBoxStyles,
-        })));
-        const iconsContainer = this.iconsContainer = $('.icon-select-icons-container', { id: `${this.domId}_icons` });
-        iconsContainer.role = 'listbox';
-        iconsContainer.tabIndex = 0;
-        this.scrollableElement = disposables.add(( new DomScrollableElement(iconsContainer, {
-            useShadows: false,
-            horizontal: 2 ,
-        })));
-        append(iconSelectBoxContainer, this.scrollableElement.getDomNode());
-        if (this.options.showIconInfo) {
-            this.iconIdElement = this._register(( new HighlightedLabel(
-                append(append(iconSelectBoxContainer, $('.icon-select-id-container')), $('.icon-select-id-label'))
-            )));
-        }
-        const iconsDisposables = disposables.add(( new MutableDisposable()));
-        iconsDisposables.value = this.renderIcons(this.options.icons, [], iconsContainer);
-        this.scrollableElement.scanDomNode();
-        disposables.add(this.inputBox.onDidChange(value => {
-            const icons = [], matches = [];
-            for (const icon of this.options.icons) {
-                const match = this.matchesContiguous(value, icon.id);
-                if (match) {
-                    icons.push(icon);
-                    matches.push(match);
-                }
-            }
-            if (icons.length) {
-                iconsDisposables.value = this.renderIcons(icons, matches, iconsContainer);
-                this.scrollableElement?.scanDomNode();
-            }
-        }));
-        this.inputBox.inputElement.role = 'combobox';
-        this.inputBox.inputElement.ariaHasPopup = 'menu';
-        this.inputBox.inputElement.ariaAutoComplete = 'list';
-        this.inputBox.inputElement.ariaExpanded = 'true';
-        this.inputBox.inputElement.setAttribute('aria-controls', iconsContainer.id);
-        return disposables;
-    }
-    renderIcons(icons, matches, container) {
-        const disposables = ( new DisposableStore());
-        clearNode(container);
-        const focusedIcon = this.renderedIcons[this.focusedItemIndex]?.icon;
-        let focusedIconIndex = 0;
-        const renderedIcons = [];
-        if (icons.length) {
-            for (let index = 0; index < icons.length; index++) {
-                const icon = icons[index];
-                const iconContainer = append(container, $('.icon-container', { id: `${this.domId}_icons_${index}` }));
-                iconContainer.style.width = `${this.iconContainerWidth}px`;
-                iconContainer.style.height = `${this.iconContainerHeight}px`;
-                iconContainer.title = icon.id;
-                iconContainer.role = 'button';
-                iconContainer.setAttribute('aria-setsize', `${icons.length}`);
-                iconContainer.setAttribute('aria-posinset', `${index + 1}`);
-                append(iconContainer, $(ThemeIcon.asCSSSelector(icon)));
-                renderedIcons.push({ icon, element: iconContainer, highlightMatches: matches[index] });
-                disposables.add(addDisposableListener(iconContainer, EventType.CLICK, (e) => {
-                    e.stopPropagation();
-                    this.setSelection(index);
-                }));
-                if (icon === focusedIcon) {
-                    focusedIconIndex = index;
-                }
-            }
-        }
-        else {
-            const noResults = ( localizeWithPath(
-                'vs/base/browser/ui/icons/iconSelectBox',
-                'iconSelect.noResults',
-                "No results"
-            ));
-            append(container, $('.icon-no-results', undefined, noResults));
-            alert(noResults);
-        }
-        this.renderedIcons.splice(0, this.renderedIcons.length, ...renderedIcons);
-        this.focusIcon(focusedIconIndex);
-        return disposables;
-    }
-    focusIcon(index) {
-        const existing = this.renderedIcons[this.focusedItemIndex];
-        if (existing) {
-            existing.element.classList.remove('focused');
-        }
-        this.focusedItemIndex = index;
-        const renderedItem = this.renderedIcons[index];
-        if (renderedItem) {
-            renderedItem.element.classList.add('focused');
-        }
-        if (this.inputBox) {
-            if (renderedItem) {
-                this.inputBox.inputElement.setAttribute('aria-activedescendant', renderedItem.element.id);
-            }
-            else {
-                this.inputBox.inputElement.removeAttribute('aria-activedescendant');
-            }
-        }
-        if (this.iconIdElement) {
-            if (renderedItem) {
-                this.iconIdElement.set(renderedItem.icon.id, renderedItem.highlightMatches);
-            }
-            else {
-                this.iconIdElement.set('');
-            }
-        }
-        this.reveal(index);
-    }
-    reveal(index) {
-        if (!this.scrollableElement) {
-            return;
-        }
-        if (index < 0 || index >= this.renderedIcons.length) {
-            return;
-        }
-        const element = this.renderedIcons[index].element;
-        if (!element) {
-            return;
-        }
-        const { height } = this.scrollableElement.getScrollDimensions();
-        const { scrollTop } = this.scrollableElement.getScrollPosition();
-        if (element.offsetTop + this.iconContainerHeight > scrollTop + height) {
-            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop + this.iconContainerHeight - height });
-        }
-        else if (element.offsetTop < scrollTop) {
-            this.scrollableElement.setScrollPosition({ scrollTop: element.offsetTop });
-        }
-    }
-    matchesContiguous(word, wordToMatchAgainst) {
-        const matchIndex = wordToMatchAgainst.toLowerCase().indexOf(word.toLowerCase());
-        if (matchIndex !== -1) {
-            return [{ start: matchIndex, end: matchIndex + word.length }];
-        }
-        return null;
-    }
-    layout(dimension) {
-        this.domNode.style.width = `${dimension.width}px`;
-        this.domNode.style.height = `${dimension.height}px`;
-        const iconsContainerWidth = dimension.width - 30;
-        this.numberOfElementsPerRow = Math.floor(iconsContainerWidth / this.iconContainerWidth);
-        if (this.numberOfElementsPerRow === 0) {
-            throw new Error('Insufficient width');
-        }
-        const extraSpace = iconsContainerWidth % this.iconContainerWidth;
-        const iconElementMargin = Math.floor(extraSpace / this.numberOfElementsPerRow);
-        for (const { element } of this.renderedIcons) {
-            element.style.marginRight = `${iconElementMargin}px`;
-        }
-        const containerPadding = extraSpace % this.numberOfElementsPerRow;
-        if (this.iconsContainer) {
-            this.iconsContainer.style.paddingLeft = `${Math.floor(containerPadding / 2)}px`;
-            this.iconsContainer.style.paddingRight = `${Math.ceil(containerPadding / 2)}px`;
-        }
-        if (this.scrollableElement) {
-            this.scrollableElement.getDomNode().style.height = `${this.iconIdElement ? dimension.height - 80 : dimension.height - 40}px`;
-            this.scrollableElement.scanDomNode();
-        }
-    }
-    getFocus() {
-        return [this.focusedItemIndex];
-    }
-    setSelection(index) {
-        if (index < 0 || index >= this.renderedIcons.length) {
-            throw new Error(`Invalid index ${index}`);
-        }
-        this.focusIcon(index);
-        this._onDidSelect.fire(this.renderedIcons[index].icon);
-    }
-    clearInput() {
-        if (this.inputBox) {
-            this.inputBox.value = '';
-        }
-    }
-    focus() {
-        this.inputBox?.focus();
-        this.focusIcon(0);
-    }
-    focusNext() {
-        this.focusIcon((this.focusedItemIndex + 1) % this.renderedIcons.length);
-    }
-    focusPrevious() {
-        this.focusIcon((this.focusedItemIndex - 1 + this.renderedIcons.length) % this.renderedIcons.length);
-    }
-    focusNextRow() {
-        let nextRowIndex = this.focusedItemIndex + this.numberOfElementsPerRow;
-        if (nextRowIndex >= this.renderedIcons.length) {
-            nextRowIndex = (nextRowIndex + 1) % this.numberOfElementsPerRow;
-            nextRowIndex = nextRowIndex >= this.renderedIcons.length ? 0 : nextRowIndex;
-        }
-        this.focusIcon(nextRowIndex);
-    }
-    focusPreviousRow() {
-        let previousRowIndex = this.focusedItemIndex - this.numberOfElementsPerRow;
-        if (previousRowIndex < 0) {
-            const numberOfRows = Math.floor(this.renderedIcons.length / this.numberOfElementsPerRow);
-            previousRowIndex = this.focusedItemIndex + (this.numberOfElementsPerRow * numberOfRows) - 1;
-            previousRowIndex = previousRowIndex < 0
-                ? this.renderedIcons.length - 1
-                : previousRowIndex >= this.renderedIcons.length
-                    ? previousRowIndex - this.numberOfElementsPerRow
-                    : previousRowIndex;
-        }
-        this.focusIcon(previousRowIndex);
-    }
-    getFocusedIcon() {
-        return this.renderedIcons[this.focusedItemIndex].icon;
-    }
-}
-export { IconSelectBox };

package/vscode/src/vs/base/common/amd.js

@@ -1,101 +0,0 @@
-class LoaderStats {
-    static get() {
-        const amdLoadScript = ( new Map());
-        const amdInvokeFactory = ( new Map());
-        const nodeRequire = ( new Map());
-        const nodeEval = ( new Map());
-        function mark(map, stat) {
-            if (( map.has(stat.detail))) {
-                return;
-            }
-            map.set(stat.detail, -stat.timestamp);
-        }
-        function diff(map, stat) {
-            const duration = map.get(stat.detail);
-            if (!duration) {
-                return;
-            }
-            if (duration >= 0) {
-                return;
-            }
-            map.set(stat.detail, duration + stat.timestamp);
-        }
-        let stats = [];
-        if (typeof require === 'function' && typeof require.getStats === 'function') {
-            stats = require.getStats().slice(0).sort((a, b) => a.timestamp - b.timestamp);
-        }
-        for (const stat of stats) {
-            switch (stat.type) {
-                case 10 :
-                    mark(amdLoadScript, stat);
-                    break;
-                case 11 :
-                case 12 :
-                    diff(amdLoadScript, stat);
-                    break;
-                case 21 :
-                    mark(amdInvokeFactory, stat);
-                    break;
-                case 22 :
-                    diff(amdInvokeFactory, stat);
-                    break;
-                case 33 :
-                    mark(nodeRequire, stat);
-                    break;
-                case 34 :
-                    diff(nodeRequire, stat);
-                    break;
-                case 31 :
-                    mark(nodeEval, stat);
-                    break;
-                case 32 :
-                    diff(nodeEval, stat);
-                    break;
-            }
-        }
-        let nodeRequireTotal = 0;
-        nodeRequire.forEach(value => nodeRequireTotal += value);
-        function to2dArray(map) {
-            const res = [];
-            map.forEach((value, index) => res.push([index, value]));
-            return res;
-        }
-        return {
-            amdLoad: to2dArray(amdLoadScript),
-            amdInvoke: to2dArray(amdInvokeFactory),
-            nodeRequire: to2dArray(nodeRequire),
-            nodeEval: to2dArray(nodeEval),
-            nodeRequireTotal
-        };
-    }
-    static toMarkdownTable(header, rows) {
-        let result = '';
-        const lengths = [];
-        header.forEach((cell, ci) => {
-            lengths[ci] = cell.length;
-        });
-        rows.forEach(row => {
-            row.forEach((cell, ci) => {
-                if (typeof cell === 'undefined') {
-                    cell = row[ci] = '-';
-                }
-                const len = ( cell.toString()).length;
-                lengths[ci] = Math.max(len, lengths[ci]);
-            });
-        });
-        header.forEach((cell, ci) => { result += `| ${cell + ' '.repeat(lengths[ci] - ( cell.toString()).length)} `; });
-        result += '|\n';
-        header.forEach((_cell, ci) => { result += `| ${'-'.repeat(lengths[ci])} `; });
-        result += '|\n';
-        rows.forEach(row => {
-            row.forEach((cell, ci) => {
-                if (typeof cell !== 'undefined') {
-                    result += `| ${cell + ' '.repeat(lengths[ci] - ( cell.toString()).length)} `;
-                }
-            });
-            result += '|\n';
-        });
-        return result;
-    }
-}
-export { LoaderStats };

package/vscode/src/vs/base/common/console.js

@@ -1,60 +0,0 @@
-import './path.js';
-import './platform.js';
-function parse(entry) {
-    const args = [];
-    let stack;
-    try {
-        const parsedArguments = JSON.parse(entry.arguments);
-        const stackArgument = parsedArguments[parsedArguments.length - 1];
-        if (stackArgument && stackArgument.__$stack) {
-            parsedArguments.pop();
-            stack = stackArgument.__$stack;
-        }
-        args.push(...parsedArguments);
-    }
-    catch (error) {
-        args.push('Unable to log remote console arguments', entry.arguments);
-    }
-    return { args, stack };
-}
-function findFirstFrame(stack) {
-    if (!stack) {
-        return stack;
-    }
-    const newlineIndex = stack.indexOf('\n');
-    if (newlineIndex === -1) {
-        return stack;
-    }
-    return stack.substring(0, newlineIndex);
-}
-function log(entry, label) {
-    const { args, stack } = parse(entry);
-    const isOneStringArg = typeof args[0] === 'string' && args.length === 1;
-    let topFrame = findFirstFrame(stack);
-    if (topFrame) {
-        topFrame = `(${topFrame.trim()})`;
-    }
-    let consoleArgs = [];
-    if (typeof args[0] === 'string') {
-        if (topFrame && isOneStringArg) {
-            consoleArgs = [`%c[${label}] %c${args[0]} %c${topFrame}`, color('blue'), color(''), color('grey')];
-        }
-        else {
-            consoleArgs = [`%c[${label}] %c${args[0]}`, color('blue'), color(''), ...args.slice(1)];
-        }
-    }
-    else {
-        consoleArgs = [`%c[${label}]%`, color('blue'), ...args];
-    }
-    if (topFrame && !isOneStringArg) {
-        consoleArgs.push(topFrame);
-    }
-    if (typeof console[entry.severity] !== 'function') {
-        throw new Error('Unknown console method');
-    }
-    console[entry.severity].apply(console, consoleArgs);
-}
-function color(color) {
-    return `color: ${color}`;
-}
-export { log, parse };

package/vscode/src/vs/base/common/paging.js

@@ -1,116 +0,0 @@
-import { range } from './arrays.js';
-import { CancellationTokenSource } from './cancellation.js';
-import { CancellationError } from './errors.js';
-function createPage(elements) {
-    return {
-        isResolved: !!elements,
-        promise: null,
-        cts: null,
-        promiseIndexes: ( new Set()),
-        elements: elements || []
-    };
-}
-function singlePagePager(elements) {
-    return {
-        firstPage: elements,
-        total: elements.length,
-        pageSize: elements.length,
-        getPage: (pageIndex, cancellationToken) => {
-            return Promise.resolve(elements);
-        }
-    };
-}
-class PagedModel {
-    get length() { return this.pager.total; }
-    constructor(arg) {
-        this.pages = [];
-        this.pager = Array.isArray(arg) ? singlePagePager(arg) : arg;
-        const totalPages = Math.ceil(this.pager.total / this.pager.pageSize);
-        this.pages = [
-            createPage(this.pager.firstPage.slice()),
-            ...( range(totalPages - 1).map(() => createPage()))
-        ];
-    }
-    isResolved(index) {
-        const pageIndex = Math.floor(index / this.pager.pageSize);
-        const page = this.pages[pageIndex];
-        return !!page.isResolved;
-    }
-    get(index) {
-        const pageIndex = Math.floor(index / this.pager.pageSize);
-        const indexInPage = index % this.pager.pageSize;
-        const page = this.pages[pageIndex];
-        return page.elements[indexInPage];
-    }
-    resolve(index, cancellationToken) {
-        if (cancellationToken.isCancellationRequested) {
-            return Promise.reject(( new CancellationError()));
-        }
-        const pageIndex = Math.floor(index / this.pager.pageSize);
-        const indexInPage = index % this.pager.pageSize;
-        const page = this.pages[pageIndex];
-        if (page.isResolved) {
-            return Promise.resolve(page.elements[indexInPage]);
-        }
-        if (!page.promise) {
-            page.cts = ( new CancellationTokenSource());
-            page.promise = this.pager.getPage(pageIndex, page.cts.token)
-                .then(elements => {
-                page.elements = elements;
-                page.isResolved = true;
-                page.promise = null;
-                page.cts = null;
-            }, err => {
-                page.isResolved = false;
-                page.promise = null;
-                page.cts = null;
-                return Promise.reject(err);
-            });
-        }
-        const listener = cancellationToken.onCancellationRequested(() => {
-            if (!page.cts) {
-                return;
-            }
-            page.promiseIndexes.delete(index);
-            if (page.promiseIndexes.size === 0) {
-                page.cts.cancel();
-            }
-        });
-        page.promiseIndexes.add(index);
-        return page.promise.then(() => page.elements[indexInPage])
-            .finally(() => listener.dispose());
-    }
-}
-class DelayedPagedModel {
-    get length() { return this.model.length; }
-    constructor(model, timeout = 500) {
-        this.model = model;
-        this.timeout = timeout;
-    }
-    isResolved(index) {
-        return this.model.isResolved(index);
-    }
-    get(index) {
-        return this.model.get(index);
-    }
-    resolve(index, cancellationToken) {
-        return ( new Promise((c, e) => {
-            if (cancellationToken.isCancellationRequested) {
-                return e(( new CancellationError()));
-            }
-            const timer = setTimeout(() => {
-                if (cancellationToken.isCancellationRequested) {
-                    return e(( new CancellationError()));
-                }
-                timeoutCancellation.dispose();
-                this.model.resolve(index, cancellationToken).then(c, e);
-            }, this.timeout);
-            const timeoutCancellation = cancellationToken.onCancellationRequested(() => {
-                clearTimeout(timer);
-                timeoutCancellation.dispose();
-                e(( new CancellationError()));
-            });
-        }));
-    }
-}
-export { DelayedPagedModel, PagedModel, singlePagePager };

package/vscode/src/vs/base/common/parsers.js

@@ -1,43 +0,0 @@
-class ValidationStatus {
-    constructor() {
-        this._state = 0 ;
-    }
-    get state() {
-        return this._state;
-    }
-    set state(value) {
-        if (value > this._state) {
-            this._state = value;
-        }
-    }
-    isOK() {
-        return this._state === 0 ;
-    }
-    isFatal() {
-        return this._state === 4 ;
-    }
-}
-class Parser {
-    constructor(problemReporter) {
-        this._problemReporter = problemReporter;
-    }
-    reset() {
-        this._problemReporter.status.state = 0 ;
-    }
-    get problemReporter() {
-        return this._problemReporter;
-    }
-    info(message) {
-        this._problemReporter.info(message);
-    }
-    warn(message) {
-        this._problemReporter.warn(message);
-    }
-    error(message) {
-        this._problemReporter.error(message);
-    }
-    fatal(message) {
-        this._problemReporter.fatal(message);
-    }
-}
-export { Parser, ValidationStatus };

package/vscode/src/vs/base/common/processes.js

@@ -1,25 +0,0 @@
-import './platform.js';
-function sanitizeProcessEnvironment(env, ...preserve) {
-    const set = preserve.reduce((set, key) => {
-        set[key] = true;
-        return set;
-    }, {});
-    const keysToRemove = [
-        /^ELECTRON_.+$/,
-        /^VSCODE_(?!(PORTABLE|SHELL_LOGIN|ENV_REPLACE|ENV_APPEND|ENV_PREPEND)).+$/,
-        /^SNAP(|_.*)$/,
-        /^GDK_PIXBUF_.+$/,
-    ];
-    const envKeys = ( Object.keys(env));
-    envKeys
-        .filter(key => !set[key])
-        .forEach(envKey => {
-        for (let i = 0; i < keysToRemove.length; i++) {
-            if (envKey.search(keysToRemove[i]) !== -1) {
-                delete env[envKey];
-                break;
-            }
-        }
-    });
-}
-export { sanitizeProcessEnvironment };

package/vscode/src/vs/base/parts/request/browser/request.js

@@ -1,60 +0,0 @@
-import { bufferToStream, VSBuffer } from '../../../common/buffer.js';
-import { canceled } from '../../../common/errors.js';
-import { OfflineError } from '../common/request.js';
-function request(options, token) {
-    if (options.proxyAuthorization) {
-        options.headers = {
-            ...(options.headers || {}),
-            'Proxy-Authorization': options.proxyAuthorization
-        };
-    }
-    const xhr = ( new XMLHttpRequest());
-    return ( new Promise((resolve, reject) => {
-        xhr.open(options.type || 'GET', options.url || '', true, options.user, options.password);
-        setRequestHeaders(xhr, options);
-        xhr.responseType = 'arraybuffer';
-        xhr.onerror = e => reject(navigator.onLine ? ( new Error(xhr.statusText && ('XHR failed: ' + xhr.statusText) || 'XHR failed')) : ( new OfflineError()));
-        xhr.onload = (e) => {
-            resolve({
-                res: {
-                    statusCode: xhr.status,
-                    headers: getResponseHeaders(xhr)
-                },
-                stream: bufferToStream(VSBuffer.wrap(( new Uint8Array(xhr.response))))
-            });
-        };
-        xhr.ontimeout = e => reject(( new Error(`XHR timeout: ${options.timeout}ms`)));
-        if (options.timeout) {
-            xhr.timeout = options.timeout;
-        }
-        xhr.send(options.data);
-        token.onCancellationRequested(() => {
-            xhr.abort();
-            reject(canceled());
-        });
-    }));
-}
-function setRequestHeaders(xhr, options) {
-    if (options.headers) {
-        outer: for (const k in options.headers) {
-            switch (k) {
-                case 'User-Agent':
-                case 'Accept-Encoding':
-                case 'Content-Length':
-                    continue outer;
-            }
-            xhr.setRequestHeader(k, options.headers[k]);
-        }
-    }
-}
-function getResponseHeaders(xhr) {
-    const headers = Object.create(null);
-    for (const line of xhr.getAllResponseHeaders().split(/\r\n|\n|\r/g)) {
-        if (line) {
-            const idx = line.indexOf(':');
-            headers[line.substr(0, idx).trim().toLowerCase()] = line.substr(idx + 1).trim();
-        }
-    }
-    return headers;
-}
-export { request };