@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/editor/common/model/prefixSumComputer.ts

@@ -0,0 +1,304 @@
+//!!! 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 { arrayInsert } from '../../../base/common/arrays';
+import { toUint32 } from '../../../base/common/uint';
+
+export class PrefixSumComputer {
+
+	/**
+	 * values[i] is the value at index i
+	 */
+	private values: Uint32Array;
+
+	/**
+	 * prefixSum[i] = SUM(heights[j]), 0 <= j <= i
+	 */
+	private prefixSum: Uint32Array;
+
+	/**
+	 * prefixSum[i], 0 <= i <= prefixSumValidIndex can be trusted
+	 */
+	private readonly prefixSumValidIndex: Int32Array;
+
+	constructor(values: Uint32Array) {
+		this.values = values;
+		this.prefixSum = new Uint32Array(values.length);
+		this.prefixSumValidIndex = new Int32Array(1);
+		this.prefixSumValidIndex[0] = -1;
+	}
+
+	public getCount(): number {
+		return this.values.length;
+	}
+
+	public insertValues(insertIndex: number, insertValues: Uint32Array): boolean {
+		insertIndex = toUint32(insertIndex);
+		const oldValues = this.values;
+		const oldPrefixSum = this.prefixSum;
+		const insertValuesLen = insertValues.length;
+
+		if (insertValuesLen === 0) {
+			return false;
+		}
+
+		this.values = new Uint32Array(oldValues.length + insertValuesLen);
+		this.values.set(oldValues.subarray(0, insertIndex), 0);
+		this.values.set(oldValues.subarray(insertIndex), insertIndex + insertValuesLen);
+		this.values.set(insertValues, insertIndex);
+
+		if (insertIndex - 1 < this.prefixSumValidIndex[0]) {
+			this.prefixSumValidIndex[0] = insertIndex - 1;
+		}
+
+		this.prefixSum = new Uint32Array(this.values.length);
+		if (this.prefixSumValidIndex[0] >= 0) {
+			this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+		}
+		return true;
+	}
+
+	public setValue(index: number, value: number): boolean {
+		index = toUint32(index);
+		value = toUint32(value);
+
+		if (this.values[index] === value) {
+			return false;
+		}
+		this.values[index] = value;
+		if (index - 1 < this.prefixSumValidIndex[0]) {
+			this.prefixSumValidIndex[0] = index - 1;
+		}
+		return true;
+	}
+
+	public removeValues(startIndex: number, count: number): boolean {
+		startIndex = toUint32(startIndex);
+		count = toUint32(count);
+
+		const oldValues = this.values;
+		const oldPrefixSum = this.prefixSum;
+
+		if (startIndex >= oldValues.length) {
+			return false;
+		}
+
+		const maxCount = oldValues.length - startIndex;
+		if (count >= maxCount) {
+			count = maxCount;
+		}
+
+		if (count === 0) {
+			return false;
+		}
+
+		this.values = new Uint32Array(oldValues.length - count);
+		this.values.set(oldValues.subarray(0, startIndex), 0);
+		this.values.set(oldValues.subarray(startIndex + count), startIndex);
+
+		this.prefixSum = new Uint32Array(this.values.length);
+		if (startIndex - 1 < this.prefixSumValidIndex[0]) {
+			this.prefixSumValidIndex[0] = startIndex - 1;
+		}
+		if (this.prefixSumValidIndex[0] >= 0) {
+			this.prefixSum.set(oldPrefixSum.subarray(0, this.prefixSumValidIndex[0] + 1));
+		}
+		return true;
+	}
+
+	public getTotalSum(): number {
+		if (this.values.length === 0) {
+			return 0;
+		}
+		return this._getPrefixSum(this.values.length - 1);
+	}
+
+	/**
+	 * Returns the sum of the first `index + 1` many items.
+	 * @returns `SUM(0 <= j <= index, values[j])`.
+	 */
+	public getPrefixSum(index: number): number {
+		if (index < 0) {
+			return 0;
+		}
+
+		index = toUint32(index);
+		return this._getPrefixSum(index);
+	}
+
+	private _getPrefixSum(index: number): number {
+		if (index <= this.prefixSumValidIndex[0]) {
+			return this.prefixSum[index];
+		}
+
+		let startIndex = this.prefixSumValidIndex[0] + 1;
+		if (startIndex === 0) {
+			this.prefixSum[0] = this.values[0];
+			startIndex++;
+		}
+
+		if (index >= this.values.length) {
+			index = this.values.length - 1;
+		}
+
+		for (let i = startIndex; i <= index; i++) {
+			this.prefixSum[i] = this.prefixSum[i - 1] + this.values[i];
+		}
+		this.prefixSumValidIndex[0] = Math.max(this.prefixSumValidIndex[0], index);
+		return this.prefixSum[index];
+	}
+
+	public getIndexOf(sum: number): PrefixSumIndexOfResult {
+		sum = Math.floor(sum);
+
+		// Compute all sums (to get a fully valid prefixSum)
+		this.getTotalSum();
+
+		let low = 0;
+		let high = this.values.length - 1;
+		let mid = 0;
+		let midStop = 0;
+		let midStart = 0;
+
+		while (low <= high) {
+			mid = low + ((high - low) / 2) | 0;
+
+			midStop = this.prefixSum[mid];
+			midStart = midStop - this.values[mid];
+
+			if (sum < midStart) {
+				high = mid - 1;
+			} else if (sum >= midStop) {
+				low = mid + 1;
+			} else {
+				break;
+			}
+		}
+
+		return new PrefixSumIndexOfResult(mid, sum - midStart);
+	}
+}
+
+/**
+ * {@link getIndexOf} has an amortized runtime complexity of O(1).
+ *
+ * ({@link PrefixSumComputer.getIndexOf} is just  O(log n))
+*/
+export class ConstantTimePrefixSumComputer {
+	private _values: number[];
+	private _isValid: boolean;
+	private _validEndIndex: number;
+
+	/**
+	 * _prefixSum[i] = SUM(values[j]), 0 <= j <= i
+	 */
+	private _prefixSum: number[];
+
+	/**
+	 * _indexBySum[sum] = idx => _prefixSum[idx - 1] <= sum < _prefixSum[idx]
+	*/
+	private _indexBySum: number[];
+
+	constructor(values: number[]) {
+		this._values = values;
+		this._isValid = false;
+		this._validEndIndex = -1;
+		this._prefixSum = [];
+		this._indexBySum = [];
+	}
+
+	/**
+	 * @returns SUM(0 <= j < values.length, values[j])
+	 */
+	public getTotalSum(): number {
+		this._ensureValid();
+		return this._indexBySum.length;
+	}
+
+	/**
+	 * Returns the sum of the first `count` many items.
+	 * @returns `SUM(0 <= j < count, values[j])`.
+	 */
+	public getPrefixSum(count: number): number {
+		this._ensureValid();
+		if (count === 0) {
+			return 0;
+		}
+		return this._prefixSum[count - 1];
+	}
+
+	/**
+	 * @returns `result`, such that `getPrefixSum(result.index) + result.remainder = sum`
+	 */
+	public getIndexOf(sum: number): PrefixSumIndexOfResult {
+		this._ensureValid();
+		const idx = this._indexBySum[sum];
+		const viewLinesAbove = idx > 0 ? this._prefixSum[idx - 1] : 0;
+		return new PrefixSumIndexOfResult(idx, sum - viewLinesAbove);
+	}
+
+	public removeValues(start: number, deleteCount: number): void {
+		this._values.splice(start, deleteCount);
+		this._invalidate(start);
+	}
+
+	public insertValues(insertIndex: number, insertArr: number[]): void {
+		this._values = arrayInsert(this._values, insertIndex, insertArr);
+		this._invalidate(insertIndex);
+	}
+
+	private _invalidate(index: number): void {
+		this._isValid = false;
+		this._validEndIndex = Math.min(this._validEndIndex, index - 1);
+	}
+
+	private _ensureValid(): void {
+		if (this._isValid) {
+			return;
+		}
+
+		for (let i = this._validEndIndex + 1, len = this._values.length; i < len; i++) {
+			const value = this._values[i];
+			const sumAbove = i > 0 ? this._prefixSum[i - 1] : 0;
+
+			this._prefixSum[i] = sumAbove + value;
+			for (let j = 0; j < value; j++) {
+				this._indexBySum[sumAbove + j] = i;
+			}
+		}
+
+		// trim things
+		this._prefixSum.length = this._values.length;
+		this._indexBySum.length = this._prefixSum[this._prefixSum.length - 1];
+
+		// mark as valid
+		this._isValid = true;
+		this._validEndIndex = this._values.length - 1;
+	}
+
+	public setValue(index: number, value: number): void {
+		if (this._values[index] === value) {
+			// no change
+			return;
+		}
+		this._values[index] = value;
+		this._invalidate(index);
+	}
+}
+
+
+export class PrefixSumIndexOfResult {
+	_prefixSumIndexOfResultBrand: void = undefined;
+
+	constructor(
+		public readonly index: number,
+		public readonly remainder: number
+	) {
+		this.index = index;
+		this.remainder = remainder;
+	}
+}

package/src/_internal/util/vs/nls.messages.ts

@@ -0,0 +1,21 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+/*
+ * This module exists so that the AMD build of the monaco editor can replace this with an async loader plugin.
+ * If you add new functions to this module make sure that they are also provided in the AMD build of the monaco editor.
+ *
+ * TODO@esm remove me once we no longer ship an AMD build.
+ */
+
+export function getNLSMessages(): string[] {
+	return globalThis._VSCODE_NLS_MESSAGES;
+}
+
+export function getNLSLanguage(): string | undefined {
+	return globalThis._VSCODE_NLS_LANGUAGE;
+}

package/src/_internal/util/vs/nls.ts

@@ -0,0 +1,243 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+// eslint-disable-next-line local/code-import-patterns
+import { getNLSLanguage, getNLSMessages } from './nls.messages';
+// eslint-disable-next-line local/code-import-patterns
+export { getNLSLanguage, getNLSMessages } from './nls.messages';
+
+declare const document: { location?: { hash?: string } } | undefined;
+const isPseudo = getNLSLanguage() === 'pseudo' || (typeof document !== 'undefined' && document.location && typeof document.location.hash === 'string' && document.location.hash.indexOf('pseudo=true') >= 0);
+
+export interface ILocalizeInfo {
+	key: string;
+	comment: string[];
+}
+
+export interface ILocalizedString {
+	original: string;
+	value: string;
+}
+
+function _format(message: string, args: (string | number | boolean | undefined | null)[]): string {
+	let result: string;
+
+	if (args.length === 0) {
+		result = message;
+	} else {
+		result = message.replace(/\{(\d+)\}/g, (match, rest) => {
+			const index = rest[0];
+			const arg = args[index];
+			let result = match;
+			if (typeof arg === 'string') {
+				result = arg;
+			} else if (typeof arg === 'number' || typeof arg === 'boolean' || arg === void 0 || arg === null) {
+				result = String(arg);
+			}
+			return result;
+		});
+	}
+
+	if (isPseudo) {
+		// FF3B and FF3D is the Unicode zenkaku representation for [ and ]
+		result = '\uFF3B' + result.replace(/[aouei]/g, '$&$&') + '\uFF3D';
+	}
+
+	return result;
+}
+
+/**
+ * Marks a string to be localized. Returns the localized string.
+ *
+ * @param info The {@linkcode ILocalizeInfo} which describes the id and comments associated with the localized string.
+ * @param message The string to localize
+ * @param args The arguments to the string
+ *
+ * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`
+ * @example `localize({ key: 'sayHello', comment: ['Welcomes user'] }, 'hello {0}', name)`
+ *
+ * @returns string The localized string.
+ */
+export function localize(info: ILocalizeInfo, message: string, ...args: (string | number | boolean | undefined | null)[]): string;
+
+/**
+ * Marks a string to be localized. Returns the localized string.
+ *
+ * @param key The key to use for localizing the string
+ * @param message The string to localize
+ * @param args The arguments to the string
+ *
+ * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`
+ * @example For example, `localize('sayHello', 'hello {0}', name)`
+ *
+ * @returns string The localized string.
+ */
+export function localize(key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): string;
+
+/**
+ * @skipMangle
+ */
+export function localize(data: ILocalizeInfo | string /* | number when built */, message: string /* | null when built */, ...args: (string | number | boolean | undefined | null)[]): string {
+	if (typeof data === 'number') {
+		return _format(lookupMessage(data, message), args);
+	}
+	return _format(message, args);
+}
+
+/**
+ * Only used when built: Looks up the message in the global NLS table.
+ * This table is being made available as a global through bootstrapping
+ * depending on the target context.
+ */
+function lookupMessage(index: number, fallback: string | null): string {
+	const message = getNLSMessages()?.[index];
+	if (typeof message !== 'string') {
+		if (typeof fallback === 'string') {
+			return fallback;
+		}
+		throw new Error(`!!! NLS MISSING: ${index} !!!`);
+	}
+	return message;
+}
+
+/**
+ * Marks a string to be localized. Returns an {@linkcode ILocalizedString}
+ * which contains the localized string and the original string.
+ *
+ * @param info The {@linkcode ILocalizeInfo} which describes the id and comments associated with the localized string.
+ * @param message The string to localize
+ * @param args The arguments to the string
+ *
+ * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`
+ * @example `localize2({ key: 'sayHello', comment: ['Welcomes user'] }, 'hello {0}', name)`
+ *
+ * @returns ILocalizedString which contains the localized string and the original string.
+ */
+export function localize2(info: ILocalizeInfo, message: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString;
+
+/**
+ * Marks a string to be localized. Returns an {@linkcode ILocalizedString}
+ * which contains the localized string and the original string.
+ *
+ * @param key The key to use for localizing the string
+ * @param message The string to localize
+ * @param args The arguments to the string
+ *
+ * @note `message` can contain `{n}` notation where it is replaced by the nth value in `...args`
+ * @example `localize('sayHello', 'hello {0}', name)`
+ *
+ * @returns ILocalizedString which contains the localized string and the original string.
+ */
+export function localize2(key: string, message: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString;
+
+/**
+ * @skipMangle
+ */
+export function localize2(data: ILocalizeInfo | string /* | number when built */, originalMessage: string, ...args: (string | number | boolean | undefined | null)[]): ILocalizedString {
+	let message: string;
+	if (typeof data === 'number') {
+		message = lookupMessage(data, originalMessage);
+	} else {
+		message = originalMessage;
+	}
+
+	const value = _format(message, args);
+
+	return {
+		value,
+		original: originalMessage === message ? value : _format(originalMessage, args)
+	};
+}
+
+export interface INLSLanguagePackConfiguration {
+
+	/**
+	 * The path to the translations config file that contains pointers to
+	 * all message bundles for `main` and extensions.
+	 */
+	readonly translationsConfigFile: string;
+
+	/**
+	 * The path to the file containing the translations for this language
+	 * pack as flat string array.
+	 */
+	readonly messagesFile: string;
+
+	/**
+	 * The path to the file that can be used to signal a corrupt language
+	 * pack, for example when reading the `messagesFile` fails. This will
+	 * instruct the application to re-create the cache on next startup.
+	 */
+	readonly corruptMarkerFile: string;
+}
+
+export interface INLSConfiguration {
+
+	/**
+	 * Locale as defined in `argv.json` or `app.getLocale()`.
+	 */
+	readonly userLocale: string;
+
+	/**
+	 * Locale as defined by the OS (e.g. `app.getPreferredSystemLanguages()`).
+	 */
+	readonly osLocale: string;
+
+	/**
+	 * The actual language of the UI that ends up being used considering `userLocale`
+	 * and `osLocale`.
+	 */
+	readonly resolvedLanguage: string;
+
+	/**
+	 * Defined if a language pack is used that is not the
+	 * default english language pack. This requires a language
+	 * pack to be installed as extension.
+	 */
+	readonly languagePack?: INLSLanguagePackConfiguration;
+
+	/**
+	 * The path to the file containing the default english messages
+	 * as flat string array. The file is only present in built
+	 * versions of the application.
+	 */
+	readonly defaultMessagesFile: string;
+
+	/**
+	 * Below properties are deprecated and only there to continue support
+	 * for `vscode-nls` module that depends on them.
+	 * Refs https://github.com/microsoft/vscode-nls/blob/main/src/node/main.ts#L36-L46
+	 */
+	/** @deprecated */
+	readonly locale: string;
+	/** @deprecated */
+	readonly availableLanguages: Record<string, string>;
+	/** @deprecated */
+	readonly _languagePackSupport?: boolean;
+	/** @deprecated */
+	readonly _languagePackId?: string;
+	/** @deprecated */
+	readonly _translationsConfigFile?: string;
+	/** @deprecated */
+	readonly _cacheRoot?: string;
+	/** @deprecated */
+	readonly _resolvedLanguagePackCoreLocation?: string;
+	/** @deprecated */
+	readonly _corruptedFile?: string;
+}
+
+export interface ILanguagePack {
+	readonly hash: string;
+	readonly label: string | undefined;
+	readonly extensions: {
+		readonly extensionIdentifier: { readonly id: string; readonly uuid?: string };
+		readonly version: string;
+	}[];
+	readonly translations: Record<string, string | undefined>;
+}
+
+export type ILanguagePacks = Record<string, ILanguagePack | undefined>;

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

@@ -0,0 +1,23 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+export class SyncDescriptor<T> {
+
+	readonly ctor: any;
+	readonly staticArguments: any[];
+	readonly supportsDelayedInstantiation: boolean;
+
+	constructor(ctor: new (...args: any[]) => T, staticArguments: any[] = [], supportsDelayedInstantiation: boolean = false) {
+		this.ctor = ctor;
+		this.staticArguments = staticArguments;
+		this.supportsDelayedInstantiation = supportsDelayedInstantiation;
+	}
+}
+
+export interface SyncDescriptor0<T> {
+	readonly ctor: new () => T;
+}

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

@@ -0,0 +1,113 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+export class Node<T> {
+
+
+	readonly incoming = new Map<string, Node<T>>();
+	readonly outgoing = new Map<string, Node<T>>();
+
+	constructor(
+		readonly key: string,
+		readonly data: T
+	) { }
+}
+
+export class Graph<T> {
+
+	private readonly _nodes = new Map<string, Node<T>>();
+
+	constructor(private readonly _hashFn: (element: T) => string) {
+		// empty
+	}
+
+	roots(): Node<T>[] {
+		const ret: Node<T>[] = [];
+		for (const node of this._nodes.values()) {
+			if (node.outgoing.size === 0) {
+				ret.push(node);
+			}
+		}
+		return ret;
+	}
+
+	insertEdge(from: T, to: T): void {
+		const fromNode = this.lookupOrInsertNode(from);
+		const toNode = this.lookupOrInsertNode(to);
+
+		fromNode.outgoing.set(toNode.key, toNode);
+		toNode.incoming.set(fromNode.key, fromNode);
+	}
+
+	removeNode(data: T): void {
+		const key = this._hashFn(data);
+		this._nodes.delete(key);
+		for (const node of this._nodes.values()) {
+			node.outgoing.delete(key);
+			node.incoming.delete(key);
+		}
+	}
+
+	lookupOrInsertNode(data: T): Node<T> {
+		const key = this._hashFn(data);
+		let node = this._nodes.get(key);
+
+		if (!node) {
+			node = new Node(key, data);
+			this._nodes.set(key, node);
+		}
+
+		return node;
+	}
+
+	lookup(data: T): Node<T> | undefined {
+		return this._nodes.get(this._hashFn(data));
+	}
+
+	isEmpty(): boolean {
+		return this._nodes.size === 0;
+	}
+
+	toString(): string {
+		const data: string[] = [];
+		for (const [key, value] of this._nodes) {
+			data.push(`${key}\n\t(-> incoming)[${[...value.incoming.keys()].join(', ')}]\n\t(outgoing ->)[${[...value.outgoing.keys()].join(',')}]\n`);
+
+		}
+		return data.join('\n');
+	}
+
+	/**
+	 * This is brute force and slow and **only** be used
+	 * to trouble shoot.
+	 */
+	findCycleSlow() {
+		for (const [id, node] of this._nodes) {
+			const seen = new Set<string>([id]);
+			const res = this._findCycle(node, seen);
+			if (res) {
+				return res;
+			}
+		}
+		return undefined;
+	}
+
+	private _findCycle(node: Node<T>, seen: Set<string>): string | undefined {
+		for (const [id, outgoing] of node.outgoing) {
+			if (seen.has(id)) {
+				return [...seen, id].join(' -> ');
+			}
+			seen.add(id);
+			const value = this._findCycle(outgoing, seen);
+			if (value) {
+				return value;
+			}
+			seen.delete(id);
+		}
+		return undefined;
+	}
+}