chore(vscode): update to 1.56.0

lib/vscode/src/vs/base/common/stream.ts

@@ -142,15 +142,21 @@ export interface ReadableBufferedStream<T> {
 }
 
 export function isReadableStream<T>(obj: unknown): obj is ReadableStream<T> {
-	const candidate = obj as ReadableStream<T>;
+	const candidate = obj as ReadableStream<T> | undefined;
+	if (!candidate) {
+		return false;
+	}
 
-	return candidate && [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
+	return [candidate.on, candidate.pause, candidate.resume, candidate.destroy].every(fn => typeof fn === 'function');
 }
 
 export function isReadableBufferedStream<T>(obj: unknown): obj is ReadableBufferedStream<T> {
-	const candidate = obj as ReadableBufferedStream<T>;
+	const candidate = obj as ReadableBufferedStream<T> | undefined;
+	if (!candidate) {
+		return false;
+	}
 
-	return candidate && isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
+	return isReadableStream(candidate.stream) && Array.isArray(candidate.buffer) && typeof candidate.ended === 'boolean';
 }
 
 export interface IReducer<T> {
@@ -625,6 +631,16 @@ export function toStream<T>(t: T, reducer: IReducer<T>): ReadableStream<T> {
 	return stream;
 }
 
+/**
+ * Helper to create an empty stream
+ */
+export function emptyStream(): ReadableStream<never> {
+	const stream = newWriteableStream<never>(() => { throw new Error('not supported'); });
+	stream.end();
+
+	return stream;
+}
+
 /**
  * Helper to convert a T into a Readable<T>.
  */
@@ -658,3 +674,71 @@ export function transform<Original, Transformed>(stream: ReadableStreamEvents<Or
 
 	return target;
 }
+
+/**
+ * Helper to take an existing readable that will
+ * have a prefix injected to the beginning.
+ */
+export function prefixedReadable<T>(prefix: T, readable: Readable<T>, reducer: IReducer<T>): Readable<T> {
+	let prefixHandled = false;
+
+	return {
+		read: () => {
+			const chunk = readable.read();
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				// If we have also a read-result, make
+				// sure to reduce it to a single result
+				if (chunk !== null) {
+					return reducer([prefix, chunk]);
+				}
+
+				// Otherwise, just return prefix directly
+				return prefix;
+			}
+
+			return chunk;
+		}
+	};
+}
+
+/**
+ * Helper to take an existing stream that will
+ * have a prefix injected to the beginning.
+ */
+export function prefixedStream<T>(prefix: T, stream: ReadableStream<T>, reducer: IReducer<T>): ReadableStream<T> {
+	let prefixHandled = false;
+
+	const target = newWriteableStream<T>(reducer);
+
+	listenStream(stream, {
+		onData: data => {
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				return target.write(reducer([prefix, data]));
+			}
+
+			return target.write(data);
+		},
+		onError: error => target.error(error),
+		onEnd: () => {
+
+			// Handle prefix only once
+			if (!prefixHandled) {
+				prefixHandled = true;
+
+				target.write(prefix);
+			}
+
+			target.end();
+		}
+	});
+
+	return target;
+}