text: 'use strict'
  var __extends = (this && this.__extends) || function (d, b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]
    function __ () { this.constructor = d }
    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __())
  }
  var isFunction_1 = require('./util/isFunction')
  var Subscription_1 = require('./Subscription')
  var Observer_1 = require('./Observer')
  var rxSubscriber_1 = require('./symbol/rxSubscriber')
  /**
   * Implements the {@link Observer} interface and extends the
   * {@link Subscription} class. While the {@link Observer} is the public API for
   * consuming the values of an {@link Observable}, all Observers get converted to
   * a Subscriber, in order to provide Subscription-like capabilities such as
   * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
   * implementing operators, but it is rarely used as a public API.
   *
   * @class Subscriber<T>
   */
  var Subscriber = (function (_super) {
    __extends(Subscriber, _super)
    /**
       * @param {Observer|function(value: T): void} [destinationOrNext] A partially
       * defined Observer or a `next` callback function.
       * @param {function(e: ?any): void} [error] The `error` callback of an
       * Observer.
       * @param {function(): void} [complete] The `complete` callback of an
       * Observer.
       */
    function Subscriber (destinationOrNext, error, complete) {
      _super.call(this)
      this.syncErrorValue = null
      this.syncErrorThrown = false
      this.syncErrorThrowable = false
      this.isStopped = false
      switch (arguments.length) {
        case 0:
          this.destination = Observer_1.empty
          break
        case 1:
          if (!destinationOrNext) {
            this.destination = Observer_1.empty
            break
          }
          if (typeof destinationOrNext === 'object') {
            // HACK(benlesh): To resolve an issue where Node users may have multiple
            // copies of rxjs in their node_modules directory.
            if (isTrustedSubscriber(destinationOrNext)) {
              var trustedSubscriber = destinationOrNext[rxSubscriber_1.rxSubscriber]()
              this.syncErrorThrowable = trustedSubscriber.syncErrorThrowable
              this.destination = trustedSubscriber
              trustedSubscriber.add(this)
            } else {
              this.syncErrorThrowable = true
              this.destination = new SafeSubscriber(this, destinationOrNext)
            }
            break
          }
        default:
          this.syncErrorThrowable = true
          this.destination = new SafeSubscriber(this, destinationOrNext, error, complete)
          break
      }
    }
    Subscriber.prototype[rxSubscriber_1.rxSubscriber] = function () { return this }
    /**
       * A static factory for a Subscriber, given a (potentially partial) definition
       * of an Observer.
       * @param {function(x: ?T): void} [next] The `next` callback of an Observer.
       * @param {function(e: ?any): void} [error] The `error` callback of an
       * Observer.
       * @param {function(): void} [complete] The `complete` callback of an
       * Observer.
       * @return {Subscriber<T>} A Subscriber wrapping the (partially defined)
       * Observer represented by the given arguments.
       */
    Subscriber.create = function (next, error, complete) {
      var subscriber = new Subscriber(next, error, complete)
      subscriber.syncErrorThrowable = false
      return subscriber
    }
    /**
       * The {@link Observer} 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}
       */
    Subscriber.prototype.next = function (value) {
      if (!this.isStopped) {
        this._next(value)
      }
    }
    /**
       * The {@link Observer} 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}
       */
    Subscriber.prototype.error = function (err) {
      if (!this.isStopped) {
        this.isStopped = true
        this._error(err)
      }
    }
    /**
       * The {@link Observer} 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}
       */
    Subscriber.prototype.complete = function () {
      if (!this.isStopped) {
        this.isStopped = true
        this._complete()
      }
    }
    Subscriber.prototype.unsubscribe = function () {
      if (this.closed) {
        return
      }
      this.isStopped = true
      _super.prototype.unsubscribe.call(this)
    }
    Subscriber.prototype._next = function (value) {
      this.destination.next(value)
    }
    Subscriber.prototype._error = function (err) {
      this.destination.error(err)
      this.unsubscribe()
    }
    Subscriber.prototype._complete = function () {
      this.destination.complete()
      this.unsubscribe()
    }
    /** @deprecated internal use only */ Subscriber.prototype._unsubscribeAndRecycle = function () {
      var _a = this; var _parent = _a._parent; var _parents = _a._parents
      this._parent = null
      this._parents = null
      this.unsubscribe()
      this.closed = false
      this.isStopped = false
      this._parent = _parent
      this._parents = _parents
      return this
    }
    return Subscriber
  }(Subscription_1.Subscription))
  exports.Subscriber = Subscriber
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @ignore
   * @extends {Ignored}
   */
  var SafeSubscriber = (function (_super) {
    __extends(SafeSubscriber, _super)
    function SafeSubscriber (_parentSubscriber, observerOrNext, error, complete) {
      _super.call(this)
      this._parentSubscriber = _parentSubscriber
      var next
      var context = this
      if (isFunction_1.isFunction(observerOrNext)) {
        next = observerOrNext
      } else if (observerOrNext) {
        next = observerOrNext.next
        error = observerOrNext.error
        complete = observerOrNext.complete
        if (observerOrNext !== Observer_1.empty) {
          context = Object.create(observerOrNext)
          if (isFunction_1.isFunction(context.unsubscribe)) {
            this.add(context.unsubscribe.bind(context))
          }
          context.unsubscribe = this.unsubscribe.bind(this)
        }
      }
      this._context = context
      this._next = next
      this._error = error
      this._complete = complete
    }
    SafeSubscriber.prototype.next = function (value) {
      if (!this.isStopped && this._next) {
        var _parentSubscriber = this._parentSubscriber
        if (!_parentSubscriber.syncErrorThrowable) {
          this.__tryOrUnsub(this._next, value)
        } else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {
          this.unsubscribe()
        }
      }
    }
    SafeSubscriber.prototype.error = function (err) {
      if (!this.isStopped) {
        var _parentSubscriber = this._parentSubscriber
        if (this._error) {
          if (!_parentSubscriber.syncErrorThrowable) {
            this.__tryOrUnsub(this._error, err)
            this.unsubscribe()
          } else {
            this.__tryOrSetError(_parentSubscriber, this._error, err)
            this.unsubscribe()
          }
        } else if (!_parentSubscriber.syncErrorThrowable) {
          this.unsubscribe()
          throw err
        } else {
          _parentSubscriber.syncErrorValue = err
          _parentSubscriber.syncErrorThrown = true
          this.unsubscribe()
        }
      }
    }
    SafeSubscriber.prototype.complete = function () {
      var _this = this
      if (!this.isStopped) {
        var _parentSubscriber = this._parentSubscriber
        if (this._complete) {
          var wrappedComplete = function () { return _this._complete.call(_this._context) }
          if (!_parentSubscriber.syncErrorThrowable) {
            this.__tryOrUnsub(wrappedComplete)
            this.unsubscribe()
          } else {
            this.__tryOrSetError(_parentSubscriber, wrappedComplete)
            this.unsubscribe()
          }
        } else {
          this.unsubscribe()
        }
      }
    }
    SafeSubscriber.prototype.__tryOrUnsub = function (fn, value) {
      try {
        fn.call(this._context, value)
      } catch (err) {
        this.unsubscribe()
        throw err
      }
    }
    SafeSubscriber.prototype.__tryOrSetError = function (parent, fn, value) {
      try {
        fn.call(this._context, value)
      } catch (err) {
        parent.syncErrorValue = err
        parent.syncErrorThrown = true
        return true
      }
      return false
    }
    /** @deprecated internal use only */ SafeSubscriber.prototype._unsubscribe = function () {
      var _parentSubscriber = this._parentSubscriber
      this._context = null
      this._parentSubscriber = null
      _parentSubscriber.unsubscribe()
    }
    return SafeSubscriber
  }(Subscriber))
  function isTrustedSubscriber (obj) {
    return obj instanceof Subscriber || ('syncErrorThrowable' in obj && obj[rxSubscriber_1.rxSubscriber])
  }
  // # sourceMappingURL=Subscriber.js.map
  