@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/platform/instantiation/common/instantiation.ts

@@ -0,0 +1,127 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DisposableStore } from '../../../base/common/lifecycle';
+import * as descriptors from './descriptors';
+import { ServiceCollection } from './serviceCollection';
+
+// ------ internal util
+
+export namespace _util {
+
+	export const serviceIds = new Map<string, ServiceIdentifier<any>>();
+
+	export const DI_TARGET = '$di$target';
+	export const DI_DEPENDENCIES = '$di$dependencies';
+
+	export function getServiceDependencies(ctor: any): { id: ServiceIdentifier<any>; index: number }[] {
+		return ctor[DI_DEPENDENCIES] || [];
+	}
+}
+
+// --- interfaces ------
+
+export type BrandedService = { _serviceBrand: undefined };
+
+export interface IConstructorSignature<T, Args extends any[] = []> {
+	new <Services extends BrandedService[]>(...args: [...Args, ...Services]): T;
+}
+
+export interface ServicesAccessor {
+	get<T>(id: ServiceIdentifier<T>): T;
+	getIfExists<T>(id: ServiceIdentifier<T>): T | undefined;
+}
+
+export const IInstantiationService = createDecorator<IInstantiationService>('instantiationService');
+
+/**
+ * Given a list of arguments as a tuple, attempt to extract the leading, non-service arguments
+ * to their own tuple.
+ */
+export type GetLeadingNonServiceArgs<TArgs extends any[]> =
+	TArgs extends [] ? []
+	: TArgs extends [...infer TFirst, BrandedService] ? GetLeadingNonServiceArgs<TFirst>
+	: TArgs;
+
+export interface IInstantiationService {
+
+	readonly _serviceBrand: undefined;
+
+	/**
+	 * Synchronously creates an instance that is denoted by the descriptor
+	 */
+	createInstance<T>(descriptor: descriptors.SyncDescriptor0<T>): T;
+	createInstance<Ctor extends new (...args: any[]) => unknown, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+
+	/**
+	 * Calls a function with a service accessor.
+	 */
+	invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R;
+
+	/**
+	 * Creates a child of this service which inherits all current services
+	 * and adds/overwrites the given services.
+	 *
+	 * NOTE that the returned child is `disposable` and should be disposed when not used
+	 * anymore. This will also dispose all the services that this service has created.
+	 */
+	createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService;
+
+	/**
+	 * Disposes this instantiation service.
+	 *
+	 * - Will dispose all services that this instantiation service has created.
+	 * - Will dispose all its children but not its parent.
+	 * - Will NOT dispose services-instances that this service has been created with
+	 * - Will NOT dispose consumer-instances this service has created
+	 */
+	dispose(): void;
+}
+
+
+/**
+ * Identifies a service of type `T`.
+ */
+export interface ServiceIdentifier<T> {
+	(...args: any[]): void;
+	type: T;
+}
+
+function storeServiceDependency(id: Function, target: Function, index: number): void {
+	if ((target as any)[_util.DI_TARGET] === target) {
+		(target as any)[_util.DI_DEPENDENCIES].push({ id, index });
+	} else {
+		(target as any)[_util.DI_DEPENDENCIES] = [{ id, index }];
+		(target as any)[_util.DI_TARGET] = target;
+	}
+}
+
+/**
+ * The *only* valid way to create a {{ServiceIdentifier}}.
+ */
+export function createDecorator<T>(serviceId: string): ServiceIdentifier<T> {
+
+	if (_util.serviceIds.has(serviceId)) {
+		return _util.serviceIds.get(serviceId)!;
+	}
+
+	const id = <any>function (target: Function, key: string, index: number) {
+		if (arguments.length !== 3) {
+			throw new Error('@IServiceName-decorator can only be used to decorate a parameter');
+		}
+		storeServiceDependency(id, target, index);
+	};
+
+	id.toString = () => serviceId;
+
+	_util.serviceIds.set(serviceId, id);
+	return id;
+}
+
+export function refineServiceDecorator<T1, T extends T1>(serviceIdentifier: ServiceIdentifier<T1>): ServiceIdentifier<T> {
+	return <ServiceIdentifier<T>>serviceIdentifier;
+}

package/src/_internal/util/vs/platform/instantiation/common/instantiationService.ts

@@ -0,0 +1,483 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { GlobalIdleValue } from '../../../base/common/async';
+import { Event } from '../../../base/common/event';
+import { illegalState } from '../../../base/common/errors';
+import { DisposableStore, dispose, IDisposable, isDisposable, toDisposable } from '../../../base/common/lifecycle';
+import { SyncDescriptor, SyncDescriptor0 } from './descriptors';
+import { Graph } from './graph';
+import { GetLeadingNonServiceArgs, IInstantiationService, ServiceIdentifier, ServicesAccessor, _util } from './instantiation';
+import { ServiceCollection } from './serviceCollection';
+import { LinkedList } from '../../../base/common/linkedList';
+
+// TRACING
+const _enableAllTracing = false
+	// || "TRUE" // DO NOT CHECK IN!
+	;
+
+class CyclicDependencyError extends Error {
+	constructor(graph: Graph<any>) {
+		super('cyclic dependency between services');
+		this.message = graph.findCycleSlow() ?? `UNABLE to detect cycle, dumping graph: \n${graph.toString()}`;
+	}
+}
+
+export class InstantiationService implements IInstantiationService {
+
+	declare readonly _serviceBrand: undefined;
+
+	readonly _globalGraph?: Graph<string>;
+	private _globalGraphImplicitDependency?: string;
+
+	private _isDisposed = false;
+	private readonly _servicesToMaybeDispose = new Set<any>();
+	private readonly _children = new Set<InstantiationService>();
+
+	constructor(
+		private readonly _services: ServiceCollection = new ServiceCollection(),
+		private readonly _strict: boolean = false,
+		private readonly _parent?: InstantiationService,
+		private readonly _enableTracing: boolean = _enableAllTracing
+	) {
+
+		this._services.set(IInstantiationService, this);
+		this._globalGraph = _enableTracing ? _parent?._globalGraph ?? new Graph(e => e) : undefined;
+	}
+
+	dispose(): void {
+		if (!this._isDisposed) {
+			this._isDisposed = true;
+			// dispose all child services
+			dispose(this._children);
+			this._children.clear();
+
+			// dispose all services created by this service
+			for (const candidate of this._servicesToMaybeDispose) {
+				if (isDisposable(candidate)) {
+					candidate.dispose();
+				}
+			}
+			this._servicesToMaybeDispose.clear();
+		}
+	}
+
+	private _throwIfDisposed(): void {
+		if (this._isDisposed) {
+			throw new Error('InstantiationService has been disposed');
+		}
+	}
+
+	createChild(services: ServiceCollection, store?: DisposableStore): IInstantiationService {
+		this._throwIfDisposed();
+
+		const that = this;
+		const result = new class extends InstantiationService {
+			override dispose(): void {
+				that._children.delete(result);
+				super.dispose();
+			}
+		}(services, this._strict, this, this._enableTracing);
+		this._children.add(result);
+
+		store?.add(result);
+		return result;
+	}
+
+	invokeFunction<R, TS extends any[] = []>(fn: (accessor: ServicesAccessor, ...args: TS) => R, ...args: TS): R {
+		this._throwIfDisposed();
+
+		const _trace = Trace.traceInvocation(this._enableTracing, fn);
+		let _done = false;
+		try {
+			const accessor: ServicesAccessor = {
+				get: <T>(id: ServiceIdentifier<T>) => {
+
+					if (_done) {
+						throw illegalState('service accessor is only valid during the invocation of its target method');
+					}
+
+					const result = this._getOrCreateServiceInstance(id, _trace);
+					if (!result) {
+						throw new Error(`[invokeFunction] unknown service '${id}'`);
+					}
+					return result;
+				},
+				getIfExists: <T>(id: ServiceIdentifier<T>) => {
+					if (_done) {
+						throw illegalState('service accessor is only valid during the invocation of its target method');
+					}
+					const result = this._getOrCreateServiceInstance(id, _trace);
+					return result;
+				}
+			};
+			return fn(accessor, ...args);
+		} finally {
+			_done = true;
+			_trace.stop();
+		}
+	}
+
+	createInstance<T>(descriptor: SyncDescriptor0<T>): T;
+	createInstance<Ctor extends new (...args: any[]) => unknown, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
+	createInstance(ctorOrDescriptor: any | SyncDescriptor<any>, ...rest: any[]): unknown {
+		this._throwIfDisposed();
+
+		let _trace: Trace;
+		let result: unknown;
+		if (ctorOrDescriptor instanceof SyncDescriptor) {
+			_trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor.ctor);
+			result = this._createInstance(ctorOrDescriptor.ctor, ctorOrDescriptor.staticArguments.concat(rest), _trace);
+		} else {
+			_trace = Trace.traceCreation(this._enableTracing, ctorOrDescriptor);
+			result = this._createInstance(ctorOrDescriptor, rest, _trace);
+		}
+		_trace.stop();
+		return result;
+	}
+
+	private _createInstance<T>(ctor: any, args: any[] = [], _trace: Trace): T {
+
+		// arguments defined by service decorators
+		const serviceDependencies = _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
+		const serviceArgs: any[] = [];
+		for (const dependency of serviceDependencies) {
+			const service = this._getOrCreateServiceInstance(dependency.id, _trace);
+			if (!service) {
+				this._throwIfStrict(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`, false);
+			}
+			serviceArgs.push(service);
+		}
+
+		const firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length;
+
+		// check for argument mismatches, adjust static args if needed
+		if (args.length !== firstServiceArgPos) {
+			console.trace(`[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);
+
+			const delta = firstServiceArgPos - args.length;
+			if (delta > 0) {
+				args = args.concat(new Array(delta));
+			} else {
+				args = args.slice(0, firstServiceArgPos);
+			}
+		}
+
+		// now create the instance
+		return Reflect.construct<any, T>(ctor, args.concat(serviceArgs));
+	}
+
+	private _setCreatedServiceInstance<T>(id: ServiceIdentifier<T>, instance: T): void {
+		if (this._services.get(id) instanceof SyncDescriptor) {
+			this._services.set(id, instance);
+		} else if (this._parent) {
+			this._parent._setCreatedServiceInstance(id, instance);
+		} else {
+			throw new Error('illegalState - setting UNKNOWN service instance');
+		}
+	}
+
+	private _getServiceInstanceOrDescriptor<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
+		const instanceOrDesc = this._services.get(id);
+		if (!instanceOrDesc && this._parent) {
+			return this._parent._getServiceInstanceOrDescriptor(id);
+		} else {
+			return instanceOrDesc;
+		}
+	}
+
+	protected _getOrCreateServiceInstance<T>(id: ServiceIdentifier<T>, _trace: Trace): T {
+		if (this._globalGraph && this._globalGraphImplicitDependency) {
+			this._globalGraph.insertEdge(this._globalGraphImplicitDependency, String(id));
+		}
+		const thing = this._getServiceInstanceOrDescriptor(id);
+		if (thing instanceof SyncDescriptor) {
+			return this._safeCreateAndCacheServiceInstance(id, thing, _trace.branch(id, true));
+		} else {
+			_trace.branch(id, false);
+			return thing;
+		}
+	}
+
+	private readonly _activeInstantiations = new Set<ServiceIdentifier<any>>();
+
+
+	private _safeCreateAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {
+		if (this._activeInstantiations.has(id)) {
+			throw new Error(`illegal state - RECURSIVELY instantiating service '${id}'`);
+		}
+		this._activeInstantiations.add(id);
+		try {
+			return this._createAndCacheServiceInstance(id, desc, _trace);
+		} finally {
+			this._activeInstantiations.delete(id);
+		}
+	}
+
+	private _createAndCacheServiceInstance<T>(id: ServiceIdentifier<T>, desc: SyncDescriptor<T>, _trace: Trace): T {
+
+		type Triple = { id: ServiceIdentifier<any>; desc: SyncDescriptor<any>; _trace: Trace };
+		const graph = new Graph<Triple>(data => data.id.toString());
+
+		let cycleCount = 0;
+		const stack = [{ id, desc, _trace }];
+		const seen = new Set<string>();
+		while (stack.length) {
+			const item = stack.pop()!;
+
+			if (seen.has(String(item.id))) {
+				continue;
+			}
+			seen.add(String(item.id));
+
+			graph.lookupOrInsertNode(item);
+
+			// a weak but working heuristic for cycle checks
+			if (cycleCount++ > 1000) {
+				throw new CyclicDependencyError(graph);
+			}
+
+			// check all dependencies for existence and if they need to be created first
+			for (const dependency of _util.getServiceDependencies(item.desc.ctor)) {
+
+				const instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
+				if (!instanceOrDesc) {
+					this._throwIfStrict(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`, true);
+				}
+
+				// take note of all service dependencies
+				this._globalGraph?.insertEdge(String(item.id), String(dependency.id));
+
+				if (instanceOrDesc instanceof SyncDescriptor) {
+					const d = { id: dependency.id, desc: instanceOrDesc, _trace: item._trace.branch(dependency.id, true) };
+					graph.insertEdge(item, d);
+					stack.push(d);
+				}
+			}
+		}
+
+		while (true) {
+			const roots = graph.roots();
+
+			// if there is no more roots but still
+			// nodes in the graph we have a cycle
+			if (roots.length === 0) {
+				if (!graph.isEmpty()) {
+					throw new CyclicDependencyError(graph);
+				}
+				break;
+			}
+
+			for (const { data } of roots) {
+				// Repeat the check for this still being a service sync descriptor. That's because
+				// instantiating a dependency might have side-effect and recursively trigger instantiation
+				// so that some dependencies are now fullfilled already.
+				const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
+				if (instanceOrDesc instanceof SyncDescriptor) {
+					// create instance and overwrite the service collections
+					const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
+					this._setCreatedServiceInstance(data.id, instance);
+				}
+				graph.removeNode(data);
+			}
+		}
+		return <T>this._getServiceInstanceOrDescriptor(id);
+	}
+
+	private _createServiceInstanceWithOwner<T>(id: ServiceIdentifier<T>, ctor: any, args: any[] = [], supportsDelayedInstantiation: boolean, _trace: Trace): T {
+		if (this._services.get(id) instanceof SyncDescriptor) {
+			return this._createServiceInstance(id, ctor, args, supportsDelayedInstantiation, _trace, this._servicesToMaybeDispose);
+		} else if (this._parent) {
+			return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);
+		} else {
+			throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
+		}
+	}
+
+	private _createServiceInstance<T>(id: ServiceIdentifier<T>, ctor: any, args: any[] = [], supportsDelayedInstantiation: boolean, _trace: Trace, disposeBucket: Set<any>): T {
+		if (!supportsDelayedInstantiation) {
+			// eager instantiation
+			const result = this._createInstance<T>(ctor, args, _trace);
+			disposeBucket.add(result);
+			return result;
+
+		} else {
+			const child = new InstantiationService(undefined, this._strict, this, this._enableTracing);
+			child._globalGraphImplicitDependency = String(id);
+
+			type EaryListenerData = {
+				listener: Parameters<Event<any>>;
+				disposable?: IDisposable;
+			};
+
+			// Return a proxy object that's backed by an idle value. That
+			// strategy is to instantiate services in our idle time or when actually
+			// needed but not when injected into a consumer
+
+			// return "empty events" when the service isn't instantiated yet
+			const earlyListeners = new Map<string, LinkedList<EaryListenerData>>();
+
+			const idle = new GlobalIdleValue<any>(() => {
+				const result = child._createInstance<T>(ctor, args, _trace);
+
+				// early listeners that we kept are now being subscribed to
+				// the real service
+				for (const [key, values] of earlyListeners) {
+					const candidate = <Event<any>>(<any>result)[key];
+					if (typeof candidate === 'function') {
+						for (const value of values) {
+							value.disposable = candidate.apply(result, value.listener);
+						}
+					}
+				}
+				earlyListeners.clear();
+				disposeBucket.add(result);
+				return result;
+			});
+			return <T>new Proxy(Object.create(null), {
+				get(target: any, key: PropertyKey): unknown {
+
+					if (!idle.isInitialized) {
+						// looks like an event
+						if (typeof key === 'string' && (key.startsWith('onDid') || key.startsWith('onWill'))) {
+							let list = earlyListeners.get(key);
+							if (!list) {
+								list = new LinkedList();
+								earlyListeners.set(key, list);
+							}
+							const event: Event<any> = (callback, thisArg, disposables) => {
+								if (idle.isInitialized) {
+									return idle.value[key](callback, thisArg, disposables);
+								} else {
+									const entry: EaryListenerData = { listener: [callback, thisArg, disposables], disposable: undefined };
+									const rm = list.push(entry);
+									const result = toDisposable(() => {
+										rm();
+										entry.disposable?.dispose();
+									});
+									return result;
+								}
+							};
+							return event;
+						}
+					}
+
+					// value already exists
+					if (key in target) {
+						return target[key];
+					}
+
+					// create value
+					const obj = idle.value;
+					let prop = obj[key];
+					if (typeof prop !== 'function') {
+						return prop;
+					}
+					prop = prop.bind(obj);
+					target[key] = prop;
+					return prop;
+				},
+				set(_target: T, p: PropertyKey, value: any): boolean {
+					idle.value[p] = value;
+					return true;
+				},
+				getPrototypeOf(_target: T) {
+					return ctor.prototype;
+				}
+			});
+		}
+	}
+
+	private _throwIfStrict(msg: string, printWarning: boolean): void {
+		if (printWarning) {
+			console.warn(msg);
+		}
+		if (this._strict) {
+			throw new Error(msg);
+		}
+	}
+}
+
+//#region -- tracing ---
+
+const enum TraceType {
+	None = 0,
+	Creation = 1,
+	Invocation = 2,
+	Branch = 3,
+}
+
+export class Trace {
+
+	static all = new Set<string>();
+
+	private static readonly _None = new class extends Trace {
+		constructor() { super(TraceType.None, null); }
+		override stop() { }
+		override branch() { return this; }
+	};
+
+	static traceInvocation(_enableTracing: boolean, ctor: any): Trace {
+		return !_enableTracing ? Trace._None : new Trace(TraceType.Invocation, ctor.name || new Error().stack!.split('\n').slice(3, 4).join('\n'));
+	}
+
+	static traceCreation(_enableTracing: boolean, ctor: any): Trace {
+		return !_enableTracing ? Trace._None : new Trace(TraceType.Creation, ctor.name);
+	}
+
+	private static _totals: number = 0;
+	private readonly _start: number = Date.now();
+	private readonly _dep: [ServiceIdentifier<any>, boolean, Trace?][] = [];
+
+	private constructor(
+		readonly type: TraceType,
+		readonly name: string | null
+	) { }
+
+	branch(id: ServiceIdentifier<any>, first: boolean): Trace {
+		const child = new Trace(TraceType.Branch, id.toString());
+		this._dep.push([id, first, child]);
+		return child;
+	}
+
+	stop() {
+		const dur = Date.now() - this._start;
+		Trace._totals += dur;
+
+		let causedCreation = false;
+
+		function printChild(n: number, trace: Trace) {
+			const res: string[] = [];
+			const prefix = new Array(n + 1).join('\t');
+			for (const [id, first, child] of trace._dep) {
+				if (first && child) {
+					causedCreation = true;
+					res.push(`${prefix}CREATES -> ${id}`);
+					const nested = printChild(n + 1, child);
+					if (nested) {
+						res.push(nested);
+					}
+				} else {
+					res.push(`${prefix}uses -> ${id}`);
+				}
+			}
+			return res.join('\n');
+		}
+
+		const lines = [
+			`${this.type === TraceType.Creation ? 'CREATE' : 'CALL'} ${this.name}`,
+			`${printChild(1, this)}`,
+			`DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`
+		];
+
+		if (dur > 2 || causedCreation) {
+			Trace.all.add(lines.join('\n'));
+		}
+	}
+}
+
+//#endregion

package/src/_internal/util/vs/platform/instantiation/common/serviceCollection.ts

@@ -0,0 +1,34 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ServiceIdentifier } from './instantiation';
+import { SyncDescriptor } from './descriptors';
+
+export class ServiceCollection {
+
+	private _entries = new Map<ServiceIdentifier<any>, any>();
+
+	constructor(...entries: [ServiceIdentifier<any>, any][]) {
+		for (const [id, service] of entries) {
+			this.set(id, service);
+		}
+	}
+
+	set<T>(id: ServiceIdentifier<T>, instanceOrDescriptor: T | SyncDescriptor<T>): T | SyncDescriptor<T> {
+		const result = this._entries.get(id);
+		this._entries.set(id, instanceOrDescriptor);
+		return result;
+	}
+
+	has(id: ServiceIdentifier<any>): boolean {
+		return this._entries.has(id);
+	}
+
+	get<T>(id: ServiceIdentifier<T>): T | SyncDescriptor<T> {
+		return this._entries.get(id);
+	}
+}

package/src/_internal/util/vs/vscode-globals-nls.d.ts

@@ -0,0 +1,42 @@
+//!!! DO NOT modify, this file was COPIED from 'microsoft/vscode'
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+// AMD2ESM migration relevant
+
+/**
+ * NLS Globals: these need to be defined in all contexts that make
+ * use of our `nls.localize` and `nls.localize2` functions. This includes:
+ * - Electron main process
+ * - Electron window (renderer) process
+ * - Utility Process
+ * - Node.js
+ * - Browser
+ * - Web worker
+ *
+ * That is because during build time we strip out all english strings from
+ * the resulting JS code and replace it with a <number> that is then looked
+ * up from the `_VSCODE_NLS_MESSAGES` array.
+ */
+declare global {
+	/**
+	 * All NLS messages produced by `localize` and `localize2` calls
+	 * under `src/vs` translated to the language as indicated by
+	 * `_VSCODE_NLS_LANGUAGE`.
+	 *
+	 * Instead of accessing this global variable directly, use function getNLSMessages.
+	 */
+	var _VSCODE_NLS_MESSAGES: string[];
+	/**
+	 * The actual language of the NLS messages (e.g. 'en', de' or 'pt-br').
+	 *
+	 * Instead of accessing this global variable directly, use function getNLSLanguage.
+	 */
+	var _VSCODE_NLS_LANGUAGE: string | undefined;
+}
+
+// fake export to make global work
+export { }