@xterm/xterm 6.1.0-beta.28 → 6.1.0-beta.281

package/src/vs/base/common/linkedList.ts

@@ -1,142 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-class Node<E> {
-
-	static readonly Undefined = new Node<any>(undefined);
-
-	element: E;
-	next: Node<E>;
-	prev: Node<E>;
-
-	constructor(element: E) {
-		this.element = element;
-		this.next = Node.Undefined;
-		this.prev = Node.Undefined;
-	}
-}
-
-export class LinkedList<E> {
-
-	private _first: Node<E> = Node.Undefined;
-	private _last: Node<E> = Node.Undefined;
-	private _size: number = 0;
-
-	get size(): number {
-		return this._size;
-	}
-
-	isEmpty(): boolean {
-		return this._first === Node.Undefined;
-	}
-
-	clear(): void {
-		let node = this._first;
-		while (node !== Node.Undefined) {
-			const next = node.next;
-			node.prev = Node.Undefined;
-			node.next = Node.Undefined;
-			node = next;
-		}
-
-		this._first = Node.Undefined;
-		this._last = Node.Undefined;
-		this._size = 0;
-	}
-
-	unshift(element: E): () => void {
-		return this._insert(element, false);
-	}
-
-	push(element: E): () => void {
-		return this._insert(element, true);
-	}
-
-	private _insert(element: E, atTheEnd: boolean): () => void {
-		const newNode = new Node(element);
-		if (this._first === Node.Undefined) {
-			this._first = newNode;
-			this._last = newNode;
-
-		} else if (atTheEnd) {
-			// push
-			const oldLast = this._last;
-			this._last = newNode;
-			newNode.prev = oldLast;
-			oldLast.next = newNode;
-
-		} else {
-			// unshift
-			const oldFirst = this._first;
-			this._first = newNode;
-			newNode.next = oldFirst;
-			oldFirst.prev = newNode;
-		}
-		this._size += 1;
-
-		let didRemove = false;
-		return () => {
-			if (!didRemove) {
-				didRemove = true;
-				this._remove(newNode);
-			}
-		};
-	}
-
-	shift(): E | undefined {
-		if (this._first === Node.Undefined) {
-			return undefined;
-		} else {
-			const res = this._first.element;
-			this._remove(this._first);
-			return res;
-		}
-	}
-
-	pop(): E | undefined {
-		if (this._last === Node.Undefined) {
-			return undefined;
-		} else {
-			const res = this._last.element;
-			this._remove(this._last);
-			return res;
-		}
-	}
-
-	private _remove(node: Node<E>): void {
-		if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
-			// middle
-			const anchor = node.prev;
-			anchor.next = node.next;
-			node.next.prev = anchor;
-
-		} else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
-			// only node
-			this._first = Node.Undefined;
-			this._last = Node.Undefined;
-
-		} else if (node.next === Node.Undefined) {
-			// last
-			this._last = this._last.prev!;
-			this._last.next = Node.Undefined;
-
-		} else if (node.prev === Node.Undefined) {
-			// first
-			this._first = this._first.next!;
-			this._first.prev = Node.Undefined;
-		}
-
-		// done
-		this._size -= 1;
-	}
-
-	*[Symbol.iterator](): Iterator<E> {
-		let node = this._first;
-		while (node !== Node.Undefined) {
-			yield node.element;
-			node = node.next;
-		}
-	}
-}

package/src/vs/base/common/map.ts

@@ -1,202 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export function getOrSet<K, V>(map: Map<K, V>, key: K, value: V): V {
-	let result = map.get(key);
-	if (result === undefined) {
-		result = value;
-		map.set(key, result);
-	}
-
-	return result;
-}
-
-export function mapToString<K, V>(map: Map<K, V>): string {
-	const entries: string[] = [];
-	map.forEach((value, key) => {
-		entries.push(`${key} => ${value}`);
-	});
-
-	return `Map(${map.size}) {${entries.join(', ')}}`;
-}
-
-export function setToString<K>(set: Set<K>): string {
-	const entries: K[] = [];
-	set.forEach(value => {
-		entries.push(value);
-	});
-
-	return `Set(${set.size}) {${entries.join(', ')}}`;
-}
-
-export const enum Touch {
-	None = 0,
-	AsOld = 1,
-	AsNew = 2
-}
-
-export class CounterSet<T> {
-
-	private map = new Map<T, number>();
-
-	add(value: T): CounterSet<T> {
-		this.map.set(value, (this.map.get(value) || 0) + 1);
-		return this;
-	}
-
-	delete(value: T): boolean {
-		let counter = this.map.get(value) || 0;
-
-		if (counter === 0) {
-			return false;
-		}
-
-		counter--;
-
-		if (counter === 0) {
-			this.map.delete(value);
-		} else {
-			this.map.set(value, counter);
-		}
-
-		return true;
-	}
-
-	has(value: T): boolean {
-		return this.map.has(value);
-	}
-}
-
-/**
- * A map that allows access both by keys and values.
- * **NOTE**: values need to be unique.
- */
-export class BidirectionalMap<K, V> {
-
-	private readonly _m1 = new Map<K, V>();
-	private readonly _m2 = new Map<V, K>();
-
-	constructor(entries?: readonly (readonly [K, V])[]) {
-		if (entries) {
-			for (const [key, value] of entries) {
-				this.set(key, value);
-			}
-		}
-	}
-
-	clear(): void {
-		this._m1.clear();
-		this._m2.clear();
-	}
-
-	set(key: K, value: V): void {
-		this._m1.set(key, value);
-		this._m2.set(value, key);
-	}
-
-	get(key: K): V | undefined {
-		return this._m1.get(key);
-	}
-
-	getKey(value: V): K | undefined {
-		return this._m2.get(value);
-	}
-
-	delete(key: K): boolean {
-		const value = this._m1.get(key);
-		if (value === undefined) {
-			return false;
-		}
-		this._m1.delete(key);
-		this._m2.delete(value);
-		return true;
-	}
-
-	forEach(callbackfn: (value: V, key: K, map: BidirectionalMap<K, V>) => void, thisArg?: any): void {
-		this._m1.forEach((value, key) => {
-			callbackfn.call(thisArg, value, key, this);
-		});
-	}
-
-	keys(): IterableIterator<K> {
-		return this._m1.keys();
-	}
-
-	values(): IterableIterator<V> {
-		return this._m1.values();
-	}
-}
-
-export class SetMap<K, V> {
-
-	private map = new Map<K, Set<V>>();
-
-	add(key: K, value: V): void {
-		let values = this.map.get(key);
-
-		if (!values) {
-			values = new Set<V>();
-			this.map.set(key, values);
-		}
-
-		values.add(value);
-	}
-
-	delete(key: K, value: V): void {
-		const values = this.map.get(key);
-
-		if (!values) {
-			return;
-		}
-
-		values.delete(value);
-
-		if (values.size === 0) {
-			this.map.delete(key);
-		}
-	}
-
-	forEach(key: K, fn: (value: V) => void): void {
-		const values = this.map.get(key);
-
-		if (!values) {
-			return;
-		}
-
-		values.forEach(fn);
-	}
-
-	get(key: K): ReadonlySet<V> {
-		const values = this.map.get(key);
-		if (!values) {
-			return new Set<V>();
-		}
-		return values;
-	}
-}
-
-export function mapsStrictEqualIgnoreOrder(a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean {
-	if (a === b) {
-		return true;
-	}
-
-	if (a.size !== b.size) {
-		return false;
-	}
-
-	for (const [key, value] of a) {
-		if (!b.has(key) || b.get(key) !== value) {
-			return false;
-		}
-	}
-
-	for (const [key] of b) {
-		if (!a.has(key)) {
-			return false;
-		}
-	}
-
-	return true;
-}

package/src/vs/base/common/numbers.ts

@@ -1,98 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-export function clamp(value: number, min: number, max: number): number {
-	return Math.min(Math.max(value, min), max);
-}
-
-export function rot(index: number, modulo: number): number {
-	return (modulo + (index % modulo)) % modulo;
-}
-
-export class Counter {
-	private _next = 0;
-
-	getNext(): number {
-		return this._next++;
-	}
-}
-
-export class MovingAverage {
-
-	private _n = 1;
-	private _val = 0;
-
-	update(value: number): number {
-		this._val = this._val + (value - this._val) / this._n;
-		this._n += 1;
-		return this._val;
-	}
-
-	get value(): number {
-		return this._val;
-	}
-}
-
-export class SlidingWindowAverage {
-
-	private _n: number = 0;
-	private _val = 0;
-
-	private readonly _values: number[] = [];
-	private _index: number = 0;
-	private _sum = 0;
-
-	constructor(size: number) {
-		this._values = new Array(size);
-		this._values.fill(0, 0, size);
-	}
-
-	update(value: number): number {
-		const oldValue = this._values[this._index];
-		this._values[this._index] = value;
-		this._index = (this._index + 1) % this._values.length;
-
-		this._sum -= oldValue;
-		this._sum += value;
-
-		if (this._n < this._values.length) {
-			this._n += 1;
-		}
-
-		this._val = this._sum / this._n;
-		return this._val;
-	}
-
-	get value(): number {
-		return this._val;
-	}
-}
-
-/** Returns whether the point is within the triangle formed by the following 6 x/y point pairs */
-export function isPointWithinTriangle(
-	x: number, y: number,
-	ax: number, ay: number,
-	bx: number, by: number,
-	cx: number, cy: number
-) {
-	const v0x = cx - ax;
-	const v0y = cy - ay;
-	const v1x = bx - ax;
-	const v1y = by - ay;
-	const v2x = x - ax;
-	const v2y = y - ay;
-
-	const dot00 = v0x * v0x + v0y * v0y;
-	const dot01 = v0x * v1x + v0y * v1y;
-	const dot02 = v0x * v2x + v0y * v2y;
-	const dot11 = v1x * v1x + v1y * v1y;
-	const dot12 = v1x * v2x + v1y * v2y;
-
-	const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
-	const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
-	const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
-
-	return u >= 0 && v >= 0 && u + v < 1;
-}

package/src/vs/base/common/observable.ts

@@ -1,76 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-// This is a facade for the observable implementation. Only import from here!
-
-export type {
-	IObservable,
-	IObserver,
-	IReader,
-	ISettable,
-	ISettableObservable,
-	ITransaction,
-	IChangeContext,
-	IChangeTracker,
-} from 'vs/base/common/observableInternal/base';
-
-export {
-	observableValue,
-	disposableObservableValue,
-	transaction,
-	subtransaction,
-} from 'vs/base/common/observableInternal/base';
-export {
-	derived,
-	derivedOpts,
-	derivedHandleChanges,
-	derivedWithStore,
-} from 'vs/base/common/observableInternal/derived';
-export {
-	autorun,
-	autorunDelta,
-	autorunHandleChanges,
-	autorunWithStore,
-	autorunOpts,
-	autorunWithStoreHandleChanges,
-} from 'vs/base/common/observableInternal/autorun';
-export type {
-	IObservableSignal,
-} from 'vs/base/common/observableInternal/utils';
-export {
-	constObservable,
-	debouncedObservable,
-	derivedObservableWithCache,
-	derivedObservableWithWritableCache,
-	keepObserved,
-	recomputeInitiallyAndOnChange,
-	observableFromEvent,
-	observableFromPromise,
-	observableSignal,
-	observableSignalFromEvent,
-	wasEventTriggeredRecently,
-} from 'vs/base/common/observableInternal/utils';
-export {
-	ObservableLazy,
-	ObservableLazyPromise,
-	ObservablePromise,
-	PromiseResult,
-	waitForState,
-	derivedWithCancellationToken,
-} from 'vs/base/common/observableInternal/promise';
-export {
-	observableValueOpts
-} from 'vs/base/common/observableInternal/api';
-
-import { ConsoleObservableLogger, setLogger } from 'vs/base/common/observableInternal/logging';
-
-// Remove "//" in the next line to enable logging
-const enableLogging = false
-	// || Boolean("true") // done "weirdly" so that a lint warning prevents you from pushing this
-	;
-
-if (enableLogging) {
-	setLogger(new ConsoleObservableLogger());
-}

package/src/vs/base/common/observableInternal/api.ts

@@ -1,31 +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 { EqualityComparer, strictEquals } from 'vs/base/common/equals';
-import { ISettableObservable } from 'vs/base/common/observable';
-import { ObservableValue } from 'vs/base/common/observableInternal/base';
-import { IDebugNameData, DebugNameData } from 'vs/base/common/observableInternal/debugName';
-import { LazyObservableValue } from 'vs/base/common/observableInternal/lazyObservableValue';
-
-export function observableValueOpts<T, TChange = void>(
-	options: IDebugNameData & {
-		equalsFn?: EqualityComparer<T>;
-		lazy?: boolean;
-	},
-	initialValue: T
-): ISettableObservable<T, TChange> {
-	if (options.lazy) {
-		return new LazyObservableValue(
-			new DebugNameData(options.owner, options.debugName, undefined),
-			initialValue,
-			options.equalsFn ?? strictEquals,
-		);
-	}
-	return new ObservableValue(
-		new DebugNameData(options.owner, options.debugName, undefined),
-		initialValue,
-		options.equalsFn ?? strictEquals,
-	);
-}