proxies to be instanceof Observable

fix #6

src/core/proxy.ts

@@ -14,6 +14,9 @@ export function coreProxy<O>(o: Observable<O>, ps: Path = [], getOverride?: (ps:
   const proxyForPropertyCache = new Map<keyof O, ObservableProxy<O[keyof O]>>();
 
   return (new Proxy(noop, {
+    getPrototypeOf: function () {
+      return Observable.prototype;
+    },
     // call result = O.fn in Observable<O>
     // and make it Observable<result>
     apply(_, __, argumentsList) {

tests/observable.test.ts

@@ -1,4 +1,4 @@
-import { isObservable, of, Subscription } from 'rxjs';
+import { combineLatest, from, isObservable, Observable, of, Subscription } from 'rxjs';
 import { filter, map, scan } from 'rxjs/operators';
 import { proxify } from '../src';
 import { createTestObserver, TestObserver } from './helpers';
@@ -24,6 +24,27 @@ describe('Proxify', () => {
       expect(isObservable(p)).toBe(true);
     });
 
+    test('should be instance of Observable', () => {
+      const o = of(1);
+      const p = proxify(o);
+      expect(p instanceof Observable).toBe(true);
+    });
+
+    test('should still behave as an Observable even after applying from', () => {
+      const o = of(1);
+      const p = proxify(o);
+      const o2 = from(p);
+      sub = o2.subscribe(observer);
+      expect(observer.next.mock.calls).toEqual([[1]]);
+    });
+
+    test('should be combinable with other Observables', () => {
+      const a = proxify(of('a'));
+      const b = of('b');
+      sub = combineLatest([a, b]).subscribe(observer);
+      expect(observer.next.mock.calls).toEqual([[['a', 'b']]]);
+    });
+
     test('directly applying operator', () => {
       const o = of(1, 2, 3);
       const p = proxify(o);