Rewriting Project

1 files changed, 207 insertions, 0 deletions

diff --git a/node_modules/core-js/modules/esnext.observable.js b/node_modules/core-js/modules/esnext.observable.js
new file mode 100644
index 0000000..edc52b8
--- /dev/null
+++ b/node_modules/core-js/modules/esnext.observable.js
@@ -0,0 +1,207 @@
+'use strict';
+// https://github.com/tc39/proposal-observable
+var $ = require('../internals/export');
+var DESCRIPTORS = require('../internals/descriptors');
+var setSpecies = require('../internals/set-species');
+var aFunction = require('../internals/a-function');
+var anObject = require('../internals/an-object');
+var isObject = require('../internals/is-object');
+var anInstance = require('../internals/an-instance');
+var defineProperty = require('../internals/object-define-property').f;
+var createNonEnumerableProperty = require('../internals/create-non-enumerable-property');
+var redefineAll = require('../internals/redefine-all');
+var getIterator = require('../internals/get-iterator');
+var iterate = require('../internals/iterate');
+var hostReportErrors = require('../internals/host-report-errors');
+var wellKnownSymbol = require('../internals/well-known-symbol');
+var InternalStateModule = require('../internals/internal-state');
+
+var OBSERVABLE = wellKnownSymbol('observable');
+var getInternalState = InternalStateModule.get;
+var setInternalState = InternalStateModule.set;
+
+var getMethod = function (fn) {
+  return fn == null ? undefined : aFunction(fn);
+};
+
+var cleanupSubscription = function (subscriptionState) {
+  var cleanup = subscriptionState.cleanup;
+  if (cleanup) {
+    subscriptionState.cleanup = undefined;
+    try {
+      cleanup();
+    } catch (error) {
+      hostReportErrors(error);
+    }
+  }
+};
+
+var subscriptionClosed = function (subscriptionState) {
+  return subscriptionState.observer === undefined;
+};
+
+var close = function (subscription, subscriptionState) {
+  if (!DESCRIPTORS) {
+    subscription.closed = true;
+    var subscriptionObserver = subscriptionState.subscriptionObserver;
+    if (subscriptionObserver) subscriptionObserver.closed = true;
+  } subscriptionState.observer = undefined;
+};
+
+var Subscription = function (observer, subscriber) {
+  var subscriptionState = setInternalState(this, {
+    cleanup: undefined,
+    observer: anObject(observer),
+    subscriptionObserver: undefined
+  });
+  var start;
+  if (!DESCRIPTORS) this.closed = false;
+  try {
+    if (start = getMethod(observer.start)) start.call(observer, this);
+  } catch (error) {
+    hostReportErrors(error);
+  }
+  if (subscriptionClosed(subscriptionState)) return;
+  var subscriptionObserver = subscriptionState.subscriptionObserver = new SubscriptionObserver(this);
+  try {
+    var cleanup = subscriber(subscriptionObserver);
+    var subscription = cleanup;
+    if (cleanup != null) subscriptionState.cleanup = typeof cleanup.unsubscribe === 'function'
+      ? function () { subscription.unsubscribe(); }
+      : aFunction(cleanup);
+  } catch (error) {
+    subscriptionObserver.error(error);
+    return;
+  } if (subscriptionClosed(subscriptionState)) cleanupSubscription(subscriptionState);
+};
+
+Subscription.prototype = redefineAll({}, {
+  unsubscribe: function unsubscribe() {
+    var subscriptionState = getInternalState(this);
+    if (!subscriptionClosed(subscriptionState)) {
+      close(this, subscriptionState);
+      cleanupSubscription(subscriptionState);
+    }
+  }
+});
+
+if (DESCRIPTORS) defineProperty(Subscription.prototype, 'closed', {
+  configurable: true,
+  get: function () {
+    return subscriptionClosed(getInternalState(this));
+  }
+});
+
+var SubscriptionObserver = function (subscription) {
+  setInternalState(this, { subscription: subscription });
+  if (!DESCRIPTORS) this.closed = false;
+};
+
+SubscriptionObserver.prototype = redefineAll({}, {
+  next: function next(value) {
+    var subscriptionState = getInternalState(getInternalState(this).subscription);
+    if (!subscriptionClosed(subscriptionState)) {
+      var observer = subscriptionState.observer;
+      try {
+        var nextMethod = getMethod(observer.next);
+        if (nextMethod) nextMethod.call(observer, value);
+      } catch (error) {
+        hostReportErrors(error);
+      }
+    }
+  },
+  error: function error(value) {
+    var subscription = getInternalState(this).subscription;
+    var subscriptionState = getInternalState(subscription);
+    if (!subscriptionClosed(subscriptionState)) {
+      var observer = subscriptionState.observer;
+      close(subscription, subscriptionState);
+      try {
+        var errorMethod = getMethod(observer.error);
+        if (errorMethod) errorMethod.call(observer, value);
+        else hostReportErrors(value);
+      } catch (err) {
+        hostReportErrors(err);
+      } cleanupSubscription(subscriptionState);
+    }
+  },
+  complete: function complete() {
+    var subscription = getInternalState(this).subscription;
+    var subscriptionState = getInternalState(subscription);
+    if (!subscriptionClosed(subscriptionState)) {
+      var observer = subscriptionState.observer;
+      close(subscription, subscriptionState);
+      try {
+        var completeMethod = getMethod(observer.complete);
+        if (completeMethod) completeMethod.call(observer);
+      } catch (error) {
+        hostReportErrors(error);
+      } cleanupSubscription(subscriptionState);
+    }
+  }
+});
+
+if (DESCRIPTORS) defineProperty(SubscriptionObserver.prototype, 'closed', {
+  configurable: true,
+  get: function () {
+    return subscriptionClosed(getInternalState(getInternalState(this).subscription));
+  }
+});
+
+var $Observable = function Observable(subscriber) {
+  anInstance(this, $Observable, 'Observable');
+  setInternalState(this, { subscriber: aFunction(subscriber) });
+};
+
+redefineAll($Observable.prototype, {
+  subscribe: function subscribe(observer) {
+    var length = arguments.length;
+    return new Subscription(typeof observer === 'function' ? {
+      next: observer,
+      error: length > 1 ? arguments[1] : undefined,
+      complete: length > 2 ? arguments[2] : undefined
+    } : isObject(observer) ? observer : {}, getInternalState(this).subscriber);
+  }
+});
+
+redefineAll($Observable, {
+  from: function from(x) {
+    var C = typeof this === 'function' ? this : $Observable;
+    var observableMethod = getMethod(anObject(x)[OBSERVABLE]);
+    if (observableMethod) {
+      var observable = anObject(observableMethod.call(x));
+      return observable.constructor === C ? observable : new C(function (observer) {
+        return observable.subscribe(observer);
+      });
+    }
+    var iterator = getIterator(x);
+    return new C(function (observer) {
+      iterate(iterator, function (it, stop) {
+        observer.next(it);
+        if (observer.closed) return stop();
+      }, { IS_ITERATOR: true, INTERRUPTED: true });
+      observer.complete();
+    });
+  },
+  of: function of() {
+    var C = typeof this === 'function' ? this : $Observable;
+    var length = arguments.length;
+    var items = new Array(length);
+    var index = 0;
+    while (index < length) items[index] = arguments[index++];
+    return new C(function (observer) {
+      for (var i = 0; i < length; i++) {
+        observer.next(items[i]);
+        if (observer.closed) return;
+      } observer.complete();
+    });
+  }
+});
+
+createNonEnumerableProperty($Observable.prototype, OBSERVABLE, function () { return this; });
+
+$({ global: true }, {
+  Observable: $Observable
+});
+
+setSpecies('Observable');