Every new change

node_modules/rxjs/src/AsyncSubject.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/AsyncSubject';

node_modules/rxjs/src/BehaviorSubject.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/BehaviorSubject';

node_modules/rxjs/src/InnerSubscriber.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/InnerSubscriber';

node_modules/rxjs/src/LICENSE.txt

@@ -0,0 +1,202 @@
+                               Apache License
+                         Version 2.0, January 2004
+                      http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+        Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+        stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+        that You distribute, all copyright, patent, trademark, and
+        attribution notices from the Source form of the Work,
+        excluding those notices that do not pertain to any part of
+        the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+        distribution, then any Derivative Works that You distribute must
+        include a readable copy of the attribution notices contained
+        within such NOTICE file, excluding those notices that do not
+        pertain to any part of the Derivative Works, in at least one
+        of the following places: within a NOTICE text file distributed
+        as part of the Derivative Works; within the Source form or
+        documentation, if provided along with the Derivative Works; or,
+        within a display generated by the Derivative Works, if and
+        wherever such third-party notices normally appear. The contents
+        of the NOTICE file are for informational purposes only and
+        do not modify the License. You may add Your own attribution
+        notices within Derivative Works that You distribute, alongside
+        or as an addendum to the NOTICE text from the Work, provided
+        that such additional attribution notices cannot be construed
+        as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+    To apply the Apache License to your work, attach the following
+    boilerplate notice, with the fields enclosed by brackets "[]"
+    replaced with your own identifying information. (Don't include
+    the brackets!)  The text should be enclosed in the appropriate
+    comment syntax for the file format. We also recommend that a
+    file or class name and description of purpose be included on the
+    same "printed page" as the copyright notice for easier
+    identification within third-party archives.
+
+ Copyright (c) 2015-2018 Google, Inc., Netflix, Inc., Microsoft Corp. and contributors
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ 

node_modules/rxjs/src/MiscJSDoc.ts

@@ -0,0 +1,451 @@
+/*
+ * This file and its definitions are needed just so that ESDoc sees these
+ * JSDoc documentation comments. Originally they were meant for some TypeScript
+ * interfaces, but TypeScript strips away JSDoc comments near interfaces. Hence,
+ * we need these bogus classes, which are not stripped away. This file on the
+ * other hand, is not included in the release bundle.
+ */
+import { Observer, TeardownLogic } from './internal/types';
+import { Observable } from './internal/Observable';
+import './internal/observable/dom/MiscJSDoc';
+
+/**
+ * We need this JSDoc comment for affecting ESDoc.
+ * @extends {Ignored}
+ * @hide true
+ */
+export class ObservableDoc {
+  /**
+   * Creates a new Observable, that will execute the specified function when an
+   * {@link Observer} subscribes to it.
+   *
+   * <span class="informal">Create custom Observable, that does whatever you like.</span>
+   *
+   * ![](create.png)
+   *
+   * `create` converts an `onSubscription` function to an actual Observable.
+   * Whenever someone subscribes to that Observable, the function will be called
+   * with an {@link Observer} instance as a first and only parameter. `onSubscription` should
+   * then invoke the Observers `next`, `error` and `complete` methods.
+   *
+   * Calling `next` with a value will emit that value to the observer. Calling `complete`
+   * means that Observable finished emitting and will not do anything else.
+   * Calling `error` means that something went wrong - value passed to `error` method should
+   * provide details on what exactly happened.
+   *
+   * A well-formed Observable can emit as many values as it needs via `next` method,
+   * but `complete` and `error` methods can be called only once and nothing else can be called
+   * thereafter. If you try to invoke `next`, `complete` or `error` methods after created
+   * Observable already completed or ended with an error, these calls will be ignored to
+   * preserve so called *Observable Contract*. Note that you are not required to call
+   * `complete` at any point - it is perfectly fine to create an Observable that never ends,
+   * depending on your needs.
+   *
+   * `onSubscription` can optionally return either a function or an object with
+   * `unsubscribe` method. In both cases function or method will be called when
+   * subscription to Observable is being cancelled and should be used to clean up all
+   * resources. So, for example, if you are using `setTimeout` in your custom
+   * Observable, when someone unsubscribes, you can clear planned timeout, so that
+   * it does not fire needlessly and browser (or other environment) does not waste
+   * computing power on timing event that no one will listen to anyways.
+   *
+   * Most of the times you should not need to use `create`, because existing
+   * operators allow you to create an Observable for most of the use cases.
+   * That being said, `create` is low-level mechanism allowing you to create
+   * any Observable, if you have very specific needs.
+   *
+   * **TypeScript signature issue**
+   *
+   * Because Observable extends class which already has defined static `create` function,
+   * but with different type signature, it was impossible to assign proper signature to
+   * `Observable.create`. Because of that, it has very general type `Function` and thus
+   * function passed to `create` will not be type checked, unless you explicitly state
+   * what signature it should have.
+   *
+   * When using TypeScript we recommend to declare type signature of function passed to
+   * `create` as `(observer: Observer) => TeardownLogic`, where {@link Observer}
+   * and {@link TeardownLogic} are interfaces provided by the library.
+   *
+   * @example <caption>Emit three numbers, then complete.</caption>
+   * var observable = Rx.Observable.create(function (observer) {
+   *   observer.next(1);
+   *   observer.next(2);
+   *   observer.next(3);
+   *   observer.complete();
+   * });
+   * observable.subscribe(
+   *   value => console.log(value),
+   *   err => {},
+   *   () => console.log('this is the end')
+   * );
+   *
+   * // Logs
+   * // 1
+   * // 2
+   * // 3
+   * // "this is the end"
+   *
+   *
+   * @example <caption>Emit an error</caption>
+   * const observable = Rx.Observable.create((observer) => {
+   *   observer.error('something went really wrong...');
+   * });
+   *
+   * observable.subscribe(
+   *   value => console.log(value), // will never be called
+   *   err => console.log(err),
+   *   () => console.log('complete') // will never be called
+   * );
+   *
+   * // Logs
+   * // "something went really wrong..."
+   *
+   *
+   * @example <caption>Return unsubscribe function</caption>
+   *
+   * const observable = Rx.Observable.create(observer => {
+   *   const id = setTimeout(() => observer.next('...'), 5000); // emit value after 5s
+   *
+   *   return () => { clearTimeout(id); console.log('cleared!'); };
+   * });
+   *
+   * const subscription = observable.subscribe(value => console.log(value));
+   *
+   * setTimeout(() => subscription.unsubscribe(), 3000); // cancel subscription after 3s
+   *
+   * // Logs:
+   * // "cleared!" after 3s
+   *
+   * // Never logs "..."
+   *
+   *
+   * @see {@link empty}
+   * @see {@link never}
+   * @see {@link of}
+   * @see {@link throw}
+   *
+   * @param {function(observer: Observer): TeardownLogic} onSubscription A
+   * function that accepts an Observer, and invokes its `next`,
+   * `error`, and `complete` methods as appropriate, and optionally returns some
+   * logic for cleaning up resources.
+   * @return {Observable} An Observable that, whenever subscribed, will execute the
+   * specified function.
+   * @static true
+   * @name create
+   * @owner Observable
+   * @nocollapse
+   */
+  static create<T>(onSubscription: <R>(observer: Observer<R>) => TeardownLogic): Observable<T> {
+    return new Observable<T>(onSubscription);
+  }
+}
+
+/**
+ * An interface for a consumer of push-based notifications delivered by an
+ * {@link Observable}.
+ *
+ * ```ts
+ * interface Observer<T> {
+ *   closed?: boolean;
+ *   next: (value: T) => void;
+ *   error: (err: any) => void;
+ *   complete: () => void;
+ * }
+ * ```
+ *
+ * An object conforming to the Observer interface is usually
+ * given to the `observable.subscribe(observer)` method, and the Observable will
+ * call the Observer's `next(value)` method to provide notifications. A
+ * well-behaved Observable will call an Observer's `complete()` method exactly
+ * once or the Observer's `error(err)` method exactly once, as the last
+ * notification delivered.
+ *
+ * @interface
+ * @name Observer
+ * @noimport true
+ */
+export class ObserverDoc<T> {
+  /**
+   * An optional flag to indicate whether this Observer, when used as a
+   * subscriber, has already been unsubscribed from its Observable.
+   * @type {boolean}
+   */
+  closed: boolean = false;
+  /**
+   * The callback to receive notifications of type `next` from the Observable,
+   * with a value. The Observable may call this method 0 or more times.
+   * @param {T} value The `next` value.
+   * @return {void}
+   */
+  next(value: T): void {
+    return void 0;
+  }
+  /**
+   * The callback to receive notifications of type `error` from the Observable,
+   * with an attached {@link Error}. Notifies the Observer that the Observable
+   * has experienced an error condition.
+   * @param {any} err The `error` exception.
+   * @return {void}
+   */
+  error(err: any): void {
+    return void 0;
+  }
+  /**
+   * The callback to receive a valueless notification of type `complete` from
+   * the Observable. Notifies the Observer that the Observable has finished
+   * sending push-based notifications.
+   * @return {void}
+   */
+  complete(): void {
+    return void 0;
+  }
+}
+
+/**
+ * `SubscribableOrPromise` interface describes values that behave like either
+ * Observables or Promises. Every operator that accepts arguments annotated
+ * with this interface, can be also used with parameters that are not necessarily
+ * RxJS Observables.
+ *
+ * Following types of values might be passed to operators expecting this interface:
+ *
+ * ## Observable
+ *
+ * RxJS {@link Observable} instance.
+ *
+ * ## Observable-like (Subscribable)
+ *
+ * This might be any object that has `Symbol.observable` method. This method,
+ * when called, should return object with `subscribe` method on it, which should
+ * behave the same as RxJS `Observable.subscribe`.
+ *
+ * `Symbol.observable` is part of https://github.com/tc39/proposal-observable proposal.
+ * Since currently it is not supported natively, and every symbol is equal only to itself,
+ * you should use https://github.com/blesh/symbol-observable polyfill, when implementing
+ * custom Observable-likes.
+ *
+ * **TypeScript Subscribable interface issue**
+ *
+ * Although TypeScript interface claims that Subscribable is an object that has `subscribe`
+ * method declared directly on it, passing custom objects that have `subscribe`
+ * method but not `Symbol.observable` method will fail at runtime. Conversely, passing
+ * objects with `Symbol.observable` but without `subscribe` will fail at compile time
+ * (if you use TypeScript).
+ *
+ * TypeScript has problem supporting interfaces with methods defined as symbol
+ * properties. To get around that, you should implement `subscribe` directly on
+ * passed object, and make `Symbol.observable` method simply return `this`. That way
+ * everything will work as expected, and compiler will not complain. If you really
+ * do not want to put `subscribe` directly on your object, you will have to type cast
+ * it to `any`, before passing it to an operator.
+ *
+ * When this issue is resolved, Subscribable interface will only permit Observable-like
+ * objects with `Symbol.observable` defined, no matter if they themselves implement
+ * `subscribe` method or not.
+ *
+ * ## ES6 Promise
+ *
+ * Promise can be interpreted as Observable that emits value and completes
+ * when it is resolved or errors when it is rejected.
+ *
+ * ## Promise-like (Thenable)
+ *
+ * Promises passed to operators do not have to be native ES6 Promises.
+ * They can be implementations from popular Promise libraries, polyfills
+ * or even custom ones. They just need to have `then` method that works
+ * as the same as ES6 Promise `then`.
+ *
+ * @example <caption>Use merge and then map with non-RxJS observable</caption>
+ * const nonRxJSObservable = {
+ *   subscribe(observer) {
+ *     observer.next(1000);
+ *     observer.complete();
+ *   },
+ *   [Symbol.observable]() {
+ *     return this;
+ *   }
+ * };
+ *
+ * Rx.Observable.merge(nonRxJSObservable)
+ * .map(value => "This value is " + value)
+ * .subscribe(result => console.log(result)); // Logs "This value is 1000"
+ *
+ *
+ * @example <caption>Use combineLatest with ES6 Promise</caption>
+ * Rx.Observable.combineLatest(Promise.resolve(5), Promise.resolve(10), Promise.resolve(15))
+ * .subscribe(
+ *   value => console.log(value),
+ *   err => {},
+ *   () => console.log('the end!')
+ * );
+ * // Logs
+ * // [5, 10, 15]
+ * // "the end!"
+ *
+ *
+ * @interface
+ * @name SubscribableOrPromise
+ * @noimport true
+ */
+export class SubscribableOrPromiseDoc<T> {
+
+}
+
+/**
+ * `ObservableInput` interface describes all values that are either an
+ * {@link SubscribableOrPromise} or some kind of collection of values that
+ * can be transformed to Observable emitting that values. Every operator that
+ * accepts arguments annotated with this interface, can be also used with
+ * parameters that are not necessarily RxJS Observables.
+ *
+ * `ObservableInput` extends {@link SubscribableOrPromise} with following types:
+ *
+ * ## Array
+ *
+ * Arrays can be interpreted as observables that emit all values in array one by one,
+ * from left to right, and then complete immediately.
+ *
+ * ## Array-like
+ *
+ * Arrays passed to operators do not have to be built-in JavaScript Arrays. They
+ * can be also, for example, `arguments` property available inside every function,
+ * [DOM NodeList](https://developer.mozilla.org/pl/docs/Web/API/NodeList),
+ * or, actually, any object that has `length` property (which is a number)
+ * and stores values under non-negative (zero and up) integers.
+ *
+ * ## ES6 Iterable
+ *
+ * Operators will accept both built-in and custom ES6 Iterables, by treating them as
+ * observables that emit all its values in order of iteration and then complete
+ * when iteration ends. Note that contrary to arrays, Iterables do not have to
+ * necessarily be finite, so creating Observables that never complete is possible as well.
+ *
+ * Note that you can make iterator an instance of Iterable by having it return itself
+ * in `Symbol.iterator` method. It means that every operator accepting Iterables accepts,
+ * though indirectly, iterators themselves as well. All native ES6 iterators are instances
+ * of Iterable by default, so you do not have to implement their `Symbol.iterator` method
+ * yourself.
+ *
+ * **TypeScript Iterable interface issue**
+ *
+ * TypeScript `ObservableInput` interface actually lacks type signature for Iterables,
+ * because of issues it caused in some projects (see [this issue](https://github.com/ReactiveX/rxjs/issues/2306)).
+ * If you want to use Iterable as argument for operator, cast it to `any` first.
+ * Remember of course that, because of casting, you have to yourself ensure that passed
+ * argument really implements said interface.
+ *
+ *
+ * @example <caption>Use merge with arrays</caption>
+ * Rx.Observable.merge([1, 2], [4], [5, 6])
+ * .subscribe(
+ *   value => console.log(value),
+ *   err => {},
+ *   () => console.log('ta dam!')
+ * );
+ *
+ * // Logs
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * // 6
+ * // "ta dam!"
+ *
+ *
+ * @example <caption>Use merge with array-like</caption>
+ * Rx.Observable.merge({0: 1, 1: 2, length: 2}, {0: 3, length: 1})
+ * .subscribe(
+ *   value => console.log(value),
+ *   err => {},
+ *   () => console.log('nice, huh?')
+ * );
+ *
+ * // Logs
+ * // 1
+ * // 2
+ * // 3
+ * // "nice, huh?"
+ *
+ * @example <caption>Use merge with an Iterable (Map)</caption>
+ * const firstMap = new Map([[1, 'a'], [2, 'b']]);
+ * const secondMap = new Map([[3, 'c'], [4, 'd']]);
+ *
+ * Rx.Observable.merge(
+ *   firstMap,          // pass Iterable
+ *   secondMap.values() // pass iterator, which is itself an Iterable
+ * ).subscribe(
+ *   value => console.log(value),
+ *   err => {},
+ *   () => console.log('yup!')
+ * );
+ *
+ * // Logs
+ * // [1, "a"]
+ * // [2, "b"]
+ * // "c"
+ * // "d"
+ * // "yup!"
+ *
+ * @example <caption>Use from with generator (returning infinite iterator)</caption>
+ * // infinite stream of incrementing numbers
+ * const infinite = function* () {
+ *   let i = 0;
+ *
+ *   while (true) {
+ *     yield i++;
+ *   }
+ * };
+ *
+ * Rx.Observable.from(infinite())
+ * .take(3) // only take 3, cause this is infinite
+ * .subscribe(
+ *   value => console.log(value),
+ *   err => {},
+ *   () => console.log('ta dam!')
+ * );
+ *
+ * // Logs
+ * // 0
+ * // 1
+ * // 2
+ * // "ta dam!"
+ *
+ * @interface
+ * @name ObservableInput
+ * @noimport true
+ */
+export class ObservableInputDoc<T> {
+
+}
+
+/**
+ *
+ * This interface describes what should be returned by function passed to Observable
+ * constructor or static {@link create} function. Value of that interface will be used
+ * to cancel subscription for given Observable.
+ *
+ * `TeardownLogic` can be:
+ *
+ * ## Function
+ *
+ * Function that takes no parameters. When consumer of created Observable calls `unsubscribe`,
+ * that function will be called
+ *
+ * ## AnonymousSubscription
+ *
+ * `AnonymousSubscription` is simply an object with `unsubscribe` method on it. That method
+ * will work the same as function
+ *
+ * ## void
+ *
+ * If created Observable does not have any resources to clean up, function does not have to
+ * return anything.
+ *
+ * @interface
+ * @name TeardownLogic
+ * @noimport true
+ */
+export class TeardownLogicDoc {
+
+}

node_modules/rxjs/src/Notification.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Notification';

node_modules/rxjs/src/Observable.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Observable';

node_modules/rxjs/src/Observer.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Observer';

node_modules/rxjs/src/Operator.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Operator';

node_modules/rxjs/src/OuterSubscriber.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/OuterSubscriber';

node_modules/rxjs/src/README.md

@@ -0,0 +1,145 @@
+<img src="doc/asset/Rx_Logo_S.png" alt="RxJS Logo" width="86" height="86"> RxJS: Reactive Extensions For JavaScript
+======================================
+
+
+[![CircleCI](https://circleci.com/gh/ReactiveX/rxjs/tree/6.x.svg?style=svg)](https://circleci.com/gh/ReactiveX/rxjs/tree/6.x)
+[![npm version](https://badge.fury.io/js/%40reactivex%2Frxjs.svg)](http://badge.fury.io/js/%40reactivex%2Frxjs)
+[![Join the chat at https://gitter.im/Reactive-Extensions/RxJS](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/Reactive-Extensions/RxJS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+
+# RxJS 6 Stable
+
+### MIGRATION AND RELEASE INFORMATION:
+
+Find out how to update to v6, **automatically update your TypeScript code**, and more!
+
+- [Current home is MIGRATION.md](./docs_app/content/guide/v6/migration.md)
+
+### FOR V 5.X PLEASE GO TO [THE 5.0 BRANCH](https://github.com/ReactiveX/rxjs/tree/5.x)
+
+Reactive Extensions Library for JavaScript. This is a rewrite of [Reactive-Extensions/RxJS](https://github.com/Reactive-Extensions/RxJS) and is the latest production-ready version of RxJS. This rewrite is meant to have better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface.
+
+[Apache 2.0 License](LICENSE.txt)
+
+- [Code of Conduct](CODE_OF_CONDUCT.md)
+- [Contribution Guidelines](CONTRIBUTING.md)
+- [Maintainer Guidelines](doc/maintainer-guidelines.md)
+- [Creating Operators](doc/operator-creation.md)
+- [API Documentation (WIP)](https://rxjs.dev/)
+
+## Versions In This Repository
+
+- [master](https://github.com/ReactiveX/rxjs/commits/master) - This is all of the current, unreleased work, which is against v6 of RxJS right now
+- [stable](https://github.com/ReactiveX/rxjs/commits/stable) - This is the branch for the latest version you'd get if you do `npm install rxjs`
+
+## Important
+
+By contributing or commenting on issues in this repository, whether you've read them or not, you're agreeing to the [Contributor Code of Conduct](CODE_OF_CONDUCT.md). Much like traffic laws, ignorance doesn't grant you immunity.
+
+## Installation and Usage
+
+### ES6 via npm
+
+```sh
+npm install rxjs
+```
+
+It's recommended to pull in the Observable creation methods you need directly from `'rxjs'` as shown below with `range`. And you can pull in any operator you need from one spot, under `'rxjs/operators'`.
+
+```js
+import { range } from 'rxjs';
+import { map, filter } from 'rxjs/operators';
+
+range(1, 200).pipe(
+  filter(x => x % 2 === 1),
+  map(x => x + x)
+).subscribe(x => console.log(x));
+```
+
+Here, we're using the built-in `pipe` method on Observables to combine operators. See [pipeable operators](https://github.com/ReactiveX/rxjs/blob/master/doc/pipeable-operators.md) for more information.
+
+### CommonJS via npm
+
+To install this library for CommonJS (CJS) usage, use the following command:
+
+```sh
+npm install rxjs
+```
+
+(Note: destructuring available in Node 8+)
+
+```js
+const { range } = require('rxjs');
+const { map, filter } = require('rxjs/operators');
+
+range(1, 200).pipe(
+  filter(x => x % 2 === 1),
+  map(x => x + x)
+).subscribe(x => console.log(x));
+```
+
+### CDN
+
+For CDN, you can use [unpkg](https://unpkg.com/):
+
+https://unpkg.com/rxjs/bundles/rxjs.umd.min.js
+
+The global namespace for rxjs is `rxjs`:
+
+```js
+const { range } = rxjs;
+const { map, filter } = rxjs.operators;
+
+range(1, 200).pipe(
+  filter(x => x % 2 === 1),
+  map(x => x + x)
+).subscribe(x => console.log(x));
+```
+
+## Goals
+
+- Smaller overall bundles sizes
+- Provide better performance than preceding versions of RxJS
+- To model/follow the [Observable Spec Proposal](https://github.com/zenparsing/es-observable) to the observable
+- Provide more modular file structure in a variety of formats
+- Provide more debuggable call stacks than preceding versions of RxJS
+
+## Building/Testing
+
+- `npm run build_all` - builds everything
+- `npm test` - runs tests
+- `npm run test_no_cache` - run test with `ts-node` set to false
+
+## Performance Tests
+
+Run `npm run build_perf` or `npm run perf` to run the performance tests with `protractor`.
+
+Run `npm run perf_micro [operator]` to run micro performance test benchmarking operator.
+
+## Adding documentation
+We appreciate all contributions to the documentation of any type. All of the information needed to get the docs app up and running locally as well as how to contribute can be found in the [documentation directory](./docs_app).
+
+## Generating PNG marble diagrams
+
+The script `npm run tests2png` requires some native packages installed locally: `imagemagick`, `graphicsmagick`, and `ghostscript`.
+
+For Mac OS X with [Homebrew](http://brew.sh/):
+
+- `brew install imagemagick`
+- `brew install graphicsmagick`
+- `brew install ghostscript`
+- You may need to install the Ghostscript fonts manually:
+  - Download the tarball from the [gs-fonts project](https://sourceforge.net/projects/gs-fonts)
+  - `mkdir -p /usr/local/share/ghostscript && tar zxvf /path/to/ghostscript-fonts.tar.gz -C /usr/local/share/ghostscript`
+
+For Debian Linux:
+
+- `sudo add-apt-repository ppa:dhor/myway`
+- `apt-get install imagemagick`
+- `apt-get install graphicsmagick`
+- `apt-get install ghostscript`
+
+For Windows and other Operating Systems, check the download instructions here:
+
+- http://imagemagick.org
+- http://www.graphicsmagick.org
+- http://www.ghostscript.com/

node_modules/rxjs/src/ReplaySubject.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/ReplaySubject';

node_modules/rxjs/src/Rx.global.js

@@ -0,0 +1,5 @@
+(function (root, factory) {
+  root.Rx = factory();
+})(window || global || this, function () {
+  return require('../dist/package/Rx');
+});

node_modules/rxjs/src/Rx.ts

@@ -0,0 +1,2 @@
+
+export * from 'rxjs-compat';

node_modules/rxjs/src/Scheduler.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Scheduler';

node_modules/rxjs/src/Subject.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Subject';

node_modules/rxjs/src/SubjectSubscription.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/SubjectSubscription';

node_modules/rxjs/src/Subscriber.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Subscriber';

node_modules/rxjs/src/Subscription.ts

@@ -0,0 +1 @@
+export * from 'rxjs-compat/Subscription';

node_modules/rxjs/src/add/observable/bindCallback.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/bindCallback';

node_modules/rxjs/src/add/observable/bindNodeCallback.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/bindNodeCallback';

node_modules/rxjs/src/add/observable/combineLatest.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/combineLatest';

node_modules/rxjs/src/add/observable/concat.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/concat';

node_modules/rxjs/src/add/observable/defer.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/defer';

node_modules/rxjs/src/add/observable/dom/ajax.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/dom/ajax';

node_modules/rxjs/src/add/observable/dom/webSocket.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/dom/webSocket';

node_modules/rxjs/src/add/observable/empty.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/empty';

node_modules/rxjs/src/add/observable/forkJoin.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/forkJoin';

node_modules/rxjs/src/add/observable/from.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/from';

node_modules/rxjs/src/add/observable/fromEvent.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/fromEvent';

node_modules/rxjs/src/add/observable/fromEventPattern.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/fromEventPattern';

node_modules/rxjs/src/add/observable/fromPromise.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/fromPromise';

node_modules/rxjs/src/add/observable/generate.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/generate';

node_modules/rxjs/src/add/observable/if.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/if';

node_modules/rxjs/src/add/observable/interval.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/interval';

node_modules/rxjs/src/add/observable/merge.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/merge';

node_modules/rxjs/src/add/observable/never.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/never';

node_modules/rxjs/src/add/observable/of.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/of';

node_modules/rxjs/src/add/observable/onErrorResumeNext.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/onErrorResumeNext';

node_modules/rxjs/src/add/observable/pairs.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/pairs';

node_modules/rxjs/src/add/observable/race.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/race';

node_modules/rxjs/src/add/observable/range.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/range';

node_modules/rxjs/src/add/observable/throw.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/throw';

node_modules/rxjs/src/add/observable/timer.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/timer';

node_modules/rxjs/src/add/observable/using.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/using';

node_modules/rxjs/src/add/observable/zip.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/observable/zip';

node_modules/rxjs/src/add/operator/audit.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/audit';

node_modules/rxjs/src/add/operator/auditTime.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/auditTime';

node_modules/rxjs/src/add/operator/buffer.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/buffer';

node_modules/rxjs/src/add/operator/bufferCount.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/bufferCount';

node_modules/rxjs/src/add/operator/bufferTime.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/bufferTime';

node_modules/rxjs/src/add/operator/bufferToggle.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/bufferToggle';

node_modules/rxjs/src/add/operator/bufferWhen.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/bufferWhen';

node_modules/rxjs/src/add/operator/catch.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/catch';

node_modules/rxjs/src/add/operator/combineAll.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/combineAll';

node_modules/rxjs/src/add/operator/combineLatest.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/combineLatest';

node_modules/rxjs/src/add/operator/concat.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/concat';

node_modules/rxjs/src/add/operator/concatAll.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/concatAll';

node_modules/rxjs/src/add/operator/concatMap.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/concatMap';

node_modules/rxjs/src/add/operator/concatMapTo.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/concatMapTo';

node_modules/rxjs/src/add/operator/count.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/count';

node_modules/rxjs/src/add/operator/debounce.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/debounce';

node_modules/rxjs/src/add/operator/debounceTime.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/debounceTime';

node_modules/rxjs/src/add/operator/defaultIfEmpty.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/defaultIfEmpty';

node_modules/rxjs/src/add/operator/delay.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/delay';

node_modules/rxjs/src/add/operator/delayWhen.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/delayWhen';

node_modules/rxjs/src/add/operator/dematerialize.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/dematerialize';

node_modules/rxjs/src/add/operator/distinct.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/distinct';

node_modules/rxjs/src/add/operator/distinctUntilChanged.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/distinctUntilChanged';

node_modules/rxjs/src/add/operator/distinctUntilKeyChanged.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/distinctUntilKeyChanged';

node_modules/rxjs/src/add/operator/do.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/do';

node_modules/rxjs/src/add/operator/elementAt.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/elementAt';

node_modules/rxjs/src/add/operator/every.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/every';

node_modules/rxjs/src/add/operator/exhaust.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/exhaust';

node_modules/rxjs/src/add/operator/exhaustMap.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/exhaustMap';

node_modules/rxjs/src/add/operator/expand.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/expand';

node_modules/rxjs/src/add/operator/filter.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/filter';

node_modules/rxjs/src/add/operator/finally.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/finally';

node_modules/rxjs/src/add/operator/find.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/find';

node_modules/rxjs/src/add/operator/findIndex.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/findIndex';

node_modules/rxjs/src/add/operator/first.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/first';

node_modules/rxjs/src/add/operator/groupBy.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/groupBy';

node_modules/rxjs/src/add/operator/ignoreElements.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/ignoreElements';

node_modules/rxjs/src/add/operator/isEmpty.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/isEmpty';

node_modules/rxjs/src/add/operator/last.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/last';

node_modules/rxjs/src/add/operator/let.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/let';

node_modules/rxjs/src/add/operator/map.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/map';

node_modules/rxjs/src/add/operator/mapTo.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/mapTo';

node_modules/rxjs/src/add/operator/materialize.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/materialize';

node_modules/rxjs/src/add/operator/max.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/max';

node_modules/rxjs/src/add/operator/merge.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/merge';

node_modules/rxjs/src/add/operator/mergeAll.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/mergeAll';

node_modules/rxjs/src/add/operator/mergeMap.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/mergeMap';

node_modules/rxjs/src/add/operator/mergeMapTo.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/mergeMapTo';

node_modules/rxjs/src/add/operator/mergeScan.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/mergeScan';

node_modules/rxjs/src/add/operator/min.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/min';

node_modules/rxjs/src/add/operator/multicast.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/multicast';

node_modules/rxjs/src/add/operator/observeOn.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/observeOn';

node_modules/rxjs/src/add/operator/onErrorResumeNext.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/onErrorResumeNext';

node_modules/rxjs/src/add/operator/pairwise.ts

@@ -0,0 +1 @@
+import 'rxjs-compat/add/operator/pairwise';