TheLanc3/code-server
1
0
Fork 0
mirror of https://github.com/coder/code-server.git synced 2026-05-08 05:17:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore(vscode): update to 1.54.2

Browse Source
This commit is contained in:
Joe Previte
2021-03-11 10:27:10 -07:00
parent 44a4a0bc20 e8cd17a97d
commit 0cd3e39492
1459 changed files with 53404 additions and 51004 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
lib/vscode/src/vs/base/common/actions.ts
View File

@@ -39,19 +39,6 @@ export interface IActionRunner extends IDisposable {
readonly onBeforeRun: Event<IRunEvent>;
}
export interface IActionViewItem extends IDisposable {
actionRunner: IActionRunner;
setActionContext(context: any): void;
render(element: any /* HTMLElement */): void;
isEnabled(): boolean;
focus(fromRight?: boolean): void; // TODO@isidorn what is this?
blur(): void;
}
export interface IActionViewItemProvider {
(action: IAction): IActionViewItem | undefined;
}
export interface IActionChangeEvent {
readonly label?: string;
readonly tooltip?: string;
@@ -205,25 +192,6 @@ export class ActionRunner extends Disposable implements IActionRunner {
}
}
export class RadioGroup extends Disposable {
constructor(readonly actions: Action[]) {
super();
for (const action of actions) {
this._register(action.onDidChange(e => {
if (e.checked && action.checked) {
for (const candidate of actions) {
if (candidate !== action) {
candidate.checked = false;
}
}
}
}));
}
}
}
export class Separator extends Action {
static readonly ID = 'vs.actions.separator';
@@ -235,17 +203,6 @@ export class Separator extends Action {
}
}
export class ActionWithMenuAction extends Action {
get actions(): IAction[] {
return this._actions;
}
constructor(id: string, private _actions: IAction[], label?: string, cssClass?: string, enabled?: boolean, actionCallback?: (event?: any) => Promise<any>) {
super(id, label, cssClass, enabled, actionCallback);
}
}
export class SubmenuAction implements IAction {
readonly id: string;

203
lib/vscode/src/vs/base/common/async.ts
View File

@@ -4,13 +4,14 @@
*--------------------------------------------------------------------------------------------*/
import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
import * as errors from 'vs/base/common/errors';
import { Emitter, Event } from 'vs/base/common/event';
import { canceled, onUnexpectedError } from 'vs/base/common/errors';
import { Emitter, Event, Listener } from 'vs/base/common/event';
import { IDisposable, toDisposable } from 'vs/base/common/lifecycle';
import { LinkedList } from 'vs/base/common/linkedList';
import { URI } from 'vs/base/common/uri';
export function isThenable<T>(obj: any): obj is Promise<T> {
return obj && typeof (<Promise<any>>obj).then === 'function';
export function isThenable<T>(obj: unknown): obj is Promise<T> {
return !!obj && typeof (obj as unknown as Promise<T>).then === 'function';
}
export interface CancelablePromise<T> extends Promise<T> {
@@ -23,7 +24,7 @@ export function createCancelablePromise<T>(callback: (token: CancellationToken)
const thenable = callback(source.token);
const promise = new Promise<T>((resolve, reject) => {
source.token.onCancellationRequested(() => {
reject(errors.canceled());
reject(canceled());
});
Promise.resolve(thenable).then(value => {
source.dispose();
@@ -165,10 +166,10 @@ export class Throttler {
this.activePromise = promiseFactory();
return new Promise((resolve, reject) => {
this.activePromise!.then((result: any) => {
this.activePromise!.then((result: T) => {
this.activePromise = null;
resolve(result);
}, (err: any) => {
}, (err: unknown) => {
this.activePromise = null;
reject(err);
});
@@ -178,7 +179,7 @@ export class Throttler {
export class Sequencer {
private current: Promise<any> = Promise.resolve(null);
private current: Promise<unknown> = Promise.resolve(null);
queue<T>(promiseTask: ITask<Promise<T>>): Promise<T> {
return this.current = this.current.then(() => promiseTask(), () => promiseTask());
@@ -187,7 +188,7 @@ export class Sequencer {
export class SequencerByKey<TKey> {
private promiseMap = new Map<TKey, Promise<any>>();
private promiseMap = new Map<TKey, Promise<unknown>>();
queue<T>(key: TKey, promiseTask: ITask<Promise<T>>): Promise<T> {
const runningPromise = this.promiseMap.get(key) ?? Promise.resolve();
@@ -282,7 +283,7 @@ export class Delayer<T> implements IDisposable {
if (this.completionPromise) {
if (this.doReject) {
this.doReject(errors.canceled());
this.doReject(canceled());
}
this.completionPromise = null;
}
@@ -320,7 +321,7 @@ export class ThrottledDelayer<T> {
}
trigger(promiseFactory: ITask<Promise<T>>, delay?: number): Promise<T> {
return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay) as any as Promise<T>;
return this.delayer.trigger(() => this.throttler.queue(promiseFactory), delay) as unknown as Promise<T>;
}
isTriggered(): boolean {
@@ -366,6 +367,25 @@ export class Barrier {
}
}
/**
* A barrier that is initially closed and then becomes opened permanently after a certain period of
* time or when open is called explicitly
*/
export class AutoOpenBarrier extends Barrier {
private readonly _timeout: any;
constructor(autoOpenTimeMs: number) {
super();
this._timeout = setTimeout(() => this.open(), autoOpenTimeMs);
}
open(): void {
clearTimeout(this._timeout);
super.open();
}
}
export function timeout(millis: number): CancelablePromise<void>;
export function timeout(millis: number, token: CancellationToken): Promise<void>;
export function timeout(millis: number, token?: CancellationToken): CancelablePromise<void> | Promise<void> {
@@ -377,7 +397,7 @@ export function timeout(millis: number, token?: CancellationToken): CancelablePr
const handle = setTimeout(resolve, millis);
token.onCancellationRequested(() => {
clearTimeout(handle);
reject(errors.canceled());
reject(canceled());
});
});
}
@@ -487,7 +507,7 @@ export function firstParallel<T>(promiseList: Promise<T>[], shouldStop: (t: T) =
interface ILimitedTaskFactory<T> {
factory: ITask<Promise<T>>;
c: (value: T | Promise<T>) => void;
e: (error?: any) => void;
e: (error?: unknown) => void;
}
/**
@@ -666,7 +686,7 @@ export class IntervalTimer implements IDisposable {
export class RunOnceScheduler {
protected runner: ((...args: any[]) => void) | null;
protected runner: ((...args: unknown[]) => void) | null;
private timeoutToken: any;
private timeout: number;
@@ -826,7 +846,7 @@ export class IdleValue<T> {
private _didRun: boolean = false;
private _value?: T;
private _error: any;
private _error: unknown;
constructor(executor: () => T) {
this._executor = () => {
@@ -1014,7 +1034,9 @@ export class IntervalCounter {
//#endregion
export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
//#region
export type ValueCallback<T = unknown> = (value: T | Promise<T>) => void;
/**
* Creates a promise whose resolution or rejection can be controlled imperatively.
@@ -1022,7 +1044,7 @@ export type ValueCallback<T = any> = (value: T | Promise<T>) => void;
export class DeferredPromise<T> {
private completeCallback!: ValueCallback<T>;
private errorCallback!: (err: any) => void;
private errorCallback!: (err: unknown) => void;
private rejected = false;
private resolved = false;
@@ -1055,7 +1077,7 @@ export class DeferredPromise<T> {
});
}
public error(err: any) {
public error(err: unknown) {
return new Promise<void>(resolve => {
this.errorCallback(err);
this.rejected = true;
@@ -1065,9 +1087,152 @@ export class DeferredPromise<T> {
public cancel() {
new Promise<void>(resolve => {
this.errorCallback(errors.canceled());
this.errorCallback(canceled());
this.rejected = true;
resolve();
});
}
}
//#endregion
//#region
export interface IWaitUntil {
waitUntil(thenable: Promise<unknown>): void;
}
export class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
private _asyncDeliveryQueue?: LinkedList<[Listener<T>, Omit<T, 'waitUntil'>]>;
async fireAsync(data: Omit<T, 'waitUntil'>, token: CancellationToken, promiseJoin?: (p: Promise<unknown>, listener: Function) => Promise<unknown>): Promise<void> {
if (!this._listeners) {
return;
}
if (!this._asyncDeliveryQueue) {
this._asyncDeliveryQueue = new LinkedList();
}
for (const listener of this._listeners) {
this._asyncDeliveryQueue.push([listener, data]);
}
while (this._asyncDeliveryQueue.size > 0 && !token.isCancellationRequested) {
const [listener, data] = this._asyncDeliveryQueue.shift()!;
const thenables: Promise<unknown>[] = [];
const event = <T>{
...data,
waitUntil: (p: Promise<unknown>): void => {
if (Object.isFrozen(thenables)) {
throw new Error('waitUntil can NOT be called asynchronous');
}
if (promiseJoin) {
p = promiseJoin(p, typeof listener === 'function' ? listener : listener[0]);
}
thenables.push(p);
}
};
try {
if (typeof listener === 'function') {
listener.call(undefined, event);
} else {
listener[0].call(listener[1], event);
}
} catch (e) {
onUnexpectedError(e);
continue;
}
// freeze thenables-collection to enforce sync-calls to
// wait until and then wait for all thenables to resolve
Object.freeze(thenables);
await Promises.settled(thenables).catch(e => onUnexpectedError(e));
}
}
}
//#endregion
//#region Promises
export namespace Promises {
export interface IResolvedPromise<T> {
status: 'fulfilled';
value: T;
}
export interface IRejectedPromise {
status: 'rejected';
reason: Error;
}
/**
* Interface of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
*/
interface PromiseWithAllSettled<T> {
allSettled<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>>;
}
/**
* A polyfill of `Promise.allSettled`: returns after all promises have
* resolved or rejected and provides access to each result or error
* in the order of the original passed in promises array.
* See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
*/
export async function allSettled<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
if (typeof (Promise as unknown as PromiseWithAllSettled<T>).allSettled === 'function') {
return allSettledNative(promises); // in some environments we can benefit from native implementation
}
return allSettledShim(promises);
}
async function allSettledNative<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
return (Promise as unknown as PromiseWithAllSettled<T>).allSettled(promises);
}
async function allSettledShim<T>(promises: Promise<T>[]): Promise<ReadonlyArray<IResolvedPromise<T> | IRejectedPromise>> {
return Promise.all(promises.map(promise => (promise.then(value => {
const fulfilled: IResolvedPromise<T> = { status: 'fulfilled', value };
return fulfilled;
}, error => {
const rejected: IRejectedPromise = { status: 'rejected', reason: error };
return rejected;
}))));
}
/**
* A drop-in replacement for `Promise.all` with the only difference
* that the method awaits every promise to either fulfill or reject.
*
* Similar to `Promise.all`, only the first error will be returned
* if any.
*/
export async function settled<T>(promises: Promise<T>[]): Promise<T[]> {
let firstError: Error | undefined = undefined;
const result = await Promise.all(promises.map(promise => promise.then(value => value, error => {
if (!firstError) {
firstError = error;
}
return undefined; // do not rethrow so that other promises can settle
})));
if (typeof firstError !== 'undefined') {
throw firstError;
}
return result as unknown as T[]; // cast is needed and protected by the `throw` above
}
}
//#endregion

16
lib/vscode/src/vs/base/common/buildunit.json
View File

@@ -1,16 +0,0 @@
{
"name": "vs/base",
"dependencies": [
{
"name": "vs",
"internal": false
}
],
"libs": [
"lib.core.d.ts"
],
"sources": [
"**/*.ts"
],
"declares": []
}

881
lib/vscode/src/vs/base/common/codicons.ts
View File

@@ -71,21 +71,26 @@ export interface CSSIcon {
readonly id: string;
}
export namespace CSSIcon {
export const iconIdRegex = /^(codicon\/)?([a-z\-]+)(?:~([a-z\-]+))?$/i;
export const iconNameSegment = '[A-Za-z0-9]+';
export const iconNameExpression = '[A-Za-z0-9\\-]+';
export const iconModifierExpression = '~[A-Za-z]+';
const cssIconIdRegex = new RegExp(`^(${iconNameExpression})(${iconModifierExpression})?$`);
export function asClassNameArray(icon: CSSIcon): string[] {
if (icon instanceof Codicon) {
return ['codicon', 'codicon-' + icon.id];
}
const match = iconIdRegex.exec(icon.id);
const match = cssIconIdRegex.exec(icon.id);
if (!match) {
return asClassNameArray(Codicon.error);
}
let [, , id, modifier] = match;
let [, id, modifier] = match;
const classNames = ['codicon', 'codicon-' + id];
if (modifier) {
classNames.push('codicon-modifier-' + modifier);
classNames.push('codicon-modifier-' + modifier.substr(1));
}
return classNames;
}
@@ -102,443 +107,447 @@ export namespace CSSIcon {
interface IconDefinition {
character: string;
fontCharacter: string;
}
export namespace Codicon {
// built-in icons, with image name
export const add = new Codicon('add', { character: '\\ea60' });
export const plus = new Codicon('plus', { character: '\\ea60' });
export const gistNew = new Codicon('gist-new', { character: '\\ea60' });
export const repoCreate = new Codicon('repo-create', { character: '\\ea60' });
export const lightbulb = new Codicon('lightbulb', { character: '\\ea61' });
export const lightBulb = new Codicon('light-bulb', { character: '\\ea61' });
export const repo = new Codicon('repo', { character: '\\ea62' });
export const repoDelete = new Codicon('repo-delete', { character: '\\ea62' });
export const gistFork = new Codicon('gist-fork', { character: '\\ea63' });
export const repoForked = new Codicon('repo-forked', { character: '\\ea63' });
export const gitPullRequest = new Codicon('git-pull-request', { character: '\\ea64' });
export const gitPullRequestAbandoned = new Codicon('git-pull-request-abandoned', { character: '\\ea64' });
export const recordKeys = new Codicon('record-keys', { character: '\\ea65' });
export const keyboard = new Codicon('keyboard', { character: '\\ea65' });
export const tag = new Codicon('tag', { character: '\\ea66' });
export const tagAdd = new Codicon('tag-add', { character: '\\ea66' });
export const tagRemove = new Codicon('tag-remove', { character: '\\ea66' });
export const person = new Codicon('person', { character: '\\ea67' });
export const personAdd = new Codicon('person-add', { character: '\\ea67' });
export const personFollow = new Codicon('person-follow', { character: '\\ea67' });
export const personOutline = new Codicon('person-outline', { character: '\\ea67' });
export const personFilled = new Codicon('person-filled', { character: '\\ea67' });
export const gitBranch = new Codicon('git-branch', { character: '\\ea68' });
export const gitBranchCreate = new Codicon('git-branch-create', { character: '\\ea68' });
export const gitBranchDelete = new Codicon('git-branch-delete', { character: '\\ea68' });
export const sourceControl = new Codicon('source-control', { character: '\\ea68' });
export const mirror = new Codicon('mirror', { character: '\\ea69' });
export const mirrorPublic = new Codicon('mirror-public', { character: '\\ea69' });
export const star = new Codicon('star', { character: '\\ea6a' });
export const starAdd = new Codicon('star-add', { character: '\\ea6a' });
export const starDelete = new Codicon('star-delete', { character: '\\ea6a' });
export const starEmpty = new Codicon('star-empty', { character: '\\ea6a' });
export const comment = new Codicon('comment', { character: '\\ea6b' });
export const commentAdd = new Codicon('comment-add', { character: '\\ea6b' });
export const alert = new Codicon('alert', { character: '\\ea6c' });
export const warning = new Codicon('warning', { character: '\\ea6c' });
export const search = new Codicon('search', { character: '\\ea6d' });
export const searchSave = new Codicon('search-save', { character: '\\ea6d' });
export const logOut = new Codicon('log-out', { character: '\\ea6e' });
export const signOut = new Codicon('sign-out', { character: '\\ea6e' });
export const logIn = new Codicon('log-in', { character: '\\ea6f' });
export const signIn = new Codicon('sign-in', { character: '\\ea6f' });
export const eye = new Codicon('eye', { character: '\\ea70' });
export const eyeUnwatch = new Codicon('eye-unwatch', { character: '\\ea70' });
export const eyeWatch = new Codicon('eye-watch', { character: '\\ea70' });
export const circleFilled = new Codicon('circle-filled', { character: '\\ea71' });
export const primitiveDot = new Codicon('primitive-dot', { character: '\\ea71' });
export const closeDirty = new Codicon('close-dirty', { character: '\\ea71' });
export const debugBreakpoint = new Codicon('debug-breakpoint', { character: '\\ea71' });
export const debugBreakpointDisabled = new Codicon('debug-breakpoint-disabled', { character: '\\ea71' });
export const debugHint = new Codicon('debug-hint', { character: '\\ea71' });
export const primitiveSquare = new Codicon('primitive-square', { character: '\\ea72' });
export const edit = new Codicon('edit', { character: '\\ea73' });
export const pencil = new Codicon('pencil', { character: '\\ea73' });
export const info = new Codicon('info', { character: '\\ea74' });
export const issueOpened = new Codicon('issue-opened', { character: '\\ea74' });
export const gistPrivate = new Codicon('gist-private', { character: '\\ea75' });
export const gitForkPrivate = new Codicon('git-fork-private', { character: '\\ea75' });
export const lock = new Codicon('lock', { character: '\\ea75' });
export const mirrorPrivate = new Codicon('mirror-private', { character: '\\ea75' });
export const close = new Codicon('close', { character: '\\ea76' });
export const removeClose = new Codicon('remove-close', { character: '\\ea76' });
export const x = new Codicon('x', { character: '\\ea76' });
export const repoSync = new Codicon('repo-sync', { character: '\\ea77' });
export const sync = new Codicon('sync', { character: '\\ea77' });
export const clone = new Codicon('clone', { character: '\\ea78' });
export const desktopDownload = new Codicon('desktop-download', { character: '\\ea78' });
export const beaker = new Codicon('beaker', { character: '\\ea79' });
export const microscope = new Codicon('microscope', { character: '\\ea79' });
export const vm = new Codicon('vm', { character: '\\ea7a' });
export const deviceDesktop = new Codicon('device-desktop', { character: '\\ea7a' });
export const file = new Codicon('file', { character: '\\ea7b' });
export const fileText = new Codicon('file-text', { character: '\\ea7b' });
export const more = new Codicon('more', { character: '\\ea7c' });
export const ellipsis = new Codicon('ellipsis', { character: '\\ea7c' });
export const kebabHorizontal = new Codicon('kebab-horizontal', { character: '\\ea7c' });
export const mailReply = new Codicon('mail-reply', { character: '\\ea7d' });
export const reply = new Codicon('reply', { character: '\\ea7d' });
export const organization = new Codicon('organization', { character: '\\ea7e' });
export const organizationFilled = new Codicon('organization-filled', { character: '\\ea7e' });
export const organizationOutline = new Codicon('organization-outline', { character: '\\ea7e' });
export const newFile = new Codicon('new-file', { character: '\\ea7f' });
export const fileAdd = new Codicon('file-add', { character: '\\ea7f' });
export const newFolder = new Codicon('new-folder', { character: '\\ea80' });
export const fileDirectoryCreate = new Codicon('file-directory-create', { character: '\\ea80' });
export const trash = new Codicon('trash', { character: '\\ea81' });
export const trashcan = new Codicon('trashcan', { character: '\\ea81' });
export const history = new Codicon('history', { character: '\\ea82' });
export const clock = new Codicon('clock', { character: '\\ea82' });
export const folder = new Codicon('folder', { character: '\\ea83' });
export const fileDirectory = new Codicon('file-directory', { character: '\\ea83' });
export const symbolFolder = new Codicon('symbol-folder', { character: '\\ea83' });
export const logoGithub = new Codicon('logo-github', { character: '\\ea84' });
export const markGithub = new Codicon('mark-github', { character: '\\ea84' });
export const github = new Codicon('github', { character: '\\ea84' });
export const terminal = new Codicon('terminal', { character: '\\ea85' });
export const console = new Codicon('console', { character: '\\ea85' });
export const repl = new Codicon('repl', { character: '\\ea85' });
export const zap = new Codicon('zap', { character: '\\ea86' });
export const symbolEvent = new Codicon('symbol-event', { character: '\\ea86' });
export const error = new Codicon('error', { character: '\\ea87' });
export const stop = new Codicon('stop', { character: '\\ea87' });
export const variable = new Codicon('variable', { character: '\\ea88' });
export const symbolVariable = new Codicon('symbol-variable', { character: '\\ea88' });
export const array = new Codicon('array', { character: '\\ea8a' });
export const symbolArray = new Codicon('symbol-array', { character: '\\ea8a' });
export const symbolModule = new Codicon('symbol-module', { character: '\\ea8b' });
export const symbolPackage = new Codicon('symbol-package', { character: '\\ea8b' });
export const symbolNamespace = new Codicon('symbol-namespace', { character: '\\ea8b' });
export const symbolObject = new Codicon('symbol-object', { character: '\\ea8b' });
export const symbolMethod = new Codicon('symbol-method', { character: '\\ea8c' });
export const symbolFunction = new Codicon('symbol-function', { character: '\\ea8c' });
export const symbolConstructor = new Codicon('symbol-constructor', { character: '\\ea8c' });
export const symbolBoolean = new Codicon('symbol-boolean', { character: '\\ea8f' });
export const symbolNull = new Codicon('symbol-null', { character: '\\ea8f' });
export const symbolNumeric = new Codicon('symbol-numeric', { character: '\\ea90' });
export const symbolNumber = new Codicon('symbol-number', { character: '\\ea90' });
export const symbolStructure = new Codicon('symbol-structure', { character: '\\ea91' });
export const symbolStruct = new Codicon('symbol-struct', { character: '\\ea91' });
export const symbolParameter = new Codicon('symbol-parameter', { character: '\\ea92' });
export const symbolTypeParameter = new Codicon('symbol-type-parameter', { character: '\\ea92' });
export const symbolKey = new Codicon('symbol-key', { character: '\\ea93' });
export const symbolText = new Codicon('symbol-text', { character: '\\ea93' });
export const symbolReference = new Codicon('symbol-reference', { character: '\\ea94' });
export const goToFile = new Codicon('go-to-file', { character: '\\ea94' });
export const symbolEnum = new Codicon('symbol-enum', { character: '\\ea95' });
export const symbolValue = new Codicon('symbol-value', { character: '\\ea95' });
export const symbolRuler = new Codicon('symbol-ruler', { character: '\\ea96' });
export const symbolUnit = new Codicon('symbol-unit', { character: '\\ea96' });
export const activateBreakpoints = new Codicon('activate-breakpoints', { character: '\\ea97' });
export const archive = new Codicon('archive', { character: '\\ea98' });
export const arrowBoth = new Codicon('arrow-both', { character: '\\ea99' });
export const arrowDown = new Codicon('arrow-down', { character: '\\ea9a' });
export const arrowLeft = new Codicon('arrow-left', { character: '\\ea9b' });
export const arrowRight = new Codicon('arrow-right', { character: '\\ea9c' });
export const arrowSmallDown = new Codicon('arrow-small-down', { character: '\\ea9d' });
export const arrowSmallLeft = new Codicon('arrow-small-left', { character: '\\ea9e' });
export const arrowSmallRight = new Codicon('arrow-small-right', { character: '\\ea9f' });
export const arrowSmallUp = new Codicon('arrow-small-up', { character: '\\eaa0' });
export const arrowUp = new Codicon('arrow-up', { character: '\\eaa1' });
export const bell = new Codicon('bell', { character: '\\eaa2' });
export const bold = new Codicon('bold', { character: '\\eaa3' });
export const book = new Codicon('book', { character: '\\eaa4' });
export const bookmark = new Codicon('bookmark', { character: '\\eaa5' });
export const debugBreakpointConditionalUnverified = new Codicon('debug-breakpoint-conditional-unverified', { character: '\\eaa6' });
export const debugBreakpointConditional = new Codicon('debug-breakpoint-conditional', { character: '\\eaa7' });
export const debugBreakpointConditionalDisabled = new Codicon('debug-breakpoint-conditional-disabled', { character: '\\eaa7' });
export const debugBreakpointDataUnverified = new Codicon('debug-breakpoint-data-unverified', { character: '\\eaa8' });
export const debugBreakpointData = new Codicon('debug-breakpoint-data', { character: '\\eaa9' });
export const debugBreakpointDataDisabled = new Codicon('debug-breakpoint-data-disabled', { character: '\\eaa9' });
export const debugBreakpointLogUnverified = new Codicon('debug-breakpoint-log-unverified', { character: '\\eaaa' });
export const debugBreakpointLog = new Codicon('debug-breakpoint-log', { character: '\\eaab' });
export const debugBreakpointLogDisabled = new Codicon('debug-breakpoint-log-disabled', { character: '\\eaab' });
export const briefcase = new Codicon('briefcase', { character: '\\eaac' });
export const broadcast = new Codicon('broadcast', { character: '\\eaad' });
export const browser = new Codicon('browser', { character: '\\eaae' });
export const bug = new Codicon('bug', { character: '\\eaaf' });
export const calendar = new Codicon('calendar', { character: '\\eab0' });
export const caseSensitive = new Codicon('case-sensitive', { character: '\\eab1' });
export const check = new Codicon('check', { character: '\\eab2' });
export const checklist = new Codicon('checklist', { character: '\\eab3' });
export const chevronDown = new Codicon('chevron-down', { character: '\\eab4' });
export const chevronLeft = new Codicon('chevron-left', { character: '\\eab5' });
export const chevronRight = new Codicon('chevron-right', { character: '\\eab6' });
export const chevronUp = new Codicon('chevron-up', { character: '\\eab7' });
export const chromeClose = new Codicon('chrome-close', { character: '\\eab8' });
export const chromeMaximize = new Codicon('chrome-maximize', { character: '\\eab9' });
export const chromeMinimize = new Codicon('chrome-minimize', { character: '\\eaba' });
export const chromeRestore = new Codicon('chrome-restore', { character: '\\eabb' });
export const circleOutline = new Codicon('circle-outline', { character: '\\eabc' });
export const debugBreakpointUnverified = new Codicon('debug-breakpoint-unverified', { character: '\\eabc' });
export const circleSlash = new Codicon('circle-slash', { character: '\\eabd' });
export const circuitBoard = new Codicon('circuit-board', { character: '\\eabe' });
export const clearAll = new Codicon('clear-all', { character: '\\eabf' });
export const clippy = new Codicon('clippy', { character: '\\eac0' });
export const closeAll = new Codicon('close-all', { character: '\\eac1' });
export const cloudDownload = new Codicon('cloud-download', { character: '\\eac2' });
export const cloudUpload = new Codicon('cloud-upload', { character: '\\eac3' });
export const code = new Codicon('code', { character: '\\eac4' });
export const collapseAll = new Codicon('collapse-all', { character: '\\eac5' });
export const colorMode = new Codicon('color-mode', { character: '\\eac6' });
export const commentDiscussion = new Codicon('comment-discussion', { character: '\\eac7' });
export const compareChanges = new Codicon('compare-changes', { character: '\\eafd' });
export const creditCard = new Codicon('credit-card', { character: '\\eac9' });
export const dash = new Codicon('dash', { character: '\\eacc' });
export const dashboard = new Codicon('dashboard', { character: '\\eacd' });
export const database = new Codicon('database', { character: '\\eace' });
export const debugContinue = new Codicon('debug-continue', { character: '\\eacf' });
export const debugDisconnect = new Codicon('debug-disconnect', { character: '\\ead0' });
export const debugPause = new Codicon('debug-pause', { character: '\\ead1' });
export const debugRestart = new Codicon('debug-restart', { character: '\\ead2' });
export const debugStart = new Codicon('debug-start', { character: '\\ead3' });
export const debugStepInto = new Codicon('debug-step-into', { character: '\\ead4' });
export const debugStepOut = new Codicon('debug-step-out', { character: '\\ead5' });
export const debugStepOver = new Codicon('debug-step-over', { character: '\\ead6' });
export const debugStop = new Codicon('debug-stop', { character: '\\ead7' });
export const debug = new Codicon('debug', { character: '\\ead8' });
export const deviceCameraVideo = new Codicon('device-camera-video', { character: '\\ead9' });
export const deviceCamera = new Codicon('device-camera', { character: '\\eada' });
export const deviceMobile = new Codicon('device-mobile', { character: '\\eadb' });
export const diffAdded = new Codicon('diff-added', { character: '\\eadc' });
export const diffIgnored = new Codicon('diff-ignored', { character: '\\eadd' });
export const diffModified = new Codicon('diff-modified', { character: '\\eade' });
export const diffRemoved = new Codicon('diff-removed', { character: '\\eadf' });
export const diffRenamed = new Codicon('diff-renamed', { character: '\\eae0' });
export const diff = new Codicon('diff', { character: '\\eae1' });
export const discard = new Codicon('discard', { character: '\\eae2' });
export const editorLayout = new Codicon('editor-layout', { character: '\\eae3' });
export const emptyWindow = new Codicon('empty-window', { character: '\\eae4' });
export const exclude = new Codicon('exclude', { character: '\\eae5' });
export const extensions = new Codicon('extensions', { character: '\\eae6' });
export const eyeClosed = new Codicon('eye-closed', { character: '\\eae7' });
export const fileBinary = new Codicon('file-binary', { character: '\\eae8' });
export const fileCode = new Codicon('file-code', { character: '\\eae9' });
export const fileMedia = new Codicon('file-media', { character: '\\eaea' });
export const filePdf = new Codicon('file-pdf', { character: '\\eaeb' });
export const fileSubmodule = new Codicon('file-submodule', { character: '\\eaec' });
export const fileSymlinkDirectory = new Codicon('file-symlink-directory', { character: '\\eaed' });
export const fileSymlinkFile = new Codicon('file-symlink-file', { character: '\\eaee' });
export const fileZip = new Codicon('file-zip', { character: '\\eaef' });
export const files = new Codicon('files', { character: '\\eaf0' });
export const filter = new Codicon('filter', { character: '\\eaf1' });
export const flame = new Codicon('flame', { character: '\\eaf2' });
export const foldDown = new Codicon('fold-down', { character: '\\eaf3' });
export const foldUp = new Codicon('fold-up', { character: '\\eaf4' });
export const fold = new Codicon('fold', { character: '\\eaf5' });
export const folderActive = new Codicon('folder-active', { character: '\\eaf6' });
export const folderOpened = new Codicon('folder-opened', { character: '\\eaf7' });
export const gear = new Codicon('gear', { character: '\\eaf8' });
export const gift = new Codicon('gift', { character: '\\eaf9' });
export const gistSecret = new Codicon('gist-secret', { character: '\\eafa' });
export const gist = new Codicon('gist', { character: '\\eafb' });
export const gitCommit = new Codicon('git-commit', { character: '\\eafc' });
export const gitCompare = new Codicon('git-compare', { character: '\\eafd' });
export const gitMerge = new Codicon('git-merge', { character: '\\eafe' });
export const githubAction = new Codicon('github-action', { character: '\\eaff' });
export const githubAlt = new Codicon('github-alt', { character: '\\eb00' });
export const globe = new Codicon('globe', { character: '\\eb01' });
export const grabber = new Codicon('grabber', { character: '\\eb02' });
export const graph = new Codicon('graph', { character: '\\eb03' });
export const gripper = new Codicon('gripper', { character: '\\eb04' });
export const heart = new Codicon('heart', { character: '\\eb05' });
export const home = new Codicon('home', { character: '\\eb06' });
export const horizontalRule = new Codicon('horizontal-rule', { character: '\\eb07' });
export const hubot = new Codicon('hubot', { character: '\\eb08' });
export const inbox = new Codicon('inbox', { character: '\\eb09' });
export const issueClosed = new Codicon('issue-closed', { character: '\\eb0a' });
export const issueReopened = new Codicon('issue-reopened', { character: '\\eb0b' });
export const issues = new Codicon('issues', { character: '\\eb0c' });
export const italic = new Codicon('italic', { character: '\\eb0d' });
export const jersey = new Codicon('jersey', { character: '\\eb0e' });
export const json = new Codicon('json', { character: '\\eb0f' });
export const kebabVertical = new Codicon('kebab-vertical', { character: '\\eb10' });
export const key = new Codicon('key', { character: '\\eb11' });
export const law = new Codicon('law', { character: '\\eb12' });
export const lightbulbAutofix = new Codicon('lightbulb-autofix', { character: '\\eb13' });
export const linkExternal = new Codicon('link-external', { character: '\\eb14' });
export const link = new Codicon('link', { character: '\\eb15' });
export const listOrdered = new Codicon('list-ordered', { character: '\\eb16' });
export const listUnordered = new Codicon('list-unordered', { character: '\\eb17' });
export const liveShare = new Codicon('live-share', { character: '\\eb18' });
export const loading = new Codicon('loading', { character: '\\eb19' });
export const location = new Codicon('location', { character: '\\eb1a' });
export const mailRead = new Codicon('mail-read', { character: '\\eb1b' });
export const mail = new Codicon('mail', { character: '\\eb1c' });
export const markdown = new Codicon('markdown', { character: '\\eb1d' });
export const megaphone = new Codicon('megaphone', { character: '\\eb1e' });
export const mention = new Codicon('mention', { character: '\\eb1f' });
export const milestone = new Codicon('milestone', { character: '\\eb20' });
export const mortarBoard = new Codicon('mortar-board', { character: '\\eb21' });
export const move = new Codicon('move', { character: '\\eb22' });
export const multipleWindows = new Codicon('multiple-windows', { character: '\\eb23' });
export const mute = new Codicon('mute', { character: '\\eb24' });
export const noNewline = new Codicon('no-newline', { character: '\\eb25' });
export const note = new Codicon('note', { character: '\\eb26' });
export const octoface = new Codicon('octoface', { character: '\\eb27' });
export const openPreview = new Codicon('open-preview', { character: '\\eb28' });
export const package_ = new Codicon('package', { character: '\\eb29' });
export const paintcan = new Codicon('paintcan', { character: '\\eb2a' });
export const pin = new Codicon('pin', { character: '\\eb2b' });
export const play = new Codicon('play', { character: '\\eb2c' });
export const run = new Codicon('run', { character: '\\eb2c' });
export const plug = new Codicon('plug', { character: '\\eb2d' });
export const preserveCase = new Codicon('preserve-case', { character: '\\eb2e' });
export const preview = new Codicon('preview', { character: '\\eb2f' });
export const project = new Codicon('project', { character: '\\eb30' });
export const pulse = new Codicon('pulse', { character: '\\eb31' });
export const question = new Codicon('question', { character: '\\eb32' });
export const quote = new Codicon('quote', { character: '\\eb33' });
export const radioTower = new Codicon('radio-tower', { character: '\\eb34' });
export const reactions = new Codicon('reactions', { character: '\\eb35' });
export const references = new Codicon('references', { character: '\\eb36' });
export const refresh = new Codicon('refresh', { character: '\\eb37' });
export const regex = new Codicon('regex', { character: '\\eb38' });
export const remoteExplorer = new Codicon('remote-explorer', { character: '\\eb39' });
export const remote = new Codicon('remote', { character: '\\eb3a' });
export const remove = new Codicon('remove', { character: '\\eb3b' });
export const replaceAll = new Codicon('replace-all', { character: '\\eb3c' });
export const replace = new Codicon('replace', { character: '\\eb3d' });
export const repoClone = new Codicon('repo-clone', { character: '\\eb3e' });
export const repoForcePush = new Codicon('repo-force-push', { character: '\\eb3f' });
export const repoPull = new Codicon('repo-pull', { character: '\\eb40' });
export const repoPush = new Codicon('repo-push', { character: '\\eb41' });
export const report = new Codicon('report', { character: '\\eb42' });
export const requestChanges = new Codicon('request-changes', { character: '\\eb43' });
export const rocket = new Codicon('rocket', { character: '\\eb44' });
export const rootFolderOpened = new Codicon('root-folder-opened', { character: '\\eb45' });
export const rootFolder = new Codicon('root-folder', { character: '\\eb46' });
export const rss = new Codicon('rss', { character: '\\eb47' });
export const ruby = new Codicon('ruby', { character: '\\eb48' });
export const saveAll = new Codicon('save-all', { character: '\\eb49' });
export const saveAs = new Codicon('save-as', { character: '\\eb4a' });
export const save = new Codicon('save', { character: '\\eb4b' });
export const screenFull = new Codicon('screen-full', { character: '\\eb4c' });
export const screenNormal = new Codicon('screen-normal', { character: '\\eb4d' });
export const searchStop = new Codicon('search-stop', { character: '\\eb4e' });
export const server = new Codicon('server', { character: '\\eb50' });
export const settingsGear = new Codicon('settings-gear', { character: '\\eb51' });
export const settings = new Codicon('settings', { character: '\\eb52' });
export const shield = new Codicon('shield', { character: '\\eb53' });
export const smiley = new Codicon('smiley', { character: '\\eb54' });
export const sortPrecedence = new Codicon('sort-precedence', { character: '\\eb55' });
export const splitHorizontal = new Codicon('split-horizontal', { character: '\\eb56' });
export const splitVertical = new Codicon('split-vertical', { character: '\\eb57' });
export const squirrel = new Codicon('squirrel', { character: '\\eb58' });
export const starFull = new Codicon('star-full', { character: '\\eb59' });
export const starHalf = new Codicon('star-half', { character: '\\eb5a' });
export const symbolClass = new Codicon('symbol-class', { character: '\\eb5b' });
export const symbolColor = new Codicon('symbol-color', { character: '\\eb5c' });
export const symbolConstant = new Codicon('symbol-constant', { character: '\\eb5d' });
export const symbolEnumMember = new Codicon('symbol-enum-member', { character: '\\eb5e' });
export const symbolField = new Codicon('symbol-field', { character: '\\eb5f' });
export const symbolFile = new Codicon('symbol-file', { character: '\\eb60' });
export const symbolInterface = new Codicon('symbol-interface', { character: '\\eb61' });
export const symbolKeyword = new Codicon('symbol-keyword', { character: '\\eb62' });
export const symbolMisc = new Codicon('symbol-misc', { character: '\\eb63' });
export const symbolOperator = new Codicon('symbol-operator', { character: '\\eb64' });
export const symbolProperty = new Codicon('symbol-property', { character: '\\eb65' });
export const wrench = new Codicon('wrench', { character: '\\eb65' });
export const wrenchSubaction = new Codicon('wrench-subaction', { character: '\\eb65' });
export const symbolSnippet = new Codicon('symbol-snippet', { character: '\\eb66' });
export const tasklist = new Codicon('tasklist', { character: '\\eb67' });
export const telescope = new Codicon('telescope', { character: '\\eb68' });
export const textSize = new Codicon('text-size', { character: '\\eb69' });
export const threeBars = new Codicon('three-bars', { character: '\\eb6a' });
export const thumbsdown = new Codicon('thumbsdown', { character: '\\eb6b' });
export const thumbsup = new Codicon('thumbsup', { character: '\\eb6c' });
export const tools = new Codicon('tools', { character: '\\eb6d' });
export const triangleDown = new Codicon('triangle-down', { character: '\\eb6e' });
export const triangleLeft = new Codicon('triangle-left', { character: '\\eb6f' });
export const triangleRight = new Codicon('triangle-right', { character: '\\eb70' });
export const triangleUp = new Codicon('triangle-up', { character: '\\eb71' });
export const twitter = new Codicon('twitter', { character: '\\eb72' });
export const unfold = new Codicon('unfold', { character: '\\eb73' });
export const unlock = new Codicon('unlock', { character: '\\eb74' });
export const unmute = new Codicon('unmute', { character: '\\eb75' });
export const unverified = new Codicon('unverified', { character: '\\eb76' });
export const verified = new Codicon('verified', { character: '\\eb77' });
export const versions = new Codicon('versions', { character: '\\eb78' });
export const vmActive = new Codicon('vm-active', { character: '\\eb79' });
export const vmOutline = new Codicon('vm-outline', { character: '\\eb7a' });
export const vmRunning = new Codicon('vm-running', { character: '\\eb7b' });
export const watch = new Codicon('watch', { character: '\\eb7c' });
export const whitespace = new Codicon('whitespace', { character: '\\eb7d' });
export const wholeWord = new Codicon('whole-word', { character: '\\eb7e' });
export const window = new Codicon('window', { character: '\\eb7f' });
export const wordWrap = new Codicon('word-wrap', { character: '\\eb80' });
export const zoomIn = new Codicon('zoom-in', { character: '\\eb81' });
export const zoomOut = new Codicon('zoom-out', { character: '\\eb82' });
export const listFilter = new Codicon('list-filter', { character: '\\eb83' });
export const listFlat = new Codicon('list-flat', { character: '\\eb84' });
export const listSelection = new Codicon('list-selection', { character: '\\eb85' });
export const selection = new Codicon('selection', { character: '\\eb85' });
export const listTree = new Codicon('list-tree', { character: '\\eb86' });
export const debugBreakpointFunctionUnverified = new Codicon('debug-breakpoint-function-unverified', { character: '\\eb87' });
export const debugBreakpointFunction = new Codicon('debug-breakpoint-function', { character: '\\eb88' });
export const debugBreakpointFunctionDisabled = new Codicon('debug-breakpoint-function-disabled', { character: '\\eb88' });
export const debugStackframeActive = new Codicon('debug-stackframe-active', { character: '\\eb89' });
export const debugStackframeDot = new Codicon('debug-stackframe-dot', { character: '\\eb8a' });
export const debugStackframe = new Codicon('debug-stackframe', { character: '\\eb8b' });
export const debugStackframeFocused = new Codicon('debug-stackframe-focused', { character: '\\eb8b' });
export const debugBreakpointUnsupported = new Codicon('debug-breakpoint-unsupported', { character: '\\eb8c' });
export const symbolString = new Codicon('symbol-string', { character: '\\eb8d' });
export const debugReverseContinue = new Codicon('debug-reverse-continue', { character: '\\eb8e' });
export const debugStepBack = new Codicon('debug-step-back', { character: '\\eb8f' });
export const debugRestartFrame = new Codicon('debug-restart-frame', { character: '\\eb90' });
export const callIncoming = new Codicon('call-incoming', { character: '\\eb92' });
export const callOutgoing = new Codicon('call-outgoing', { character: '\\eb93' });
export const menu = new Codicon('menu', { character: '\\eb94' });
export const expandAll = new Codicon('expand-all', { character: '\\eb95' });
export const feedback = new Codicon('feedback', { character: '\\eb96' });
export const groupByRefType = new Codicon('group-by-ref-type', { character: '\\eb97' });
export const ungroupByRefType = new Codicon('ungroup-by-ref-type', { character: '\\eb98' });
export const account = new Codicon('account', { character: '\\eb99' });
export const bellDot = new Codicon('bell-dot', { character: '\\eb9a' });
export const debugConsole = new Codicon('debug-console', { character: '\\eb9b' });
export const library = new Codicon('library', { character: '\\eb9c' });
export const output = new Codicon('output', { character: '\\eb9d' });
export const runAll = new Codicon('run-all', { character: '\\eb9e' });
export const syncIgnored = new Codicon('sync-ignored', { character: '\\eb9f' });
export const pinned = new Codicon('pinned', { character: '\\eba0' });
export const githubInverted = new Codicon('github-inverted', { character: '\\eba1' });
export const debugAlt = new Codicon('debug-alt', { character: '\\eb91' });
export const serverProcess = new Codicon('server-process', { character: '\\eba2' });
export const serverEnvironment = new Codicon('server-environment', { character: '\\eba3' });
export const pass = new Codicon('pass', { character: '\\eba4' });
export const stopCircle = new Codicon('stop-circle', { character: '\\eba5' });
export const playCircle = new Codicon('play-circle', { character: '\\eba6' });
export const record = new Codicon('record', { character: '\\eba7' });
export const debugAltSmall = new Codicon('debug-alt-small', { character: '\\eba8' });
export const vmConnect = new Codicon('vm-connect', { character: '\\eba9' });
export const cloud = new Codicon('cloud', { character: '\\ebaa' });
export const merge = new Codicon('merge', { character: '\\ebab' });
export const exportIcon = new Codicon('export', { character: '\\ebac' });
export const graphLeft = new Codicon('graph-left', { character: '\\ebad' });
export const magnet = new Codicon('magnet', { character: '\\ebae' });
export const notebook = new Codicon('notebook', { character: '\\ebaf' });
export const redo = new Codicon('redo', { character: '\\ebb0' });
export const checkAll = new Codicon('check-all', { character: '\\ebb1' });
export const pinnedDirty = new Codicon('pinned-dirty', { character: '\\ebb2' });
export const passFilled = new Codicon('pass-filled', { character: '\\ebb3' });
export const circleLargeFilled = new Codicon('circle-large-filled', { character: '\\ebb4' });
export const circleLargeOutline = new Codicon('circle-large-outline', { character: '\\ebb5' });
export const combine = new Codicon('combine', { character: '\\ebb6' });
export const gather = new Codicon('gather', { character: '\\ebb6' });
export const table = new Codicon('table', { character: '\\ebb7' });
export const variableGroup = new Codicon('variable-group', { character: '\\ebb8' });
export const typeHierarchy = new Codicon('type-hierarchy', { character: '\\ebb9' });
export const typeHierarchySub = new Codicon('type-hierarchy-sub', { character: '\\ebba' });
export const typeHierarchySuper = new Codicon('type-hierarchy-super', { character: '\\ebbb' });
export const gitPullRequestCreate = new Codicon('git-pull-request-create', { character: '\\ebbc' });
export const add = new Codicon('add', { fontCharacter: '\\ea60' });
export const plus = new Codicon('plus', { fontCharacter: '\\ea60' });
export const gistNew = new Codicon('gist-new', { fontCharacter: '\\ea60' });
export const repoCreate = new Codicon('repo-create', { fontCharacter: '\\ea60' });
export const lightbulb = new Codicon('lightbulb', { fontCharacter: '\\ea61' });
export const lightBulb = new Codicon('light-bulb', { fontCharacter: '\\ea61' });
export const repo = new Codicon('repo', { fontCharacter: '\\ea62' });
export const repoDelete = new Codicon('repo-delete', { fontCharacter: '\\ea62' });
export const gistFork = new Codicon('gist-fork', { fontCharacter: '\\ea63' });
export const repoForked = new Codicon('repo-forked', { fontCharacter: '\\ea63' });
export const gitPullRequest = new Codicon('git-pull-request', { fontCharacter: '\\ea64' });
export const gitPullRequestAbandoned = new Codicon('git-pull-request-abandoned', { fontCharacter: '\\ea64' });
export const recordKeys = new Codicon('record-keys', { fontCharacter: '\\ea65' });
export const keyboard = new Codicon('keyboard', { fontCharacter: '\\ea65' });
export const tag = new Codicon('tag', { fontCharacter: '\\ea66' });
export const tagAdd = new Codicon('tag-add', { fontCharacter: '\\ea66' });
export const tagRemove = new Codicon('tag-remove', { fontCharacter: '\\ea66' });
export const person = new Codicon('person', { fontCharacter: '\\ea67' });
export const personAdd = new Codicon('person-add', { fontCharacter: '\\ea67' });
export const personFollow = new Codicon('person-follow', { fontCharacter: '\\ea67' });
export const personOutline = new Codicon('person-outline', { fontCharacter: '\\ea67' });
export const personFilled = new Codicon('person-filled', { fontCharacter: '\\ea67' });
export const gitBranch = new Codicon('git-branch', { fontCharacter: '\\ea68' });
export const gitBranchCreate = new Codicon('git-branch-create', { fontCharacter: '\\ea68' });
export const gitBranchDelete = new Codicon('git-branch-delete', { fontCharacter: '\\ea68' });
export const sourceControl = new Codicon('source-control', { fontCharacter: '\\ea68' });
export const mirror = new Codicon('mirror', { fontCharacter: '\\ea69' });
export const mirrorPublic = new Codicon('mirror-public', { fontCharacter: '\\ea69' });
export const star = new Codicon('star', { fontCharacter: '\\ea6a' });
export const starAdd = new Codicon('star-add', { fontCharacter: '\\ea6a' });
export const starDelete = new Codicon('star-delete', { fontCharacter: '\\ea6a' });
export const starEmpty = new Codicon('star-empty', { fontCharacter: '\\ea6a' });
export const comment = new Codicon('comment', { fontCharacter: '\\ea6b' });
export const commentAdd = new Codicon('comment-add', { fontCharacter: '\\ea6b' });
export const alert = new Codicon('alert', { fontCharacter: '\\ea6c' });
export const warning = new Codicon('warning', { fontCharacter: '\\ea6c' });
export const search = new Codicon('search', { fontCharacter: '\\ea6d' });
export const searchSave = new Codicon('search-save', { fontCharacter: '\\ea6d' });
export const logOut = new Codicon('log-out', { fontCharacter: '\\ea6e' });
export const signOut = new Codicon('sign-out', { fontCharacter: '\\ea6e' });
export const logIn = new Codicon('log-in', { fontCharacter: '\\ea6f' });
export const signIn = new Codicon('sign-in', { fontCharacter: '\\ea6f' });
export const eye = new Codicon('eye', { fontCharacter: '\\ea70' });
export const eyeUnwatch = new Codicon('eye-unwatch', { fontCharacter: '\\ea70' });
export const eyeWatch = new Codicon('eye-watch', { fontCharacter: '\\ea70' });
export const circleFilled = new Codicon('circle-filled', { fontCharacter: '\\ea71' });
export const primitiveDot = new Codicon('primitive-dot', { fontCharacter: '\\ea71' });
export const closeDirty = new Codicon('close-dirty', { fontCharacter: '\\ea71' });
export const debugBreakpoint = new Codicon('debug-breakpoint', { fontCharacter: '\\ea71' });
export const debugBreakpointDisabled = new Codicon('debug-breakpoint-disabled', { fontCharacter: '\\ea71' });
export const debugHint = new Codicon('debug-hint', { fontCharacter: '\\ea71' });
export const primitiveSquare = new Codicon('primitive-square', { fontCharacter: '\\ea72' });
export const edit = new Codicon('edit', { fontCharacter: '\\ea73' });
export const pencil = new Codicon('pencil', { fontCharacter: '\\ea73' });
export const info = new Codicon('info', { fontCharacter: '\\ea74' });
export const issueOpened = new Codicon('issue-opened', { fontCharacter: '\\ea74' });
export const gistPrivate = new Codicon('gist-private', { fontCharacter: '\\ea75' });
export const gitForkPrivate = new Codicon('git-fork-private', { fontCharacter: '\\ea75' });
export const lock = new Codicon('lock', { fontCharacter: '\\ea75' });
export const mirrorPrivate = new Codicon('mirror-private', { fontCharacter: '\\ea75' });
export const close = new Codicon('close', { fontCharacter: '\\ea76' });
export const removeClose = new Codicon('remove-close', { fontCharacter: '\\ea76' });
export const x = new Codicon('x', { fontCharacter: '\\ea76' });
export const repoSync = new Codicon('repo-sync', { fontCharacter: '\\ea77' });
export const sync = new Codicon('sync', { fontCharacter: '\\ea77' });
export const clone = new Codicon('clone', { fontCharacter: '\\ea78' });
export const desktopDownload = new Codicon('desktop-download', { fontCharacter: '\\ea78' });
export const beaker = new Codicon('beaker', { fontCharacter: '\\ea79' });
export const microscope = new Codicon('microscope', { fontCharacter: '\\ea79' });
export const vm = new Codicon('vm', { fontCharacter: '\\ea7a' });
export const deviceDesktop = new Codicon('device-desktop', { fontCharacter: '\\ea7a' });
export const file = new Codicon('file', { fontCharacter: '\\ea7b' });
export const fileText = new Codicon('file-text', { fontCharacter: '\\ea7b' });
export const more = new Codicon('more', { fontCharacter: '\\ea7c' });
export const ellipsis = new Codicon('ellipsis', { fontCharacter: '\\ea7c' });
export const kebabHorizontal = new Codicon('kebab-horizontal', { fontCharacter: '\\ea7c' });
export const mailReply = new Codicon('mail-reply', { fontCharacter: '\\ea7d' });
export const reply = new Codicon('reply', { fontCharacter: '\\ea7d' });
export const organization = new Codicon('organization', { fontCharacter: '\\ea7e' });
export const organizationFilled = new Codicon('organization-filled', { fontCharacter: '\\ea7e' });
export const organizationOutline = new Codicon('organization-outline', { fontCharacter: '\\ea7e' });
export const newFile = new Codicon('new-file', { fontCharacter: '\\ea7f' });
export const fileAdd = new Codicon('file-add', { fontCharacter: '\\ea7f' });
export const newFolder = new Codicon('new-folder', { fontCharacter: '\\ea80' });
export const fileDirectoryCreate = new Codicon('file-directory-create', { fontCharacter: '\\ea80' });
export const trash = new Codicon('trash', { fontCharacter: '\\ea81' });
export const trashcan = new Codicon('trashcan', { fontCharacter: '\\ea81' });
export const history = new Codicon('history', { fontCharacter: '\\ea82' });
export const clock = new Codicon('clock', { fontCharacter: '\\ea82' });
export const folder = new Codicon('folder', { fontCharacter: '\\ea83' });
export const fileDirectory = new Codicon('file-directory', { fontCharacter: '\\ea83' });
export const symbolFolder = new Codicon('symbol-folder', { fontCharacter: '\\ea83' });
export const logoGithub = new Codicon('logo-github', { fontCharacter: '\\ea84' });
export const markGithub = new Codicon('mark-github', { fontCharacter: '\\ea84' });
export const github = new Codicon('github', { fontCharacter: '\\ea84' });
export const terminal = new Codicon('terminal', { fontCharacter: '\\ea85' });
export const console = new Codicon('console', { fontCharacter: '\\ea85' });
export const repl = new Codicon('repl', { fontCharacter: '\\ea85' });
export const zap = new Codicon('zap', { fontCharacter: '\\ea86' });
export const symbolEvent = new Codicon('symbol-event', { fontCharacter: '\\ea86' });
export const error = new Codicon('error', { fontCharacter: '\\ea87' });
export const stop = new Codicon('stop', { fontCharacter: '\\ea87' });
export const variable = new Codicon('variable', { fontCharacter: '\\ea88' });
export const symbolVariable = new Codicon('symbol-variable', { fontCharacter: '\\ea88' });
export const array = new Codicon('array', { fontCharacter: '\\ea8a' });
export const symbolArray = new Codicon('symbol-array', { fontCharacter: '\\ea8a' });
export const symbolModule = new Codicon('symbol-module', { fontCharacter: '\\ea8b' });
export const symbolPackage = new Codicon('symbol-package', { fontCharacter: '\\ea8b' });
export const symbolNamespace = new Codicon('symbol-namespace', { fontCharacter: '\\ea8b' });
export const symbolObject = new Codicon('symbol-object', { fontCharacter: '\\ea8b' });
export const symbolMethod = new Codicon('symbol-method', { fontCharacter: '\\ea8c' });
export const symbolFunction = new Codicon('symbol-function', { fontCharacter: '\\ea8c' });
export const symbolConstructor = new Codicon('symbol-constructor', { fontCharacter: '\\ea8c' });
export const symbolBoolean = new Codicon('symbol-boolean', { fontCharacter: '\\ea8f' });
export const symbolNull = new Codicon('symbol-null', { fontCharacter: '\\ea8f' });
export const symbolNumeric = new Codicon('symbol-numeric', { fontCharacter: '\\ea90' });
export const symbolNumber = new Codicon('symbol-number', { fontCharacter: '\\ea90' });
export const symbolStructure = new Codicon('symbol-structure', { fontCharacter: '\\ea91' });
export const symbolStruct = new Codicon('symbol-struct', { fontCharacter: '\\ea91' });
export const symbolParameter = new Codicon('symbol-parameter', { fontCharacter: '\\ea92' });
export const symbolTypeParameter = new Codicon('symbol-type-parameter', { fontCharacter: '\\ea92' });
export const symbolKey = new Codicon('symbol-key', { fontCharacter: '\\ea93' });
export const symbolText = new Codicon('symbol-text', { fontCharacter: '\\ea93' });
export const symbolReference = new Codicon('symbol-reference', { fontCharacter: '\\ea94' });
export const goToFile = new Codicon('go-to-file', { fontCharacter: '\\ea94' });
export const symbolEnum = new Codicon('symbol-enum', { fontCharacter: '\\ea95' });
export const symbolValue = new Codicon('symbol-value', { fontCharacter: '\\ea95' });
export const symbolRuler = new Codicon('symbol-ruler', { fontCharacter: '\\ea96' });
export const symbolUnit = new Codicon('symbol-unit', { fontCharacter: '\\ea96' });
export const activateBreakpoints = new Codicon('activate-breakpoints', { fontCharacter: '\\ea97' });
export const archive = new Codicon('archive', { fontCharacter: '\\ea98' });
export const arrowBoth = new Codicon('arrow-both', { fontCharacter: '\\ea99' });
export const arrowDown = new Codicon('arrow-down', { fontCharacter: '\\ea9a' });
export const arrowLeft = new Codicon('arrow-left', { fontCharacter: '\\ea9b' });
export const arrowRight = new Codicon('arrow-right', { fontCharacter: '\\ea9c' });
export const arrowSmallDown = new Codicon('arrow-small-down', { fontCharacter: '\\ea9d' });
export const arrowSmallLeft = new Codicon('arrow-small-left', { fontCharacter: '\\ea9e' });
export const arrowSmallRight = new Codicon('arrow-small-right', { fontCharacter: '\\ea9f' });
export const arrowSmallUp = new Codicon('arrow-small-up', { fontCharacter: '\\eaa0' });
export const arrowUp = new Codicon('arrow-up', { fontCharacter: '\\eaa1' });
export const bell = new Codicon('bell', { fontCharacter: '\\eaa2' });
export const bold = new Codicon('bold', { fontCharacter: '\\eaa3' });
export const book = new Codicon('book', { fontCharacter: '\\eaa4' });
export const bookmark = new Codicon('bookmark', { fontCharacter: '\\eaa5' });
export const debugBreakpointConditionalUnverified = new Codicon('debug-breakpoint-conditional-unverified', { fontCharacter: '\\eaa6' });
export const debugBreakpointConditional = new Codicon('debug-breakpoint-conditional', { fontCharacter: '\\eaa7' });
export const debugBreakpointConditionalDisabled = new Codicon('debug-breakpoint-conditional-disabled', { fontCharacter: '\\eaa7' });
export const debugBreakpointDataUnverified = new Codicon('debug-breakpoint-data-unverified', { fontCharacter: '\\eaa8' });
export const debugBreakpointData = new Codicon('debug-breakpoint-data', { fontCharacter: '\\eaa9' });
export const debugBreakpointDataDisabled = new Codicon('debug-breakpoint-data-disabled', { fontCharacter: '\\eaa9' });
export const debugBreakpointLogUnverified = new Codicon('debug-breakpoint-log-unverified', { fontCharacter: '\\eaaa' });
export const debugBreakpointLog = new Codicon('debug-breakpoint-log', { fontCharacter: '\\eaab' });
export const debugBreakpointLogDisabled = new Codicon('debug-breakpoint-log-disabled', { fontCharacter: '\\eaab' });
export const briefcase = new Codicon('briefcase', { fontCharacter: '\\eaac' });
export const broadcast = new Codicon('broadcast', { fontCharacter: '\\eaad' });
export const browser = new Codicon('browser', { fontCharacter: '\\eaae' });
export const bug = new Codicon('bug', { fontCharacter: '\\eaaf' });
export const calendar = new Codicon('calendar', { fontCharacter: '\\eab0' });
export const caseSensitive = new Codicon('case-sensitive', { fontCharacter: '\\eab1' });
export const check = new Codicon('check', { fontCharacter: '\\eab2' });
export const checklist = new Codicon('checklist', { fontCharacter: '\\eab3' });
export const chevronDown = new Codicon('chevron-down', { fontCharacter: '\\eab4' });
export const chevronLeft = new Codicon('chevron-left', { fontCharacter: '\\eab5' });
export const chevronRight = new Codicon('chevron-right', { fontCharacter: '\\eab6' });
export const chevronUp = new Codicon('chevron-up', { fontCharacter: '\\eab7' });
export const chromeClose = new Codicon('chrome-close', { fontCharacter: '\\eab8' });
export const chromeMaximize = new Codicon('chrome-maximize', { fontCharacter: '\\eab9' });
export const chromeMinimize = new Codicon('chrome-minimize', { fontCharacter: '\\eaba' });
export const chromeRestore = new Codicon('chrome-restore', { fontCharacter: '\\eabb' });
export const circleOutline = new Codicon('circle-outline', { fontCharacter: '\\eabc' });
export const debugBreakpointUnverified = new Codicon('debug-breakpoint-unverified', { fontCharacter: '\\eabc' });
export const circleSlash = new Codicon('circle-slash', { fontCharacter: '\\eabd' });
export const circuitBoard = new Codicon('circuit-board', { fontCharacter: '\\eabe' });
export const clearAll = new Codicon('clear-all', { fontCharacter: '\\eabf' });
export const clippy = new Codicon('clippy', { fontCharacter: '\\eac0' });
export const closeAll = new Codicon('close-all', { fontCharacter: '\\eac1' });
export const cloudDownload = new Codicon('cloud-download', { fontCharacter: '\\eac2' });
export const cloudUpload = new Codicon('cloud-upload', { fontCharacter: '\\eac3' });
export const code = new Codicon('code', { fontCharacter: '\\eac4' });
export const collapseAll = new Codicon('collapse-all', { fontCharacter: '\\eac5' });
export const colorMode = new Codicon('color-mode', { fontCharacter: '\\eac6' });
export const commentDiscussion = new Codicon('comment-discussion', { fontCharacter: '\\eac7' });
export const compareChanges = new Codicon('compare-changes', { fontCharacter: '\\eafd' });
export const creditCard = new Codicon('credit-card', { fontCharacter: '\\eac9' });
export const dash = new Codicon('dash', { fontCharacter: '\\eacc' });
export const dashboard = new Codicon('dashboard', { fontCharacter: '\\eacd' });
export const database = new Codicon('database', { fontCharacter: '\\eace' });
export const debugContinue = new Codicon('debug-continue', { fontCharacter: '\\eacf' });
export const debugDisconnect = new Codicon('debug-disconnect', { fontCharacter: '\\ead0' });
export const debugPause = new Codicon('debug-pause', { fontCharacter: '\\ead1' });
export const debugRestart = new Codicon('debug-restart', { fontCharacter: '\\ead2' });
export const debugStart = new Codicon('debug-start', { fontCharacter: '\\ead3' });
export const debugStepInto = new Codicon('debug-step-into', { fontCharacter: '\\ead4' });
export const debugStepOut = new Codicon('debug-step-out', { fontCharacter: '\\ead5' });
export const debugStepOver = new Codicon('debug-step-over', { fontCharacter: '\\ead6' });
export const debugStop = new Codicon('debug-stop', { fontCharacter: '\\ead7' });
export const debug = new Codicon('debug', { fontCharacter: '\\ead8' });
export const deviceCameraVideo = new Codicon('device-camera-video', { fontCharacter: '\\ead9' });
export const deviceCamera = new Codicon('device-camera', { fontCharacter: '\\eada' });
export const deviceMobile = new Codicon('device-mobile', { fontCharacter: '\\eadb' });
export const diffAdded = new Codicon('diff-added', { fontCharacter: '\\eadc' });
export const diffIgnored = new Codicon('diff-ignored', { fontCharacter: '\\eadd' });
export const diffModified = new Codicon('diff-modified', { fontCharacter: '\\eade' });
export const diffRemoved = new Codicon('diff-removed', { fontCharacter: '\\eadf' });
export const diffRenamed = new Codicon('diff-renamed', { fontCharacter: '\\eae0' });
export const diff = new Codicon('diff', { fontCharacter: '\\eae1' });
export const discard = new Codicon('discard', { fontCharacter: '\\eae2' });
export const editorLayout = new Codicon('editor-layout', { fontCharacter: '\\eae3' });
export const emptyWindow = new Codicon('empty-window', { fontCharacter: '\\eae4' });
export const exclude = new Codicon('exclude', { fontCharacter: '\\eae5' });
export const extensions = new Codicon('extensions', { fontCharacter: '\\eae6' });
export const eyeClosed = new Codicon('eye-closed', { fontCharacter: '\\eae7' });
export const fileBinary = new Codicon('file-binary', { fontCharacter: '\\eae8' });
export const fileCode = new Codicon('file-code', { fontCharacter: '\\eae9' });
export const fileMedia = new Codicon('file-media', { fontCharacter: '\\eaea' });
export const filePdf = new Codicon('file-pdf', { fontCharacter: '\\eaeb' });
export const fileSubmodule = new Codicon('file-submodule', { fontCharacter: '\\eaec' });
export const fileSymlinkDirectory = new Codicon('file-symlink-directory', { fontCharacter: '\\eaed' });
export const fileSymlinkFile = new Codicon('file-symlink-file', { fontCharacter: '\\eaee' });
export const fileZip = new Codicon('file-zip', { fontCharacter: '\\eaef' });
export const files = new Codicon('files', { fontCharacter: '\\eaf0' });
export const filter = new Codicon('filter', { fontCharacter: '\\eaf1' });
export const flame = new Codicon('flame', { fontCharacter: '\\eaf2' });
export const foldDown = new Codicon('fold-down', { fontCharacter: '\\eaf3' });
export const foldUp = new Codicon('fold-up', { fontCharacter: '\\eaf4' });
export const fold = new Codicon('fold', { fontCharacter: '\\eaf5' });
export const folderActive = new Codicon('folder-active', { fontCharacter: '\\eaf6' });
export const folderOpened = new Codicon('folder-opened', { fontCharacter: '\\eaf7' });
export const gear = new Codicon('gear', { fontCharacter: '\\eaf8' });
export const gift = new Codicon('gift', { fontCharacter: '\\eaf9' });
export const gistSecret = new Codicon('gist-secret', { fontCharacter: '\\eafa' });
export const gist = new Codicon('gist', { fontCharacter: '\\eafb' });
export const gitCommit = new Codicon('git-commit', { fontCharacter: '\\eafc' });
export const gitCompare = new Codicon('git-compare', { fontCharacter: '\\eafd' });
export const gitMerge = new Codicon('git-merge', { fontCharacter: '\\eafe' });
export const githubAction = new Codicon('github-action', { fontCharacter: '\\eaff' });
export const githubAlt = new Codicon('github-alt', { fontCharacter: '\\eb00' });
export const globe = new Codicon('globe', { fontCharacter: '\\eb01' });
export const grabber = new Codicon('grabber', { fontCharacter: '\\eb02' });
export const graph = new Codicon('graph', { fontCharacter: '\\eb03' });
export const gripper = new Codicon('gripper', { fontCharacter: '\\eb04' });
export const heart = new Codicon('heart', { fontCharacter: '\\eb05' });
export const home = new Codicon('home', { fontCharacter: '\\eb06' });
export const horizontalRule = new Codicon('horizontal-rule', { fontCharacter: '\\eb07' });
export const hubot = new Codicon('hubot', { fontCharacter: '\\eb08' });
export const inbox = new Codicon('inbox', { fontCharacter: '\\eb09' });
export const issueClosed = new Codicon('issue-closed', { fontCharacter: '\\eb0a' });
export const issueReopened = new Codicon('issue-reopened', { fontCharacter: '\\eb0b' });
export const issues = new Codicon('issues', { fontCharacter: '\\eb0c' });
export const italic = new Codicon('italic', { fontCharacter: '\\eb0d' });
export const jersey = new Codicon('jersey', { fontCharacter: '\\eb0e' });
export const json = new Codicon('json', { fontCharacter: '\\eb0f' });
export const kebabVertical = new Codicon('kebab-vertical', { fontCharacter: '\\eb10' });
export const key = new Codicon('key', { fontCharacter: '\\eb11' });
export const law = new Codicon('law', { fontCharacter: '\\eb12' });
export const lightbulbAutofix = new Codicon('lightbulb-autofix', { fontCharacter: '\\eb13' });
export const linkExternal = new Codicon('link-external', { fontCharacter: '\\eb14' });
export const link = new Codicon('link', { fontCharacter: '\\eb15' });
export const listOrdered = new Codicon('list-ordered', { fontCharacter: '\\eb16' });
export const listUnordered = new Codicon('list-unordered', { fontCharacter: '\\eb17' });
export const liveShare = new Codicon('live-share', { fontCharacter: '\\eb18' });
export const loading = new Codicon('loading', { fontCharacter: '\\eb19' });
export const location = new Codicon('location', { fontCharacter: '\\eb1a' });
export const mailRead = new Codicon('mail-read', { fontCharacter: '\\eb1b' });
export const mail = new Codicon('mail', { fontCharacter: '\\eb1c' });
export const markdown = new Codicon('markdown', { fontCharacter: '\\eb1d' });
export const megaphone = new Codicon('megaphone', { fontCharacter: '\\eb1e' });
export const mention = new Codicon('mention', { fontCharacter: '\\eb1f' });
export const milestone = new Codicon('milestone', { fontCharacter: '\\eb20' });
export const mortarBoard = new Codicon('mortar-board', { fontCharacter: '\\eb21' });
export const move = new Codicon('move', { fontCharacter: '\\eb22' });
export const multipleWindows = new Codicon('multiple-windows', { fontCharacter: '\\eb23' });
export const mute = new Codicon('mute', { fontCharacter: '\\eb24' });
export const noNewline = new Codicon('no-newline', { fontCharacter: '\\eb25' });
export const note = new Codicon('note', { fontCharacter: '\\eb26' });
export const octoface = new Codicon('octoface', { fontCharacter: '\\eb27' });
export const openPreview = new Codicon('open-preview', { fontCharacter: '\\eb28' });
export const package_ = new Codicon('package', { fontCharacter: '\\eb29' });
export const paintcan = new Codicon('paintcan', { fontCharacter: '\\eb2a' });
export const pin = new Codicon('pin', { fontCharacter: '\\eb2b' });
export const play = new Codicon('play', { fontCharacter: '\\eb2c' });
export const run = new Codicon('run', { fontCharacter: '\\eb2c' });
export const plug = new Codicon('plug', { fontCharacter: '\\eb2d' });
export const preserveCase = new Codicon('preserve-case', { fontCharacter: '\\eb2e' });
export const preview = new Codicon('preview', { fontCharacter: '\\eb2f' });
export const project = new Codicon('project', { fontCharacter: '\\eb30' });
export const pulse = new Codicon('pulse', { fontCharacter: '\\eb31' });
export const question = new Codicon('question', { fontCharacter: '\\eb32' });
export const quote = new Codicon('quote', { fontCharacter: '\\eb33' });
export const radioTower = new Codicon('radio-tower', { fontCharacter: '\\eb34' });
export const reactions = new Codicon('reactions', { fontCharacter: '\\eb35' });
export const references = new Codicon('references', { fontCharacter: '\\eb36' });
export const refresh = new Codicon('refresh', { fontCharacter: '\\eb37' });
export const regex = new Codicon('regex', { fontCharacter: '\\eb38' });
export const remoteExplorer = new Codicon('remote-explorer', { fontCharacter: '\\eb39' });
export const remote = new Codicon('remote', { fontCharacter: '\\eb3a' });
export const remove = new Codicon('remove', { fontCharacter: '\\eb3b' });
export const replaceAll = new Codicon('replace-all', { fontCharacter: '\\eb3c' });
export const replace = new Codicon('replace', { fontCharacter: '\\eb3d' });
export const repoClone = new Codicon('repo-clone', { fontCharacter: '\\eb3e' });
export const repoForcePush = new Codicon('repo-force-push', { fontCharacter: '\\eb3f' });
export const repoPull = new Codicon('repo-pull', { fontCharacter: '\\eb40' });
export const repoPush = new Codicon('repo-push', { fontCharacter: '\\eb41' });
export const report = new Codicon('report', { fontCharacter: '\\eb42' });
export const requestChanges = new Codicon('request-changes', { fontCharacter: '\\eb43' });
export const rocket = new Codicon('rocket', { fontCharacter: '\\eb44' });
export const rootFolderOpened = new Codicon('root-folder-opened', { fontCharacter: '\\eb45' });
export const rootFolder = new Codicon('root-folder', { fontCharacter: '\\eb46' });
export const rss = new Codicon('rss', { fontCharacter: '\\eb47' });
export const ruby = new Codicon('ruby', { fontCharacter: '\\eb48' });
export const saveAll = new Codicon('save-all', { fontCharacter: '\\eb49' });
export const saveAs = new Codicon('save-as', { fontCharacter: '\\eb4a' });
export const save = new Codicon('save', { fontCharacter: '\\eb4b' });
export const screenFull = new Codicon('screen-full', { fontCharacter: '\\eb4c' });
export const screenNormal = new Codicon('screen-normal', { fontCharacter: '\\eb4d' });
export const searchStop = new Codicon('search-stop', { fontCharacter: '\\eb4e' });
export const server = new Codicon('server', { fontCharacter: '\\eb50' });
export const settingsGear = new Codicon('settings-gear', { fontCharacter: '\\eb51' });
export const settings = new Codicon('settings', { fontCharacter: '\\eb52' });
export const shield = new Codicon('shield', { fontCharacter: '\\eb53' });
export const smiley = new Codicon('smiley', { fontCharacter: '\\eb54' });
export const sortPrecedence = new Codicon('sort-precedence', { fontCharacter: '\\eb55' });
export const splitHorizontal = new Codicon('split-horizontal', { fontCharacter: '\\eb56' });
export const splitVertical = new Codicon('split-vertical', { fontCharacter: '\\eb57' });
export const squirrel = new Codicon('squirrel', { fontCharacter: '\\eb58' });
export const starFull = new Codicon('star-full', { fontCharacter: '\\eb59' });
export const starHalf = new Codicon('star-half', { fontCharacter: '\\eb5a' });
export const symbolClass = new Codicon('symbol-class', { fontCharacter: '\\eb5b' });
export const symbolColor = new Codicon('symbol-color', { fontCharacter: '\\eb5c' });
export const symbolConstant = new Codicon('symbol-constant', { fontCharacter: '\\eb5d' });
export const symbolEnumMember = new Codicon('symbol-enum-member', { fontCharacter: '\\eb5e' });
export const symbolField = new Codicon('symbol-field', { fontCharacter: '\\eb5f' });
export const symbolFile = new Codicon('symbol-file', { fontCharacter: '\\eb60' });
export const symbolInterface = new Codicon('symbol-interface', { fontCharacter: '\\eb61' });
export const symbolKeyword = new Codicon('symbol-keyword', { fontCharacter: '\\eb62' });
export const symbolMisc = new Codicon('symbol-misc', { fontCharacter: '\\eb63' });
export const symbolOperator = new Codicon('symbol-operator', { fontCharacter: '\\eb64' });
export const symbolProperty = new Codicon('symbol-property', { fontCharacter: '\\eb65' });
export const wrench = new Codicon('wrench', { fontCharacter: '\\eb65' });
export const wrenchSubaction = new Codicon('wrench-subaction', { fontCharacter: '\\eb65' });
export const symbolSnippet = new Codicon('symbol-snippet', { fontCharacter: '\\eb66' });
export const tasklist = new Codicon('tasklist', { fontCharacter: '\\eb67' });
export const telescope = new Codicon('telescope', { fontCharacter: '\\eb68' });
export const textSize = new Codicon('text-size', { fontCharacter: '\\eb69' });
export const threeBars = new Codicon('three-bars', { fontCharacter: '\\eb6a' });
export const thumbsdown = new Codicon('thumbsdown', { fontCharacter: '\\eb6b' });
export const thumbsup = new Codicon('thumbsup', { fontCharacter: '\\eb6c' });
export const tools = new Codicon('tools', { fontCharacter: '\\eb6d' });
export const triangleDown = new Codicon('triangle-down', { fontCharacter: '\\eb6e' });
export const triangleLeft = new Codicon('triangle-left', { fontCharacter: '\\eb6f' });
export const triangleRight = new Codicon('triangle-right', { fontCharacter: '\\eb70' });
export const triangleUp = new Codicon('triangle-up', { fontCharacter: '\\eb71' });
export const twitter = new Codicon('twitter', { fontCharacter: '\\eb72' });
export const unfold = new Codicon('unfold', { fontCharacter: '\\eb73' });
export const unlock = new Codicon('unlock', { fontCharacter: '\\eb74' });
export const unmute = new Codicon('unmute', { fontCharacter: '\\eb75' });
export const unverified = new Codicon('unverified', { fontCharacter: '\\eb76' });
export const verified = new Codicon('verified', { fontCharacter: '\\eb77' });
export const versions = new Codicon('versions', { fontCharacter: '\\eb78' });
export const vmActive = new Codicon('vm-active', { fontCharacter: '\\eb79' });
export const vmOutline = new Codicon('vm-outline', { fontCharacter: '\\eb7a' });
export const vmRunning = new Codicon('vm-running', { fontCharacter: '\\eb7b' });
export const watch = new Codicon('watch', { fontCharacter: '\\eb7c' });
export const whitespace = new Codicon('whitespace', { fontCharacter: '\\eb7d' });
export const wholeWord = new Codicon('whole-word', { fontCharacter: '\\eb7e' });
export const window = new Codicon('window', { fontCharacter: '\\eb7f' });
export const wordWrap = new Codicon('word-wrap', { fontCharacter: '\\eb80' });
export const zoomIn = new Codicon('zoom-in', { fontCharacter: '\\eb81' });
export const zoomOut = new Codicon('zoom-out', { fontCharacter: '\\eb82' });
export const listFilter = new Codicon('list-filter', { fontCharacter: '\\eb83' });
export const listFlat = new Codicon('list-flat', { fontCharacter: '\\eb84' });
export const listSelection = new Codicon('list-selection', { fontCharacter: '\\eb85' });
export const selection = new Codicon('selection', { fontCharacter: '\\eb85' });
export const listTree = new Codicon('list-tree', { fontCharacter: '\\eb86' });
export const debugBreakpointFunctionUnverified = new Codicon('debug-breakpoint-function-unverified', { fontCharacter: '\\eb87' });
export const debugBreakpointFunction = new Codicon('debug-breakpoint-function', { fontCharacter: '\\eb88' });
export const debugBreakpointFunctionDisabled = new Codicon('debug-breakpoint-function-disabled', { fontCharacter: '\\eb88' });
export const debugStackframeActive = new Codicon('debug-stackframe-active', { fontCharacter: '\\eb89' });
export const debugStackframeDot = new Codicon('debug-stackframe-dot', { fontCharacter: '\\eb8a' });
export const debugStackframe = new Codicon('debug-stackframe', { fontCharacter: '\\eb8b' });
export const debugStackframeFocused = new Codicon('debug-stackframe-focused', { fontCharacter: '\\eb8b' });
export const debugBreakpointUnsupported = new Codicon('debug-breakpoint-unsupported', { fontCharacter: '\\eb8c' });
export const symbolString = new Codicon('symbol-string', { fontCharacter: '\\eb8d' });
export const debugReverseContinue = new Codicon('debug-reverse-continue', { fontCharacter: '\\eb8e' });
export const debugStepBack = new Codicon('debug-step-back', { fontCharacter: '\\eb8f' });
export const debugRestartFrame = new Codicon('debug-restart-frame', { fontCharacter: '\\eb90' });
export const callIncoming = new Codicon('call-incoming', { fontCharacter: '\\eb92' });
export const callOutgoing = new Codicon('call-outgoing', { fontCharacter: '\\eb93' });
export const menu = new Codicon('menu', { fontCharacter: '\\eb94' });
export const expandAll = new Codicon('expand-all', { fontCharacter: '\\eb95' });
export const feedback = new Codicon('feedback', { fontCharacter: '\\eb96' });
export const groupByRefType = new Codicon('group-by-ref-type', { fontCharacter: '\\eb97' });
export const ungroupByRefType = new Codicon('ungroup-by-ref-type', { fontCharacter: '\\eb98' });
export const account = new Codicon('account', { fontCharacter: '\\eb99' });
export const bellDot = new Codicon('bell-dot', { fontCharacter: '\\eb9a' });
export const debugConsole = new Codicon('debug-console', { fontCharacter: '\\eb9b' });
export const library = new Codicon('library', { fontCharacter: '\\eb9c' });
export const output = new Codicon('output', { fontCharacter: '\\eb9d' });
export const runAll = new Codicon('run-all', { fontCharacter: '\\eb9e' });
export const syncIgnored = new Codicon('sync-ignored', { fontCharacter: '\\eb9f' });
export const pinned = new Codicon('pinned', { fontCharacter: '\\eba0' });
export const githubInverted = new Codicon('github-inverted', { fontCharacter: '\\eba1' });
export const debugAlt = new Codicon('debug-alt', { fontCharacter: '\\eb91' });
export const serverProcess = new Codicon('server-process', { fontCharacter: '\\eba2' });
export const serverEnvironment = new Codicon('server-environment', { fontCharacter: '\\eba3' });
export const pass = new Codicon('pass', { fontCharacter: '\\eba4' });
export const stopCircle = new Codicon('stop-circle', { fontCharacter: '\\eba5' });
export const playCircle = new Codicon('play-circle', { fontCharacter: '\\eba6' });
export const record = new Codicon('record', { fontCharacter: '\\eba7' });
export const debugAltSmall = new Codicon('debug-alt-small', { fontCharacter: '\\eba8' });
export const vmConnect = new Codicon('vm-connect', { fontCharacter: '\\eba9' });
export const cloud = new Codicon('cloud', { fontCharacter: '\\ebaa' });
export const merge = new Codicon('merge', { fontCharacter: '\\ebab' });
export const exportIcon = new Codicon('export', { fontCharacter: '\\ebac' });
export const graphLeft = new Codicon('graph-left', { fontCharacter: '\\ebad' });
export const magnet = new Codicon('magnet', { fontCharacter: '\\ebae' });
export const notebook = new Codicon('notebook', { fontCharacter: '\\ebaf' });
export const redo = new Codicon('redo', { fontCharacter: '\\ebb0' });
export const checkAll = new Codicon('check-all', { fontCharacter: '\\ebb1' });
export const pinnedDirty = new Codicon('pinned-dirty', { fontCharacter: '\\ebb2' });
export const passFilled = new Codicon('pass-filled', { fontCharacter: '\\ebb3' });
export const circleLargeFilled = new Codicon('circle-large-filled', { fontCharacter: '\\ebb4' });
export const circleLargeOutline = new Codicon('circle-large-outline', { fontCharacter: '\\ebb5' });
export const combine = new Codicon('combine', { fontCharacter: '\\ebb6' });
export const gather = new Codicon('gather', { fontCharacter: '\\ebb6' });
export const table = new Codicon('table', { fontCharacter: '\\ebb7' });
export const variableGroup = new Codicon('variable-group', { fontCharacter: '\\ebb8' });
export const typeHierarchy = new Codicon('type-hierarchy', { fontCharacter: '\\ebb9' });
export const typeHierarchySub = new Codicon('type-hierarchy-sub', { fontCharacter: '\\ebba' });
export const typeHierarchySuper = new Codicon('type-hierarchy-super', { fontCharacter: '\\ebbb' });
export const gitPullRequestCreate = new Codicon('git-pull-request-create', { fontCharacter: '\\ebbc' });
export const runAbove = new Codicon('run-above', { fontCharacter: '\\ebbd' });
export const runBelow = new Codicon('run-below', { fontCharacter: '\\ebbe' });
export const notebookTemplate = new Codicon('notebook-template', { fontCharacter: '\\ebbf' });
export const debugRerun = new Codicon('debug-rerun', { fontCharacter: '\\ebc0' });
export const dropDownButton = new Codicon('drop-down-button', Codicon.chevronDown.definition);
}

30
lib/vscode/src/vs/base/common/errors.ts
View File

@@ -3,6 +3,8 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IAction } from 'vs/base/common/actions';
export interface ErrorListenerCallback {
(error: any): void;
}
@@ -221,3 +223,31 @@ export class NotSupportedError extends Error {
}
}
}
export class ExpectedError extends Error {
readonly isExpected = true;
}
export interface IErrorOptions {
actions?: ReadonlyArray<IAction>;
}
export interface IErrorWithActions {
actions?: ReadonlyArray<IAction>;
}
export function isErrorWithActions(obj: unknown): obj is IErrorWithActions {
const candidate = obj as IErrorWithActions | undefined;
return candidate instanceof Error && Array.isArray(candidate.actions);
}
export function createErrorWithActions(message: string, options: IErrorOptions = Object.create(null)): Error & IErrorWithActions {
const result = new Error(message);
if (options.actions) {
(result as IErrorWithActions).actions = options.actions;
}
return result;
}

28
lib/vscode/src/vs/base/common/errorsWithActions.ts
View File

@@ -1,28 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IAction } from 'vs/base/common/actions';
export interface IErrorOptions {
actions?: ReadonlyArray<IAction>;
}
export interface IErrorWithActions {
actions?: ReadonlyArray<IAction>;
}
export function isErrorWithActions(obj: unknown): obj is IErrorWithActions {
return obj instanceof Error && Array.isArray((obj as IErrorWithActions).actions);
}
export function createErrorWithActions(message: string, options: IErrorOptions = Object.create(null)): Error & IErrorWithActions {
const result = new Error(message);
if (options.actions) {
(<IErrorWithActions>result).actions = options.actions;
}
return result;
}

61
lib/vscode/src/vs/base/common/event.ts
View File

@@ -7,7 +7,6 @@ import { onUnexpectedError } from 'vs/base/common/errors';
import { once as onceFn } from 'vs/base/common/functional';
import { Disposable, IDisposable, toDisposable, combinedDisposable, DisposableStore } from 'vs/base/common/lifecycle';
import { LinkedList } from 'vs/base/common/linkedList';
import { CancellationToken } from 'vs/base/common/cancellation';
import { StopWatch } from 'vs/base/common/stopwatch';
/**
@@ -379,7 +378,7 @@ export namespace Event {
}
}
type Listener<T> = [(e: T) => void, any] | ((e: T) => void);
export type Listener<T> = [(e: T) => void, any] | ((e: T) => void);
export interface EmitterOptions {
onFirstListenerAdd?: Function;
@@ -686,64 +685,6 @@ export class PauseableEmitter<T> extends Emitter<T> {
}
}
export interface IWaitUntil {
waitUntil(thenable: Promise<any>): void;
}
export class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
private _asyncDeliveryQueue?: LinkedList<[Listener<T>, Omit<T, 'waitUntil'>]>;
async fireAsync(data: Omit<T, 'waitUntil'>, token: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void> {
if (!this._listeners) {
return;
}
if (!this._asyncDeliveryQueue) {
this._asyncDeliveryQueue = new LinkedList();
}
for (const listener of this._listeners) {
this._asyncDeliveryQueue.push([listener, data]);
}
while (this._asyncDeliveryQueue.size > 0 && !token.isCancellationRequested) {
const [listener, data] = this._asyncDeliveryQueue.shift()!;
const thenables: Promise<any>[] = [];
const event = <T>{
...data,
waitUntil: (p: Promise<any>): void => {
if (Object.isFrozen(thenables)) {
throw new Error('waitUntil can NOT be called asynchronous');
}
if (promiseJoin) {
p = promiseJoin(p, typeof listener === 'function' ? listener : listener[0]);
}
thenables.push(p);
}
};
try {
if (typeof listener === 'function') {
listener.call(undefined, event);
} else {
listener[0].call(listener[1], event);
}
} catch (e) {
onUnexpectedError(e);
continue;
}
// freeze thenables-collection to enforce sync-calls to
// wait until and then wait for all thenables to resolve
Object.freeze(thenables);
await Promise.all(thenables).catch(e => onUnexpectedError(e));
}
}
}
export class EventMultiplexer<T> implements IDisposable {
private readonly emitter: Emitter<T>;

1
lib/vscode/src/vs/base/common/extpath.ts
View File

@@ -28,7 +28,6 @@ export function toSlashes(osPath: string) {
* or `getRoot('\\server\shares\path') === \\server\shares\`
*/
export function getRoot(path: string, sep: string = posix.sep): string {
if (!path) {
return '';
}

4
lib/vscode/src/vs/base/common/filters.ts
View File

@@ -547,8 +547,8 @@ export namespace FuzzyScore {
*/
export const Default: FuzzyScore = ([-100, 0]);
export function isDefault(score?: FuzzyScore): score is [-100, 0, 0] {
return !score || (score[0] === -100 && score[1] === 0 && score[2] === 0);
export function isDefault(score?: FuzzyScore): score is [-100, 0] {
return !score || (score.length === 2 && score[0] === -100 && score[1] === 0);
}
}

14
lib/vscode/src/vs/base/common/iconLabels.ts
View File

@@ -3,28 +3,26 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CSSIcon } from 'vs/base/common/codicons';
import { matchesFuzzy, IMatch } from 'vs/base/common/filters';
import { ltrim } from 'vs/base/common/strings';
export const iconStartMarker = '$(';
const escapeIconsRegex = /(\\)?\$\([a-z0-9\-]+?(?:~[a-z0-9\-]*?)?\)/gi;
const iconsRegex = new RegExp(`\\$\\(${CSSIcon.iconNameExpression}(?:${CSSIcon.iconModifierExpression})?\\)`, 'g'); // no capturing groups
const escapeIconsRegex = new RegExp(`(\\\\)?${iconsRegex.source}`, 'g');
export function escapeIcons(text: string): string {
return text.replace(escapeIconsRegex, (match, escaped) => escaped ? match : `\\${match}`);
}
const markdownEscapedIconsRegex = /\\\$\([a-z0-9\-]+?(?:~[a-z0-9\-]*?)?\)/gi;
const markdownEscapedIconsRegex = new RegExp(`\\\\${iconsRegex.source}`, 'g');
export function markdownEscapeEscapedIcons(text: string): string {
// Need to add an extra \ for escaping in markdown
return text.replace(markdownEscapedIconsRegex, match => `\\${match}`);
}
const markdownUnescapeIconsRegex = /(\\)?\$\\\(([a-z0-9\-]+?(?:~[a-z0-9\-]*?)?)\\\)/gi;
export function markdownUnescapeIcons(text: string): string {
return text.replace(markdownUnescapeIconsRegex, (match, escaped, iconId) => escaped ? match : `$(${iconId})`);
}
const stripIconsRegex = /(\s)?(\\)?\$\([a-z0-9\-]+?(?:~[a-z0-9\-]*?)?\)(\s)?/gi;
const stripIconsRegex = new RegExp(`(\\s)?(\\\\)?${iconsRegex.source}(\\s)?`, 'g');
export function stripIcons(text: string): string {
if (text.indexOf(iconStartMarker) === -1) {
return text;

53
lib/vscode/src/vs/base/common/iterator.ts
View File

@@ -39,6 +39,18 @@ export namespace Iterable {
return false;
}
export function find<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): T | undefined;
export function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined;
export function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined {
for (const element of iterable) {
if (predicate(element)) {
return element;
}
}
return undefined;
}
export function filter<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): Iterable<R>;
export function filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T>;
export function* filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T> {
@@ -71,22 +83,30 @@ export namespace Iterable {
}
}
export function reduce<T, R>(iterable: Iterable<T>, reducer: (previousValue: R, currentValue: T) => R, initialValue: R): R {
let value = initialValue;
for (const element of iterable) {
value = reducer(value, element);
}
return value;
}
/**
* Returns an iterable slice of the array, with the same semantics as `array.slice()`.
*/
export function* slice<T>(iterable: ReadonlyArray<T>, from: number, to = iterable.length): Iterable<T> {
export function* slice<T>(arr: ReadonlyArray<T>, from: number, to = arr.length): Iterable<T> {
if (from < 0) {
from += iterable.length;
from += arr.length;
}
if (to < 0) {
to += iterable.length;
} else if (to > iterable.length) {
to = iterable.length;
to += arr.length;
} else if (to > arr.length) {
to = arr.length;
}
for (; from < to; from++) {
yield iterable[from];
yield arr[from];
}
}
@@ -115,4 +135,25 @@ export namespace Iterable {
return [consumed, { [Symbol.iterator]() { return iterator; } }];
}
/**
* Returns whether the iterables are the same length and all items are
* equal using the comparator function.
*/
export function equals<T>(a: Iterable<T>, b: Iterable<T>, comparator = (at: T, bt: T) => at === bt) {
const ai = a[Symbol.iterator]();
const bi = b[Symbol.iterator]();
while (true) {
const an = ai.next();
const bn = bi.next();
if (an.done !== bn.done) {
return false;
} else if (an.done) {
return true;
} else if (!comparator(an.value, bn.value)) {
return false;
}
}
}
}

11
lib/vscode/src/vs/base/common/keyCodes.ts
View File

@@ -597,6 +597,17 @@ export abstract class ResolvedKeybinding {
/**
* Returns the parts that should be used for dispatching.
* Returns null for parts consisting of only modifier keys
* @example keybinding "Shift" -> null
* @example keybinding ("D" with shift == true) -> "shift+D"
*/
public abstract getDispatchParts(): (string | null)[];
/**
* Returns the parts that should be used for dispatching single modifier keys
* Returns null for parts that contain more than one modifier or a regular key.
* @example keybinding "Shift" -> "shift"
* @example keybinding ("D" with shift == true") -> null
*/
public abstract getSingleModifierDispatchParts(): (string | null)[];
}

10
lib/vscode/src/vs/base/common/lifecycle.ts
View File

@@ -68,7 +68,7 @@ export class MultiDisposeError extends Error {
constructor(
public readonly errors: any[]
) {
super(`Encounter errors while disposing of store. Errors: [${errors.join(', ')}]`);
super(`Encountered errors while disposing of store. Errors: [${errors.join(', ')}]`);
}
}
@@ -231,9 +231,7 @@ export class MutableDisposable<T extends IDisposable> implements IDisposable {
return;
}
if (this._value) {
this._value.dispose();
}
this._value?.dispose();
if (value) {
markTracked(value);
}
@@ -247,9 +245,7 @@ export class MutableDisposable<T extends IDisposable> implements IDisposable {
dispose(): void {
this._isDisposed = true;
markTracked(this);
if (this._value) {
this._value.dispose();
}
this._value?.dispose();
this._value = undefined;
}
}

403
lib/vscode/src/vs/base/common/marked/marked.js
View File

File diff suppressed because one or more lines are too long

2
lib/vscode/src/vs/base/common/network.ts
View File

@@ -64,6 +64,8 @@ export namespace Schemas {
export const vscodeSettings = 'vscode-settings';
export const vscodeWorkspaceTrust = 'vscode-workspace-trust';
export const webviewPanel = 'webview-panel';
/**

15
lib/vscode/src/vs/base/common/paging.ts
View File

@@ -187,18 +187,3 @@ export function mapPager<T, R>(pager: IPager<T>, fn: (t: T) => R): IPager<R> {
getPage: (pageIndex, token) => pager.getPage(pageIndex, token).then(r => r.map(fn))
};
}
/**
* Merges two pagers.
*/
export function mergePagers<T>(one: IPager<T>, other: IPager<T>): IPager<T> {
return {
firstPage: [...one.firstPage, ...other.firstPage],
total: one.total + other.total,
pageSize: one.pageSize + other.pageSize,
getPage(pageIndex: number, token): Promise<T[]> {
return Promise.all([one.getPage(pageIndex, token), other.getPage(pageIndex, token)])
.then(([onePage, otherPage]) => [...onePage, ...otherPage]);
}
};
}

2
lib/vscode/src/vs/base/common/platform.ts
View File

@@ -247,7 +247,7 @@ export const setImmediate: ISetImmediate = (function defineSetImmediate() {
globals.postMessage({ vscodeSetImmediateId: myId }, '*');
};
}
if (nodeProcess) {
if (nodeProcess && typeof nodeProcess.nextTick === 'function') {
return nodeProcess.nextTick.bind(nodeProcess);
}
const _promise = Promise.resolve();

4
lib/vscode/src/vs/base/common/resources.ts
View File

@@ -42,8 +42,8 @@ export interface IExtUri {
/**
* Tests whether a `candidate` URI is a parent or equal of a given `base` URI.
*
* @param base A uri which is "longer"
* @param parentCandidate A uri which is "shorter" then `base`
* @param base A uri which is "longer" or at least same length as `parentCandidate`
* @param parentCandidate A uri which is "shorter" or up to same length as `base`
* @param ignoreFragment Ignore the fragment (defaults to `false`)
*/
isEqualOrParent(base: URI, parentCandidate: URI, ignoreFragment?: boolean): boolean;

142
lib/vscode/src/vs/base/common/stream.ts
View File

@@ -16,6 +16,13 @@ export interface ReadableStreamEvents<T> {
/**
* The 'data' event is emitted whenever the stream is
* relinquishing ownership of a chunk of data to a consumer.
*
* NOTE: PLEASE UNDERSTAND THAT ADDING A DATA LISTENER CAN
* TURN THE STREAM INTO FLOWING MODE. IT IS THEREFOR THE
* LAST LISTENER THAT SHOULD BE ADDED AND NOT THE FIRST
*
* Use `listenStream` as a helper method to listen to
* stream events in the right order.
*/
on(event: 'data', callback: (data: T) => void): void;
@@ -268,7 +275,7 @@ class WriteableStreamImpl<T> implements WriteableStream<T> {
// end with data or error if provided
if (result instanceof Error) {
this.error(result);
} else if (result) {
} else if (typeof result !== 'undefined') {
this.write(result);
}
@@ -489,22 +496,74 @@ export function peekReadable<T>(readable: Readable<T>, reducer: IReducer<T>, max
}
/**
* Helper to fully read a T stream into a T.
* Helper to fully read a T stream into a T or consuming
* a stream fully, awaiting all the events without caring
* about the data.
*/
export function consumeStream<T>(stream: ReadableStreamEvents<T>, reducer: IReducer<T>): Promise<T> {
export function consumeStream<T>(stream: ReadableStreamEvents<T>, reducer: IReducer<T>): Promise<T>;
export function consumeStream(stream: ReadableStreamEvents<unknown>): Promise<undefined>;
export function consumeStream<T>(stream: ReadableStreamEvents<T>, reducer?: IReducer<T>): Promise<T | undefined> {
return new Promise((resolve, reject) => {
const chunks: T[] = [];
stream.on('error', error => reject(error));
stream.on('end', () => resolve(reducer(chunks)));
// Adding the `data` listener will turn the stream
// into flowing mode. As such it is important to
// add this listener last (DO NOT CHANGE!)
stream.on('data', data => chunks.push(data));
listenStream(stream, {
onData: chunk => {
if (reducer) {
chunks.push(chunk);
}
},
onError: error => {
if (reducer) {
reject(error);
} else {
resolve(undefined);
}
},
onEnd: () => {
if (reducer) {
resolve(reducer(chunks));
} else {
resolve(undefined);
}
}
});
});
}
export interface IStreamListener<T> {
/**
* The 'data' event is emitted whenever the stream is
* relinquishing ownership of a chunk of data to a consumer.
*/
onData(data: T): void;
/**
* Emitted when any error occurs.
*/
onError(err: Error): void;
/**
* The 'end' event is emitted when there is no more data
* to be consumed from the stream. The 'end' event will
* not be emitted unless the data is completely consumed.
*/
onEnd(): void;
}
/**
* Helper to listen to all events of a T stream in proper order.
*/
export function listenStream<T>(stream: ReadableStreamEvents<T>, listener: IStreamListener<T>): void {
stream.on('error', error => listener.onError(error));
stream.on('end', () => listener.onEnd());
// Adding the `data` listener will turn the stream
// into flowing mode. As such it is important to
// add this listener last (DO NOT CHANGE!)
stream.on('data', data => listener.onData(data));
}
/**
* Helper to peek up to `maxChunks` into a stream. The return type signals if
* the stream has ended or not. If not, caller needs to add a `data` listener
@@ -513,9 +572,9 @@ export function consumeStream<T>(stream: ReadableStreamEvents<T>, reducer: IRedu
export function peekStream<T>(stream: ReadableStream<T>, maxChunks: number): Promise<ReadableBufferedStream<T>> {
return new Promise((resolve, reject) => {
const streamListeners = new DisposableStore();
const buffer: T[] = [];
// Data Listener
const buffer: T[] = [];
const dataListener = (chunk: T) => {
// Add to buffer
@@ -533,23 +592,27 @@ export function peekStream<T>(stream: ReadableStream<T>, maxChunks: number): Pro
}
};
streamListeners.add(toDisposable(() => stream.removeListener('data', dataListener)));
stream.on('data', dataListener);
// Error Listener
const errorListener = (error: Error) => {
return reject(error);
};
streamListeners.add(toDisposable(() => stream.removeListener('error', errorListener)));
stream.on('error', errorListener);
// End Listener
const endListener = () => {
return resolve({ stream, buffer, ended: true });
};
streamListeners.add(toDisposable(() => stream.removeListener('error', errorListener)));
stream.on('error', errorListener);
streamListeners.add(toDisposable(() => stream.removeListener('end', endListener)));
stream.on('end', endListener);
// Important: leave the `data` listener last because
// this can turn the stream into flowing mode and we
// want `error` events to be received as well.
streamListeners.add(toDisposable(() => stream.removeListener('data', dataListener)));
stream.on('data', dataListener);
});
}
@@ -589,46 +652,11 @@ export function toReadable<T>(t: T): Readable<T> {
export function transform<Original, Transformed>(stream: ReadableStreamEvents<Original>, transformer: ITransformer<Original, Transformed>, reducer: IReducer<Transformed>): ReadableStream<Transformed> {
const target = newWriteableStream<Transformed>(reducer);
stream.on('data', data => target.write(transformer.data(data)));
stream.on('end', () => target.end());
stream.on('error', error => target.error(transformer.error ? transformer.error(error) : error));
listenStream(stream, {
onData: data => target.write(transformer.data(data)),
onError: error => target.error(transformer.error ? transformer.error(error) : error),
onEnd: () => target.end()
});
return target;
}
export interface IReadableStreamObservable {
/**
* A promise to await the `end` or `error` event
* of a stream.
*/
errorOrEnd: () => Promise<void>;
}
/**
* Helper to observe a stream for certain events through
* a promise based API.
*/
export function observe(stream: ReadableStream<unknown>): IReadableStreamObservable {
// A stream is closed when it ended or errord
// We install this listener right from the
// beginning to catch the events early.
const errorOrEnd = Promise.race([
new Promise<void>(resolve => stream.on('end', () => resolve())),
new Promise<void>(resolve => stream.on('error', () => resolve()))
]);
return {
errorOrEnd(): Promise<void> {
// We need to ensure the stream is flowing so that our
// listeners are getting triggered. It is possible that
// the stream is not flowing because no `data` listener
// was attached yet.
stream.resume();
return errorOrEnd;
}
};
}

18
lib/vscode/src/vs/base/common/strings.ts
View File

File diff suppressed because one or more lines are too long

38
lib/vscode/src/vs/base/common/types.ts
View File

@@ -8,22 +8,22 @@ import { URI, UriComponents } from 'vs/base/common/uri';
/**
* @returns whether the provided parameter is a JavaScript Array or not.
*/
export function isArray<T>(array: T | {}): array is T extends readonly any[] ? (unknown extends T ? never : readonly any[]) : any[] {
export function isArray(array: any): array is any[] {
return Array.isArray(array);
}
/**
* @returns whether the provided parameter is a JavaScript String or not.
*/
export function isString(str: any): str is string {
export function isString(str: unknown): str is string {
return (typeof str === 'string');
}
/**
* @returns whether the provided parameter is a JavaScript Array and each element in the array is a string.
*/
export function isStringArray(value: any): value is string[] {
return Array.isArray(value) && (<any[]>value).every(elem => isString(elem));
export function isStringArray(value: unknown): value is string[] {
return Array.isArray(value) && (<unknown[]>value).every(elem => isString(elem));
}
/**
@@ -31,7 +31,7 @@ export function isStringArray(value: any): value is string[] {
* @returns whether the provided parameter is of type `object` but **not**
* `null`, an `array`, a `regexp`, nor a `date`.
*/
export function isObject(obj: any): obj is Object {
export function isObject(obj: unknown): obj is Object {
// The method can't do a type cast since there are type (like strings) which
// are subclasses of any put not positvely matched by the function. Hence type
// narrowing results in wrong results.
@@ -46,21 +46,21 @@ export function isObject(obj: any): obj is Object {
* In **contrast** to just checking `typeof` this will return `false` for `NaN`.
* @returns whether the provided parameter is a JavaScript Number or not.
*/
export function isNumber(obj: any): obj is number {
export function isNumber(obj: unknown): obj is number {
return (typeof obj === 'number' && !isNaN(obj));
}
/**
* @returns whether the provided parameter is a JavaScript Boolean or not.
*/
export function isBoolean(obj: any): obj is boolean {
export function isBoolean(obj: unknown): obj is boolean {
return (obj === true || obj === false);
}
/**
* @returns whether the provided parameter is undefined.
*/
export function isUndefined(obj: any): obj is undefined {
export function isUndefined(obj: unknown): obj is undefined {
return (typeof obj === 'undefined');
}
@@ -74,12 +74,12 @@ export function isDefined<T>(arg: T | null | undefined): arg is T {
/**
* @returns whether the provided parameter is undefined or null.
*/
export function isUndefinedOrNull(obj: any): obj is undefined | null {
export function isUndefinedOrNull(obj: unknown): obj is undefined | null {
return (isUndefined(obj) || obj === null);
}
export function assertType(condition: any, type?: string): asserts condition {
export function assertType(condition: unknown, type?: string): asserts condition {
if (!condition) {
throw new Error(type ? `Unexpected type, expected '${type}'` : 'Unexpected type');
}
@@ -123,7 +123,7 @@ const hasOwnProperty = Object.prototype.hasOwnProperty;
/**
* @returns whether the provided parameter is an empty JavaScript Object or not.
*/
export function isEmptyObject(obj: any): obj is any {
export function isEmptyObject(obj: unknown): obj is object {
if (!isObject(obj)) {
return false;
}
@@ -140,27 +140,27 @@ export function isEmptyObject(obj: any): obj is any {
/**
* @returns whether the provided parameter is a JavaScript Function or not.
*/
export function isFunction(obj: any): obj is Function {
export function isFunction(obj: unknown): obj is Function {
return (typeof obj === 'function');
}
/**
* @returns whether the provided parameters is are JavaScript Function or not.
*/
export function areFunctions(...objects: any[]): boolean {
export function areFunctions(...objects: unknown[]): boolean {
return objects.length > 0 && objects.every(isFunction);
}
export type TypeConstraint = string | Function;
export function validateConstraints(args: any[], constraints: Array<TypeConstraint | undefined>): void {
export function validateConstraints(args: unknown[], constraints: Array<TypeConstraint | undefined>): void {
const len = Math.min(args.length, constraints.length);
for (let i = 0; i < len; i++) {
validateConstraint(args[i], constraints[i]);
}
}
export function validateConstraint(arg: any, constraint: TypeConstraint | undefined): void {
export function validateConstraint(arg: unknown, constraint: TypeConstraint | undefined): void {
if (isString(constraint)) {
if (typeof arg !== constraint) {
@@ -174,7 +174,7 @@ export function validateConstraint(arg: any, constraint: TypeConstraint | undefi
} catch {
// ignore
}
if (!isUndefinedOrNull(arg) && arg.constructor === constraint) {
if (!isUndefinedOrNull(arg) && (arg as any).constructor === constraint) {
return;
}
if (constraint.length === 1 && constraint.call(undefined, arg) === true) {
@@ -204,8 +204,8 @@ export function getAllMethodNames(obj: object): string[] {
return methods;
}
export function createProxyObject<T extends object>(methodNames: string[], invoke: (method: string, args: any[]) => any): T {
const createProxyMethod = (method: string): () => any => {
export function createProxyObject<T extends object>(methodNames: string[], invoke: (method: string, args: unknown[]) => unknown): T {
const createProxyMethod = (method: string): () => unknown => {
return function () {
const args = Array.prototype.slice.call(arguments, 0);
return invoke(method, args);
@@ -242,7 +242,7 @@ export type AddFirstParameterToFunctions<Target, TargetFunctionsReturnType, Firs
[K in keyof Target]:
// Function: add param to function
Target[K] extends (...args: any) => TargetFunctionsReturnType ? (firstArg: FirstParameter, ...args: Parameters<Target[K]>) => ReturnType<Target[K]> :
Target[K] extends (...args: any[]) => TargetFunctionsReturnType ? (firstArg: FirstParameter, ...args: Parameters<Target[K]>) => ReturnType<Target[K]> :
// Else: just leave as is
Target[K]

23
lib/vscode/src/vs/base/common/uuid.ts
View File

@@ -19,13 +19,22 @@ for (let i = 0; i < 256; i++) {
// todo@jrieken
// 1. node nodejs use`crypto#randomBytes`, see: https://nodejs.org/docs/latest/api/crypto.html#crypto_crypto_randombytes_size_callback
// 2. use browser-crypto
const _fillRandomValues = function (bucket: Uint8Array): Uint8Array {
for (let i = 0; i < bucket.length; i++) {
bucket[i] = Math.floor(Math.random() * 256);
}
return bucket;
};
let _fillRandomValues: (bucket: Uint8Array) => Uint8Array;
declare const crypto: undefined | { getRandomValues(data: Uint8Array): Uint8Array };
if (typeof crypto === 'object' && typeof crypto.getRandomValues === 'function') {
// browser
_fillRandomValues = crypto.getRandomValues.bind(crypto);
} else {
_fillRandomValues = function (bucket: Uint8Array): Uint8Array {
for (let i = 0; i < bucket.length; i++) {
bucket[i] = Math.floor(Math.random() * 256);
}
return bucket;
};
}
export function generateUuid(): string {
// get data