{"version":3,"names":["isFunction","x","_enable_super_gross_mode_that_will_cause_bad_things","config","Promise","undefined","useDeprecatedSynchronousErrorHandling","value","error","Error","console","warn","stack","log","hostReportError","err","setTimeout","empty","closed","next","complete","isArray","Array","length","isObject","UnsubscriptionErrorImpl","errors","call","this","message","map","i","toString","join","name","prototype","Object","create","UnsubscriptionError","Subscription","constructor","unsubscribe","_parentOrParents","_subscriptions","_ctorUnsubscribe","_unsubscribe","remove","index","parent","e","flattenUnsubscriptionErrors","len","sub","concat","push","add","teardown","subscription","EMPTY","tmp","indexOf","subscriptions","subscriptionIndex","splice","reduce","errs","rxSubscriber","Symbol","Math","random","Subscriber","destinationOrNext","super","syncErrorValue","syncErrorThrown","syncErrorThrowable","isStopped","arguments","destination","emptyObserver","SafeSubscriber","rxSubscriberSymbol","static","subscriber","_next","_error","_complete","_unsubscribeAndRecycle","_parentSubscriber","observerOrNext","context","bind","_context","__tryOrUnsub","__tryOrSetError","wrappedComplete","fn","canReportError","observer","toSubscriber","nextOrObserver","observable","identity","pipeFromArray","fns","piped","input","prev","Observable","subscribe","_isScalar","_subscribe","lift","operator","source","sink","_trySubscribe","forEach","promiseCtor","getPromiseCtor","resolve","reject","Symbol_observable","pipe","operations","toPromise","ObjectUnsubscribedErrorImpl","ObjectUnsubscribedError","SubjectSubscription","subject","observers","subscriberIndex","SubjectSubscriber","Subject","hasError","thrownError","AnonymousSubject","copy","slice","asObservable"],"sources":["./node_modules/rxjs/_esm2015/internal/util/isFunction.js","./node_modules/rxjs/_esm2015/internal/config.js","./node_modules/rxjs/_esm2015/internal/util/hostReportError.js","./node_modules/rxjs/_esm2015/internal/Observer.js","./node_modules/rxjs/_esm2015/internal/util/isArray.js","./node_modules/rxjs/_esm2015/internal/util/isObject.js","./node_modules/rxjs/_esm2015/internal/util/UnsubscriptionError.js","./node_modules/rxjs/_esm2015/internal/Subscription.js","./node_modules/rxjs/_esm2015/internal/symbol/rxSubscriber.js","./node_modules/rxjs/_esm2015/internal/Subscriber.js","./node_modules/rxjs/_esm2015/internal/util/canReportError.js","./node_modules/rxjs/_esm2015/internal/util/toSubscriber.js","./node_modules/rxjs/_esm2015/internal/symbol/observable.js","./node_modules/rxjs/_esm2015/internal/util/identity.js","./node_modules/rxjs/_esm2015/internal/util/pipe.js","./node_modules/rxjs/_esm2015/internal/Observable.js","./node_modules/rxjs/_esm2015/internal/util/ObjectUnsubscribedError.js","./node_modules/rxjs/_esm2015/internal/SubjectSubscription.js","./node_modules/rxjs/_esm2015/internal/Subject.js"],"sourcesContent":["export function isFunction(x) {\n    return typeof x === 'function';\n}\n//# sourceMappingURL=isFunction.js.map","let _enable_super_gross_mode_that_will_cause_bad_things = false;\nexport const config = {\n    Promise: undefined,\n    set useDeprecatedSynchronousErrorHandling(value) {\n        if (value) {\n            const error = new Error();\n            console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \\n' + error.stack);\n        }\n        else if (_enable_super_gross_mode_that_will_cause_bad_things) {\n            console.log('RxJS: Back to a better error behavior. Thank you. <3');\n        }\n        _enable_super_gross_mode_that_will_cause_bad_things = value;\n    },\n    get useDeprecatedSynchronousErrorHandling() {\n        return _enable_super_gross_mode_that_will_cause_bad_things;\n    },\n};\n//# sourceMappingURL=config.js.map","export function hostReportError(err) {\n    setTimeout(() => { throw err; }, 0);\n}\n//# sourceMappingURL=hostReportError.js.map","import { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport const empty = {\n    closed: true,\n    next(value) { },\n    error(err) {\n        if (config.useDeprecatedSynchronousErrorHandling) {\n            throw err;\n        }\n        else {\n            hostReportError(err);\n        }\n    },\n    complete() { }\n};\n//# sourceMappingURL=Observer.js.map","export const isArray = (() => Array.isArray || ((x) => x && typeof x.length === 'number'))();\n//# sourceMappingURL=isArray.js.map","export function isObject(x) {\n    return x !== null && typeof x === 'object';\n}\n//# sourceMappingURL=isObject.js.map","const UnsubscriptionErrorImpl = (() => {\n    function UnsubscriptionErrorImpl(errors) {\n        Error.call(this);\n        this.message = errors ?\n            `${errors.length} errors occurred during unsubscription:\n${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\\n  ')}` : '';\n        this.name = 'UnsubscriptionError';\n        this.errors = errors;\n        return this;\n    }\n    UnsubscriptionErrorImpl.prototype = Object.create(Error.prototype);\n    return UnsubscriptionErrorImpl;\n})();\nexport const UnsubscriptionError = UnsubscriptionErrorImpl;\n//# sourceMappingURL=UnsubscriptionError.js.map","import { isArray } from './util/isArray';\nimport { isObject } from './util/isObject';\nimport { isFunction } from './util/isFunction';\nimport { UnsubscriptionError } from './util/UnsubscriptionError';\nexport class Subscription {\n    constructor(unsubscribe) {\n        this.closed = false;\n        this._parentOrParents = null;\n        this._subscriptions = null;\n        if (unsubscribe) {\n            this._ctorUnsubscribe = true;\n            this._unsubscribe = unsubscribe;\n        }\n    }\n    unsubscribe() {\n        let errors;\n        if (this.closed) {\n            return;\n        }\n        let { _parentOrParents, _ctorUnsubscribe, _unsubscribe, _subscriptions } = this;\n        this.closed = true;\n        this._parentOrParents = null;\n        this._subscriptions = null;\n        if (_parentOrParents instanceof Subscription) {\n            _parentOrParents.remove(this);\n        }\n        else if (_parentOrParents !== null) {\n            for (let index = 0; index < _parentOrParents.length; ++index) {\n                const parent = _parentOrParents[index];\n                parent.remove(this);\n            }\n        }\n        if (isFunction(_unsubscribe)) {\n            if (_ctorUnsubscribe) {\n                this._unsubscribe = undefined;\n            }\n            try {\n                _unsubscribe.call(this);\n            }\n            catch (e) {\n                errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];\n            }\n        }\n        if (isArray(_subscriptions)) {\n            let index = -1;\n            let len = _subscriptions.length;\n            while (++index < len) {\n                const sub = _subscriptions[index];\n                if (isObject(sub)) {\n                    try {\n                        sub.unsubscribe();\n                    }\n                    catch (e) {\n                        errors = errors || [];\n                        if (e instanceof UnsubscriptionError) {\n                            errors = errors.concat(flattenUnsubscriptionErrors(e.errors));\n                        }\n                        else {\n                            errors.push(e);\n                        }\n                    }\n                }\n            }\n        }\n        if (errors) {\n            throw new UnsubscriptionError(errors);\n        }\n    }\n    add(teardown) {\n        let subscription = teardown;\n        if (!teardown) {\n            return Subscription.EMPTY;\n        }\n        switch (typeof teardown) {\n            case 'function':\n                subscription = new Subscription(teardown);\n            case 'object':\n                if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {\n                    return subscription;\n                }\n                else if (this.closed) {\n                    subscription.unsubscribe();\n                    return subscription;\n                }\n                else if (!(subscription instanceof Subscription)) {\n                    const tmp = subscription;\n                    subscription = new Subscription();\n                    subscription._subscriptions = [tmp];\n                }\n                break;\n            default: {\n                throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n            }\n        }\n        let { _parentOrParents } = subscription;\n        if (_parentOrParents === null) {\n            subscription._parentOrParents = this;\n        }\n        else if (_parentOrParents instanceof Subscription) {\n            if (_parentOrParents === this) {\n                return subscription;\n            }\n            subscription._parentOrParents = [_parentOrParents, this];\n        }\n        else if (_parentOrParents.indexOf(this) === -1) {\n            _parentOrParents.push(this);\n        }\n        else {\n            return subscription;\n        }\n        const subscriptions = this._subscriptions;\n        if (subscriptions === null) {\n            this._subscriptions = [subscription];\n        }\n        else {\n            subscriptions.push(subscription);\n        }\n        return subscription;\n    }\n    remove(subscription) {\n        const subscriptions = this._subscriptions;\n        if (subscriptions) {\n            const subscriptionIndex = subscriptions.indexOf(subscription);\n            if (subscriptionIndex !== -1) {\n                subscriptions.splice(subscriptionIndex, 1);\n            }\n        }\n    }\n}\nSubscription.EMPTY = (function (empty) {\n    empty.closed = true;\n    return empty;\n}(new Subscription()));\nfunction flattenUnsubscriptionErrors(errors) {\n    return errors.reduce((errs, err) => errs.concat((err instanceof UnsubscriptionError) ? err.errors : err), []);\n}\n//# sourceMappingURL=Subscription.js.map","export const rxSubscriber = (() => typeof Symbol === 'function'\n    ? Symbol('rxSubscriber')\n    : '@@rxSubscriber_' + Math.random())();\nexport const $$rxSubscriber = rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map","import { isFunction } from './util/isFunction';\nimport { empty as emptyObserver } from './Observer';\nimport { Subscription } from './Subscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nimport { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport class Subscriber extends Subscription {\n    constructor(destinationOrNext, error, complete) {\n        super();\n        this.syncErrorValue = null;\n        this.syncErrorThrown = false;\n        this.syncErrorThrowable = false;\n        this.isStopped = false;\n        switch (arguments.length) {\n            case 0:\n                this.destination = emptyObserver;\n                break;\n            case 1:\n                if (!destinationOrNext) {\n                    this.destination = emptyObserver;\n                    break;\n                }\n                if (typeof destinationOrNext === 'object') {\n                    if (destinationOrNext instanceof Subscriber) {\n                        this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n                        this.destination = destinationOrNext;\n                        destinationOrNext.add(this);\n                    }\n                    else {\n                        this.syncErrorThrowable = true;\n                        this.destination = new SafeSubscriber(this, destinationOrNext);\n                    }\n                    break;\n                }\n            default:\n                this.syncErrorThrowable = true;\n                this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n                break;\n        }\n    }\n    [rxSubscriberSymbol]() { return this; }\n    static create(next, error, complete) {\n        const subscriber = new Subscriber(next, error, complete);\n        subscriber.syncErrorThrowable = false;\n        return subscriber;\n    }\n    next(value) {\n        if (!this.isStopped) {\n            this._next(value);\n        }\n    }\n    error(err) {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._error(err);\n        }\n    }\n    complete() {\n        if (!this.isStopped) {\n            this.isStopped = true;\n            this._complete();\n        }\n    }\n    unsubscribe() {\n        if (this.closed) {\n            return;\n        }\n        this.isStopped = true;\n        super.unsubscribe();\n    }\n    _next(value) {\n        this.destination.next(value);\n    }\n    _error(err) {\n        this.destination.error(err);\n        this.unsubscribe();\n    }\n    _complete() {\n        this.destination.complete();\n        this.unsubscribe();\n    }\n    _unsubscribeAndRecycle() {\n        const { _parentOrParents } = this;\n        this._parentOrParents = null;\n        this.unsubscribe();\n        this.closed = false;\n        this.isStopped = false;\n        this._parentOrParents = _parentOrParents;\n        return this;\n    }\n}\nexport class SafeSubscriber extends Subscriber {\n    constructor(_parentSubscriber, observerOrNext, error, complete) {\n        super();\n        this._parentSubscriber = _parentSubscriber;\n        let next;\n        let context = this;\n        if (isFunction(observerOrNext)) {\n            next = observerOrNext;\n        }\n        else if (observerOrNext) {\n            next = observerOrNext.next;\n            error = observerOrNext.error;\n            complete = observerOrNext.complete;\n            if (observerOrNext !== emptyObserver) {\n                context = Object.create(observerOrNext);\n                if (isFunction(context.unsubscribe)) {\n                    this.add(context.unsubscribe.bind(context));\n                }\n                context.unsubscribe = this.unsubscribe.bind(this);\n            }\n        }\n        this._context = context;\n        this._next = next;\n        this._error = error;\n        this._complete = complete;\n    }\n    next(value) {\n        if (!this.isStopped && this._next) {\n            const { _parentSubscriber } = this;\n            if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                this.__tryOrUnsub(this._next, value);\n            }\n            else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n                this.unsubscribe();\n            }\n        }\n    }\n    error(err) {\n        if (!this.isStopped) {\n            const { _parentSubscriber } = this;\n            const { useDeprecatedSynchronousErrorHandling } = config;\n            if (this._error) {\n                if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(this._error, err);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, this._error, err);\n                    this.unsubscribe();\n                }\n            }\n            else if (!_parentSubscriber.syncErrorThrowable) {\n                this.unsubscribe();\n                if (useDeprecatedSynchronousErrorHandling) {\n                    throw err;\n                }\n                hostReportError(err);\n            }\n            else {\n                if (useDeprecatedSynchronousErrorHandling) {\n                    _parentSubscriber.syncErrorValue = err;\n                    _parentSubscriber.syncErrorThrown = true;\n                }\n                else {\n                    hostReportError(err);\n                }\n                this.unsubscribe();\n            }\n        }\n    }\n    complete() {\n        if (!this.isStopped) {\n            const { _parentSubscriber } = this;\n            if (this._complete) {\n                const wrappedComplete = () => this._complete.call(this._context);\n                if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n                    this.__tryOrUnsub(wrappedComplete);\n                    this.unsubscribe();\n                }\n                else {\n                    this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n                    this.unsubscribe();\n                }\n            }\n            else {\n                this.unsubscribe();\n            }\n        }\n    }\n    __tryOrUnsub(fn, value) {\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            this.unsubscribe();\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                throw err;\n            }\n            else {\n                hostReportError(err);\n            }\n        }\n    }\n    __tryOrSetError(parent, fn, value) {\n        if (!config.useDeprecatedSynchronousErrorHandling) {\n            throw new Error('bad call');\n        }\n        try {\n            fn.call(this._context, value);\n        }\n        catch (err) {\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                parent.syncErrorValue = err;\n                parent.syncErrorThrown = true;\n                return true;\n            }\n            else {\n                hostReportError(err);\n                return true;\n            }\n        }\n        return false;\n    }\n    _unsubscribe() {\n        const { _parentSubscriber } = this;\n        this._context = null;\n        this._parentSubscriber = null;\n        _parentSubscriber.unsubscribe();\n    }\n}\n//# sourceMappingURL=Subscriber.js.map","import { Subscriber } from '../Subscriber';\nexport function canReportError(observer) {\n    while (observer) {\n        const { closed, destination, isStopped } = observer;\n        if (closed || isStopped) {\n            return false;\n        }\n        else if (destination && destination instanceof Subscriber) {\n            observer = destination;\n        }\n        else {\n            observer = null;\n        }\n    }\n    return true;\n}\n//# sourceMappingURL=canReportError.js.map","import { Subscriber } from '../Subscriber';\nimport { rxSubscriber as rxSubscriberSymbol } from '../symbol/rxSubscriber';\nimport { empty as emptyObserver } from '../Observer';\nexport function toSubscriber(nextOrObserver, error, complete) {\n    if (nextOrObserver) {\n        if (nextOrObserver instanceof Subscriber) {\n            return nextOrObserver;\n        }\n        if (nextOrObserver[rxSubscriberSymbol]) {\n            return nextOrObserver[rxSubscriberSymbol]();\n        }\n    }\n    if (!nextOrObserver && !error && !complete) {\n        return new Subscriber(emptyObserver);\n    }\n    return new Subscriber(nextOrObserver, error, complete);\n}\n//# sourceMappingURL=toSubscriber.js.map","export const observable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();\n//# sourceMappingURL=observable.js.map","export function identity(x) {\n    return x;\n}\n//# sourceMappingURL=identity.js.map","import { identity } from './identity';\nexport function pipe(...fns) {\n    return pipeFromArray(fns);\n}\nexport function pipeFromArray(fns) {\n    if (fns.length === 0) {\n        return identity;\n    }\n    if (fns.length === 1) {\n        return fns[0];\n    }\n    return function piped(input) {\n        return fns.reduce((prev, fn) => fn(prev), input);\n    };\n}\n//# sourceMappingURL=pipe.js.map","import { canReportError } from './util/canReportError';\nimport { toSubscriber } from './util/toSubscriber';\nimport { observable as Symbol_observable } from './symbol/observable';\nimport { pipeFromArray } from './util/pipe';\nimport { config } from './config';\nexport class Observable {\n    constructor(subscribe) {\n        this._isScalar = false;\n        if (subscribe) {\n            this._subscribe = subscribe;\n        }\n    }\n    lift(operator) {\n        const observable = new Observable();\n        observable.source = this;\n        observable.operator = operator;\n        return observable;\n    }\n    subscribe(observerOrNext, error, complete) {\n        const { operator } = this;\n        const sink = toSubscriber(observerOrNext, error, complete);\n        if (operator) {\n            sink.add(operator.call(sink, this.source));\n        }\n        else {\n            sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?\n                this._subscribe(sink) :\n                this._trySubscribe(sink));\n        }\n        if (config.useDeprecatedSynchronousErrorHandling) {\n            if (sink.syncErrorThrowable) {\n                sink.syncErrorThrowable = false;\n                if (sink.syncErrorThrown) {\n                    throw sink.syncErrorValue;\n                }\n            }\n        }\n        return sink;\n    }\n    _trySubscribe(sink) {\n        try {\n            return this._subscribe(sink);\n        }\n        catch (err) {\n            if (config.useDeprecatedSynchronousErrorHandling) {\n                sink.syncErrorThrown = true;\n                sink.syncErrorValue = err;\n            }\n            if (canReportError(sink)) {\n                sink.error(err);\n            }\n            else {\n                console.warn(err);\n            }\n        }\n    }\n    forEach(next, promiseCtor) {\n        promiseCtor = getPromiseCtor(promiseCtor);\n        return new promiseCtor((resolve, reject) => {\n            let subscription;\n            subscription = this.subscribe((value) => {\n                try {\n                    next(value);\n                }\n                catch (err) {\n                    reject(err);\n                    if (subscription) {\n                        subscription.unsubscribe();\n                    }\n                }\n            }, reject, resolve);\n        });\n    }\n    _subscribe(subscriber) {\n        const { source } = this;\n        return source && source.subscribe(subscriber);\n    }\n    [Symbol_observable]() {\n        return this;\n    }\n    pipe(...operations) {\n        if (operations.length === 0) {\n            return this;\n        }\n        return pipeFromArray(operations)(this);\n    }\n    toPromise(promiseCtor) {\n        promiseCtor = getPromiseCtor(promiseCtor);\n        return new promiseCtor((resolve, reject) => {\n            let value;\n            this.subscribe((x) => value = x, (err) => reject(err), () => resolve(value));\n        });\n    }\n}\nObservable.create = (subscribe) => {\n    return new Observable(subscribe);\n};\nfunction getPromiseCtor(promiseCtor) {\n    if (!promiseCtor) {\n        promiseCtor = config.Promise || Promise;\n    }\n    if (!promiseCtor) {\n        throw new Error('no Promise impl found');\n    }\n    return promiseCtor;\n}\n//# sourceMappingURL=Observable.js.map","const ObjectUnsubscribedErrorImpl = (() => {\n    function ObjectUnsubscribedErrorImpl() {\n        Error.call(this);\n        this.message = 'object unsubscribed';\n        this.name = 'ObjectUnsubscribedError';\n        return this;\n    }\n    ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);\n    return ObjectUnsubscribedErrorImpl;\n})();\nexport const ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map","import { Subscription } from './Subscription';\nexport class SubjectSubscription extends Subscription {\n    constructor(subject, subscriber) {\n        super();\n        this.subject = subject;\n        this.subscriber = subscriber;\n        this.closed = false;\n    }\n    unsubscribe() {\n        if (this.closed) {\n            return;\n        }\n        this.closed = true;\n        const subject = this.subject;\n        const observers = subject.observers;\n        this.subject = null;\n        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n            return;\n        }\n        const subscriberIndex = observers.indexOf(this.subscriber);\n        if (subscriberIndex !== -1) {\n            observers.splice(subscriberIndex, 1);\n        }\n    }\n}\n//# sourceMappingURL=SubjectSubscription.js.map","import { Observable } from './Observable';\nimport { Subscriber } from './Subscriber';\nimport { Subscription } from './Subscription';\nimport { ObjectUnsubscribedError } from './util/ObjectUnsubscribedError';\nimport { SubjectSubscription } from './SubjectSubscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nexport class SubjectSubscriber extends Subscriber {\n    constructor(destination) {\n        super(destination);\n        this.destination = destination;\n    }\n}\nexport class Subject extends Observable {\n    constructor() {\n        super();\n        this.observers = [];\n        this.closed = false;\n        this.isStopped = false;\n        this.hasError = false;\n        this.thrownError = null;\n    }\n    [rxSubscriberSymbol]() {\n        return new SubjectSubscriber(this);\n    }\n    lift(operator) {\n        const subject = new AnonymousSubject(this, this);\n        subject.operator = operator;\n        return subject;\n    }\n    next(value) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError();\n        }\n        if (!this.isStopped) {\n            const { observers } = this;\n            const len = observers.length;\n            const copy = observers.slice();\n            for (let i = 0; i < len; i++) {\n                copy[i].next(value);\n            }\n        }\n    }\n    error(err) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError();\n        }\n        this.hasError = true;\n        this.thrownError = err;\n        this.isStopped = true;\n        const { observers } = this;\n        const len = observers.length;\n        const copy = observers.slice();\n        for (let i = 0; i < len; i++) {\n            copy[i].error(err);\n        }\n        this.observers.length = 0;\n    }\n    complete() {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError();\n        }\n        this.isStopped = true;\n        const { observers } = this;\n        const len = observers.length;\n        const copy = observers.slice();\n        for (let i = 0; i < len; i++) {\n            copy[i].complete();\n        }\n        this.observers.length = 0;\n    }\n    unsubscribe() {\n        this.isStopped = true;\n        this.closed = true;\n        this.observers = null;\n    }\n    _trySubscribe(subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError();\n        }\n        else {\n            return super._trySubscribe(subscriber);\n        }\n    }\n    _subscribe(subscriber) {\n        if (this.closed) {\n            throw new ObjectUnsubscribedError();\n        }\n        else if (this.hasError) {\n            subscriber.error(this.thrownError);\n            return Subscription.EMPTY;\n        }\n        else if (this.isStopped) {\n            subscriber.complete();\n            return Subscription.EMPTY;\n        }\n        else {\n            this.observers.push(subscriber);\n            return new SubjectSubscription(this, subscriber);\n        }\n    }\n    asObservable() {\n        const observable = new Observable();\n        observable.source = this;\n        return observable;\n    }\n}\nSubject.create = (destination, source) => {\n    return new AnonymousSubject(destination, source);\n};\nexport class AnonymousSubject extends Subject {\n    constructor(destination, source) {\n        super();\n        this.destination = destination;\n        this.source = source;\n    }\n    next(value) {\n        const { destination } = this;\n        if (destination && destination.next) {\n            destination.next(value);\n        }\n    }\n    error(err) {\n        const { destination } = this;\n        if (destination && destination.error) {\n            this.destination.error(err);\n        }\n    }\n    complete() {\n        const { destination } = this;\n        if (destination && destination.complete) {\n            this.destination.complete();\n        }\n    }\n    _subscribe(subscriber) {\n        const { source } = this;\n        if (source) {\n            return this.source.subscribe(subscriber);\n        }\n        else {\n            return Subscription.EMPTY;\n        }\n    }\n}\n//# sourceMappingURL=Subject.js.map"],"mappings":"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"}