hunk.code_window:  * as an {@link ObservableInput} source.
    */
   export interface ReadableStreamLike<T> {
     getReader(): ReadableStreamDefaultReaderLike<T>;
   }
  
hunk.labels: keep keep keep keep add
hunk.after_edit: /**
    * An observable with a `connect` method that is used to create a subscription
    * to an underlying source, connecting it with all consumers via a multicast.
    */
   export interface Connectable<T> extends Observable<T> {
     /**
      * (Idempotent) Calling this method will connect the underlying source observable to all subscribed consumers
      * through an underlying {@link Subject}.
      * @returns A subscription, that when unsubscribed, will "disconnect" the source from the connector subject,
      * severing notifications to all consumers.
      */
     connect(): Subscription;
   }
hunk.file_path: src/internal/types.ts
hunk.type: add
file: import { expect } from 'chai';
  import { UnsubscriptionError, Observable, timer, merge } from 'rxjs';
  
  /** @test {UnsubscriptionError} */
  describe('UnsubscriptionError', () => {
    it('should create a message that is a clear indication of its internal errors', () => {
      const err1 = new Error('Swiss cheese tastes amazing but smells like socks');
      const err2 = new Error('User too big to fit in tiny European elevator');
      const source1 = new Observable(() => () => { throw err1; });
      const source2 = timer(1000);
      const source3 = new Observable(() => () => { throw err2; });
      const source = merge(source1, source2, source3);
  
      const subscription = source.subscribe();
  
      try {
        subscription.unsubscribe();
      } catch (err) {
        expect(err instanceof UnsubscriptionError).to.equal(true);
        expect(err.errors).to.deep.equal([err1, err2]);
        expect(err.name).to.equal('UnsubscriptionError');
        expect(err.stack).to.be.a('string');
      }
    });
  });
  