@vscode/chat-lib 0.0.1

package/src/_internal/util/vs/base/common/diff/diffChange.ts

@@ -0,0 +1,62 @@
+//!!! 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.
+ *--------------------------------------------------------------------------------------------*/
+
+/**
+ * Represents information about a specific difference between two sequences.
+ */
+export class DiffChange {
+
+	/**
+	 * The position of the first element in the original sequence which
+	 * this change affects.
+	 */
+	public originalStart: number;
+
+	/**
+	 * The number of elements from the original sequence which were
+	 * affected.
+	 */
+	public originalLength: number;
+
+	/**
+	 * The position of the first element in the modified sequence which
+	 * this change affects.
+	 */
+	public modifiedStart: number;
+
+	/**
+	 * The number of elements from the modified sequence which were
+	 * affected (added).
+	 */
+	public modifiedLength: number;
+
+	/**
+	 * Constructs a new DiffChange with the given sequence information
+	 * and content.
+	 */
+	constructor(originalStart: number, originalLength: number, modifiedStart: number, modifiedLength: number) {
+		//Debug.Assert(originalLength > 0 || modifiedLength > 0, "originalLength and modifiedLength cannot both be <= 0");
+		this.originalStart = originalStart;
+		this.originalLength = originalLength;
+		this.modifiedStart = modifiedStart;
+		this.modifiedLength = modifiedLength;
+	}
+
+	/**
+	 * The end point (exclusive) of the change in the original sequence.
+	 */
+	public getOriginalEnd() {
+		return this.originalStart + this.originalLength;
+	}
+
+	/**
+	 * The end point (exclusive) of the change in the modified sequence.
+	 */
+	public getModifiedEnd() {
+		return this.modifiedStart + this.modifiedLength;
+	}
+}

package/src/_internal/util/vs/base/common/equals.ts

@@ -0,0 +1,148 @@
+//!!! 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 * as arrays from './arrays';
+
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+
+/**
+ * Compares two items for equality using strict equality.
+*/
+export const strictEquals: EqualityComparer<any> = (a, b) => a === b;
+
+/**
+ * Checks if the items of two arrays are equal.
+ * By default, strict equality is used to compare elements, but a custom equality comparer can be provided.
+ */
+export function itemsEquals<T>(itemEquals: EqualityComparer<T> = strictEquals): EqualityComparer<readonly T[]> {
+	return (a, b) => arrays.equals(a, b, itemEquals);
+}
+
+/**
+ * Two items are considered equal, if their stringified representations are equal.
+*/
+export function jsonStringifyEquals<T>(): EqualityComparer<T> {
+	return (a, b) => JSON.stringify(a) === JSON.stringify(b);
+}
+
+/**
+ * Uses `item.equals(other)` to determine equality.
+ */
+export function itemEquals<T extends { equals(other: T): boolean }>(): EqualityComparer<T> {
+	return (a, b) => a.equals(b);
+}
+
+/**
+ * Checks if two items are both null or undefined, or are equal according to the provided equality comparer.
+*/
+export function equalsIfDefined<T>(v1: T | undefined | null, v2: T | undefined | null, equals: EqualityComparer<T>): boolean;
+/**
+ * Returns an equality comparer that checks if two items are both null or undefined, or are equal according to the provided equality comparer.
+*/
+export function equalsIfDefined<T>(equals: EqualityComparer<T>): EqualityComparer<T | undefined | null>;
+export function equalsIfDefined<T>(equalsOrV1: EqualityComparer<T> | T, v2?: T | undefined | null, equals?: EqualityComparer<T>): EqualityComparer<T | undefined | null> | boolean {
+	if (equals !== undefined) {
+		const v1 = equalsOrV1 as T | undefined;
+		if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+			return v2 === v1;
+		}
+		return equals(v1, v2);
+	} else {
+		const equals = equalsOrV1 as EqualityComparer<T>;
+		return (v1, v2) => {
+			if (v1 === undefined || v1 === null || v2 === undefined || v2 === null) {
+				return v2 === v1;
+			}
+			return equals(v1, v2);
+		};
+	}
+}
+
+/**
+ * Drills into arrays (items ordered) and objects (keys unordered) and uses strict equality on everything else.
+*/
+export function structuralEquals<T>(a: T, b: T): boolean {
+	if (a === b) {
+		return true;
+	}
+
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) {
+			return false;
+		}
+		for (let i = 0; i < a.length; i++) {
+			if (!structuralEquals(a[i], b[i])) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	if (a && typeof a === 'object' && b && typeof b === 'object') {
+		if (Object.getPrototypeOf(a) === Object.prototype && Object.getPrototypeOf(b) === Object.prototype) {
+			const aObj = a as Record<string, unknown>;
+			const bObj = b as Record<string, unknown>;
+			const keysA = Object.keys(aObj);
+			const keysB = Object.keys(bObj);
+			const keysBSet = new Set(keysB);
+
+			if (keysA.length !== keysB.length) {
+				return false;
+			}
+
+			for (const key of keysA) {
+				if (!keysBSet.has(key)) {
+					return false;
+				}
+				if (!structuralEquals(aObj[key], bObj[key])) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * `getStructuralKey(a) === getStructuralKey(b) <=> structuralEquals(a, b)`
+ * (assuming that a and b are not cyclic structures and nothing extends globalThis Array).
+*/
+export function getStructuralKey(t: unknown): string {
+	return JSON.stringify(toNormalizedJsonStructure(t));
+}
+
+let objectId = 0;
+const objIds = new WeakMap<object, number>();
+
+function toNormalizedJsonStructure(t: unknown): unknown {
+	if (Array.isArray(t)) {
+		return t.map(toNormalizedJsonStructure);
+	}
+
+	if (t && typeof t === 'object') {
+		if (Object.getPrototypeOf(t) === Object.prototype) {
+			const tObj = t as Record<string, unknown>;
+			const res: Record<string, unknown> = Object.create(null);
+			for (const key of Object.keys(tObj).sort()) {
+				res[key] = toNormalizedJsonStructure(tObj[key]);
+			}
+			return res;
+		} else {
+			let objId = objIds.get(t);
+			if (objId === undefined) {
+				objId = objectId++;
+				objIds.set(t, objId);
+			}
+			// Random string to prevent collisions
+			return objId + '----2b76a038c20c4bcc';
+		}
+	}
+	return t;
+}

package/src/_internal/util/vs/base/common/errors.ts

@@ -0,0 +1,342 @@
+//!!! 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 interface ErrorListenerCallback {
+	(error: any): void;
+}
+
+export interface ErrorListenerUnbind {
+	(): void;
+}
+
+// Avoid circular dependency on EventEmitter by implementing a subset of the interface.
+export class ErrorHandler {
+	private unexpectedErrorHandler: (e: any) => void;
+	private listeners: ErrorListenerCallback[];
+
+	constructor() {
+
+		this.listeners = [];
+
+		this.unexpectedErrorHandler = function (e: any) {
+			setTimeout(() => {
+				if (e.stack) {
+					if (ErrorNoTelemetry.isErrorNoTelemetry(e)) {
+						throw new ErrorNoTelemetry(e.message + '\n\n' + e.stack);
+					}
+
+					throw new Error(e.message + '\n\n' + e.stack);
+				}
+
+				throw e;
+			}, 0);
+		};
+	}
+
+	addListener(listener: ErrorListenerCallback): ErrorListenerUnbind {
+		this.listeners.push(listener);
+
+		return () => {
+			this._removeListener(listener);
+		};
+	}
+
+	private emit(e: any): void {
+		this.listeners.forEach((listener) => {
+			listener(e);
+		});
+	}
+
+	private _removeListener(listener: ErrorListenerCallback): void {
+		this.listeners.splice(this.listeners.indexOf(listener), 1);
+	}
+
+	setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {
+		this.unexpectedErrorHandler = newUnexpectedErrorHandler;
+	}
+
+	getUnexpectedErrorHandler(): (e: any) => void {
+		return this.unexpectedErrorHandler;
+	}
+
+	onUnexpectedError(e: any): void {
+		this.unexpectedErrorHandler(e);
+		this.emit(e);
+	}
+
+	// For external errors, we don't want the listeners to be called
+	onUnexpectedExternalError(e: any): void {
+		this.unexpectedErrorHandler(e);
+	}
+}
+
+export const errorHandler = new ErrorHandler();
+
+/** @skipMangle */
+export function setUnexpectedErrorHandler(newUnexpectedErrorHandler: (e: any) => void): void {
+	errorHandler.setUnexpectedErrorHandler(newUnexpectedErrorHandler);
+}
+
+/**
+ * Returns if the error is a SIGPIPE error. SIGPIPE errors should generally be
+ * logged at most once, to avoid a loop.
+ *
+ * @see https://github.com/microsoft/vscode-remote-release/issues/6481
+ */
+export function isSigPipeError(e: unknown): e is Error {
+	if (!e || typeof e !== 'object') {
+		return false;
+	}
+
+	const cast = e as Record<string, string | undefined>;
+	return cast.code === 'EPIPE' && cast.syscall?.toUpperCase() === 'WRITE';
+}
+
+/**
+ * This function should only be called with errors that indicate a bug in the product.
+ * E.g. buggy extensions/invalid user-input/network issues should not be able to trigger this code path.
+ * If they are, this indicates there is also a bug in the product.
+*/
+export function onBugIndicatingError(e: any): undefined {
+	errorHandler.onUnexpectedError(e);
+	return undefined;
+}
+
+export function onUnexpectedError(e: any): undefined {
+	// ignore errors from cancelled promises
+	if (!isCancellationError(e)) {
+		errorHandler.onUnexpectedError(e);
+	}
+	return undefined;
+}
+
+export function onUnexpectedExternalError(e: any): undefined {
+	// ignore errors from cancelled promises
+	if (!isCancellationError(e)) {
+		errorHandler.onUnexpectedExternalError(e);
+	}
+	return undefined;
+}
+
+export interface SerializedError {
+	readonly $isError: true;
+	readonly name: string;
+	readonly message: string;
+	readonly stack: string;
+	readonly noTelemetry: boolean;
+	readonly code?: string;
+	readonly cause?: SerializedError;
+}
+
+type ErrorWithCode = Error & {
+	code: string | undefined;
+};
+
+export function transformErrorForSerialization(error: Error): SerializedError;
+export function transformErrorForSerialization(error: any): any;
+export function transformErrorForSerialization(error: any): any {
+	if (error instanceof Error) {
+		const { name, message, cause } = error;
+		const stack: string = (<any>error).stacktrace || (<any>error).stack;
+		return {
+			$isError: true,
+			name,
+			message,
+			stack,
+			noTelemetry: ErrorNoTelemetry.isErrorNoTelemetry(error),
+			cause: cause ? transformErrorForSerialization(cause) : undefined,
+			code: (<ErrorWithCode>error).code
+		};
+	}
+
+	// return as is
+	return error;
+}
+
+export function transformErrorFromSerialization(data: SerializedError): Error {
+	let error: Error;
+	if (data.noTelemetry) {
+		error = new ErrorNoTelemetry();
+	} else {
+		error = new Error();
+		error.name = data.name;
+	}
+	error.message = data.message;
+	error.stack = data.stack;
+	if (data.code) {
+		(<ErrorWithCode>error).code = data.code;
+	}
+	if (data.cause) {
+		error.cause = transformErrorFromSerialization(data.cause);
+	}
+	return error;
+}
+
+// see https://github.com/v8/v8/wiki/Stack%20Trace%20API#basic-stack-traces
+export interface V8CallSite {
+	getThis(): unknown;
+	getTypeName(): string | null;
+	getFunction(): Function | undefined;
+	getFunctionName(): string | null;
+	getMethodName(): string | null;
+	getFileName(): string | null;
+	getLineNumber(): number | null;
+	getColumnNumber(): number | null;
+	getEvalOrigin(): string | undefined;
+	isToplevel(): boolean;
+	isEval(): boolean;
+	isNative(): boolean;
+	isConstructor(): boolean;
+	toString(): string;
+}
+
+export const canceledName = 'Canceled';
+
+/**
+ * Checks if the given error is a promise in canceled state
+ */
+export function isCancellationError(error: any): boolean {
+	if (error instanceof CancellationError) {
+		return true;
+	}
+	return error instanceof Error && error.name === canceledName && error.message === canceledName;
+}
+
+// !!!IMPORTANT!!!
+// Do NOT change this class because it is also used as an API-type.
+export class CancellationError extends Error {
+	constructor() {
+		super(canceledName);
+		this.name = this.message;
+	}
+}
+
+export class PendingMigrationError extends Error {
+
+	private static readonly _name = 'PendingMigrationError';
+
+	static is(error: unknown): error is PendingMigrationError {
+		return error instanceof PendingMigrationError || (error instanceof Error && error.name === PendingMigrationError._name);
+	}
+
+	constructor(message: string) {
+		super(message);
+		this.name = PendingMigrationError._name;
+	}
+}
+
+/**
+ * @deprecated use {@link CancellationError `new CancellationError()`} instead
+ */
+export function canceled(): Error {
+	const error = new Error(canceledName);
+	error.name = error.message;
+	return error;
+}
+
+export function illegalArgument(name?: string): Error {
+	if (name) {
+		return new Error(`Illegal argument: ${name}`);
+	} else {
+		return new Error('Illegal argument');
+	}
+}
+
+export function illegalState(name?: string): Error {
+	if (name) {
+		return new Error(`Illegal state: ${name}`);
+	} else {
+		return new Error('Illegal state');
+	}
+}
+
+export class ReadonlyError extends TypeError {
+	constructor(name?: string) {
+		super(name ? `${name} is read-only and cannot be changed` : 'Cannot change read-only property');
+	}
+}
+
+export function getErrorMessage(err: any): string {
+	if (!err) {
+		return 'Error';
+	}
+
+	if (err.message) {
+		return err.message;
+	}
+
+	if (err.stack) {
+		return err.stack.split('\n')[0];
+	}
+
+	return String(err);
+}
+
+export class NotImplementedError extends Error {
+	constructor(message?: string) {
+		super('NotImplemented');
+		if (message) {
+			this.message = message;
+		}
+	}
+}
+
+export class NotSupportedError extends Error {
+	constructor(message?: string) {
+		super('NotSupported');
+		if (message) {
+			this.message = message;
+		}
+	}
+}
+
+export class ExpectedError extends Error {
+	readonly isExpected = true;
+}
+
+/**
+ * Error that when thrown won't be logged in telemetry as an unhandled error.
+ */
+export class ErrorNoTelemetry extends Error {
+	override readonly name: string;
+
+	constructor(msg?: string) {
+		super(msg);
+		this.name = 'CodeExpectedError';
+	}
+
+	public static fromError(err: Error): ErrorNoTelemetry {
+		if (err instanceof ErrorNoTelemetry) {
+			return err;
+		}
+
+		const result = new ErrorNoTelemetry();
+		result.message = err.message;
+		result.stack = err.stack;
+		return result;
+	}
+
+	public static isErrorNoTelemetry(err: Error): err is ErrorNoTelemetry {
+		return err.name === 'CodeExpectedError';
+	}
+}
+
+/**
+ * This error indicates a bug.
+ * Do not throw this for invalid user input.
+ * Only catch this error to recover gracefully from bugs.
+ */
+export class BugIndicatingError extends Error {
+	constructor(message?: string) {
+		super(message || 'An unexpected bug occurred.');
+		Object.setPrototypeOf(this, BugIndicatingError.prototype);
+
+		// Because we know for sure only buggy code throws this,
+		// we definitely want to break here and fix the bug.
+		// debugger;
+	}
+}