SOURCE

var proxies = new WeakMap();

var observers = new WeakMap();

var queuedObservers = new Set();

var queued;

function observable(obj) {
  return proxies.get(obj) || toObservable(obj);
}

function toObservable(obj) {
  var dynamicObj;
  dynamicObj = new Proxy(obj, {
    get: function(target, key) {
      if (key === '$raw') {
        return target;
      }
      var result = Reflect.get(target, key);
      var resultIsObject = typeof result === 'object' && result
      var existProxy = resultIsObject && proxies.get(result)
    },
    set: function(target, key, value) {
      if (key === 'length' || value !== Reflect.get(target, key)) {
        queueObservers(target, key);
      }

      if (typeof value === 'object' && value) {
        
      }

      return Reflect.set(target, key, value);
    },
    deleteProperty(target, key) {
      if (Reflect.has(target, key)) {
        queueObservers(target, key);
      }
      return Reflect.deleteProperty(target, key);
    }
  });
  console.log(dynamicObj);
  proxies.set(obj, dynamicObj);
  proxies.set(dynamicObj, dynamicObj);

  observers.set(obj, new Map());

  return dynamicObj;
}

function observe(callback) {
  var observer = {
    callback: callback,
    once: false,
    observedKeys: [],
    unqueue: function() {
      unqueue(observer);
    },
    unobserve: function() {
      unobserve(observer);
    }
  };
  queueObserver(observer);
  return observer;
}

function queueObserver(observer) {
  queuedObservers.add(observer);
  if (!queued) {
    queued = true;
    Promise.resolve().then(function() {
      queuedObservers.forEach(function(observer) {
        if (observer.callback) {
          if (observer.once) {
            observer.callback.apply(null, observer.proxies);
            unobserve(observer);
          } else {
            try {
              currentObserver = observer;
              observer.callback.apply(null, observer.proxies);
            } finally {
              currentObserver = null;
            }
          }
        }
      });
      queuedObservers.clear();
      queued = false;
    });
  }
}

function unqueue(observer) {
  queuedObservers.delete(observer);
}

function unobserve(observer) {
  if (typeof observer === 'object') {
    if (observer.observedKeys) {
      observer.observedKeys.forEach(function(observersForKey) {
        observersForKey.delete(observer);
      })
    }
    observer.callback = observer.proxies = observer.observedKeys = undefined;
  }
}

function queueObservers(target, key) {
  var observersForKey = observers.get(target).get(key);
  if (observersForKey) {
    observersForKey.forEach(queueObserver);
  }
}

var obj = observable({
  a: 1
});
console.log(obj)