text: /** PURE_IMPORTS_START .._Observable,.._util_tryCatch,.._util_errorObject,.._AsyncSubject PURE_IMPORTS_END */
  import { Observable } from '../Observable'
  import { tryCatch } from '../util/tryCatch'
  import { errorObject } from '../util/errorObject'
  import { AsyncSubject } from '../AsyncSubject'
  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 __())
  }
  /**
   * We need this JSDoc comment for affecting ESDoc.
   * @extends {Ignored}
   * @hide true
   */
  export var BoundNodeCallbackObservable = /* @__PURE__ */ (/* @__PURE__ */ function (_super) {
    __extends(BoundNodeCallbackObservable, _super)
    function BoundNodeCallbackObservable (callbackFunc, selector, args, context, scheduler) {
      _super.call(this)
      this.callbackFunc = callbackFunc
      this.selector = selector
      this.args = args
      this.context = context
      this.scheduler = scheduler
    }
    /* tslint:enable:max-line-length */
    /**
       * Converts a Node.js-style callback API to a function that returns an
       * Observable.
       *
       * <span class="informal">It's just like {@link bindCallback}, but the
       * callback is expected to be of type `callback(error, result)`.</span>
       *
       * `bindNodeCallback` is not an operator because its input and output are not
       * Observables. The input is a function `func` with some parameters, but the
       * last parameter must be a callback function that `func` calls when it is
       * done. The callback function is expected to follow Node.js conventions,
       * where the first argument to the callback is an error object, signaling
       * whether call was successful. If that object is passed to callback, it means
       * something went wrong.
       *
       * The output of `bindNodeCallback` is a function that takes the same
       * parameters as `func`, except the last one (the callback). When the output
       * function is called with arguments, it will return an Observable.
       * If `func` calls its callback with error parameter present, Observable will
       * error with that value as well. If error parameter is not passed, Observable will emit
       * second parameter. If there are more parameters (third and so on),
       * Observable will emit an array with all arguments, except first error argument.
       *
       * Optionally `bindNodeCallback` accepts selector function, which allows you to
       * make resulting Observable emit value computed by selector, instead of regular
       * callback arguments. It works similarly to {@link bindCallback} selector, but
       * Node.js-style error argument will never be passed to that function.
       *
       * Note that `func` will not be called at the same time output function is,
       * but rather whenever resulting Observable is subscribed. By default call to
       * `func` will happen synchronously after subscription, but that can be changed
       * with proper {@link Scheduler} provided as optional third parameter. Scheduler
       * can also control when values from callback will be emitted by Observable.
       * To find out more, check out documentation for {@link bindCallback}, where
       * Scheduler works exactly the same.
       *
       * As in {@link bindCallback}, context (`this` property) of input function will be set to context
       * of returned function, when it is called.
       *
       * After Observable emits value, it will complete immediately. This means
       * even if `func` calls callback again, values from second and consecutive
       * calls will never appear on the stream. If you need to handle functions
       * that call callbacks multiple times, check out {@link fromEvent} or
       * {@link fromEventPattern} instead.
       *
       * Note that `bindNodeCallback` can be used in non-Node.js environments as well.
       * "Node.js-style" callbacks are just a convention, so if you write for
       * browsers or any other environment and API you use implements that callback style,
       * `bindNodeCallback` can be safely used on that API functions as well.
       *
       * Remember that Error object passed to callback does not have to be an instance
       * of JavaScript built-in `Error` object. In fact, it does not even have to an object.
       * Error parameter of callback function is interpreted as "present", when value
       * of that parameter is truthy. It could be, for example, non-zero number, non-empty
       * string or boolean `true`. In all of these cases resulting Observable would error
       * with that value. This means usually regular style callbacks will fail very often when
       * `bindNodeCallback` is used. If your Observable errors much more often then you
       * would expect, check if callback really is called in Node.js-style and, if not,
       * switch to {@link bindCallback} instead.
       *
       * Note that even if error parameter is technically present in callback, but its value
       * is falsy, it still won't appear in array emitted by Observable or in selector function.
       *
       *
       * @example <caption>Read a file from the filesystem and get the data as an Observable</caption>
       * import * as fs from 'fs';
       * var readFileAsObservable = Rx.Observable.bindNodeCallback(fs.readFile);
       * var result = readFileAsObservable('./roadNames.txt', 'utf8');
       * result.subscribe(x => console.log(x), e => console.error(e));
       *
       *
       * @example <caption>Use on function calling callback with multiple arguments</caption>
       * someFunction((err, a, b) => {
       *   console.log(err); // null
       *   console.log(a); // 5
       *   console.log(b); // "some string"
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
       * boundSomeFunction()
       * .subscribe(value => {
       *   console.log(value); // [5, "some string"]
       * });
       *
       *
       * @example <caption>Use with selector function</caption>
       * someFunction((err, a, b) => {
       *   console.log(err); // undefined
       *   console.log(a); // "abc"
       *   console.log(b); // "DEF"
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction, (a, b) => a + b);
       * boundSomeFunction()
       * .subscribe(value => {
       *   console.log(value); // "abcDEF"
       * });
       *
       *
       * @example <caption>Use on function calling callback in regular style</caption>
       * someFunction(a => {
       *   console.log(a); // 5
       * });
       * var boundSomeFunction = Rx.Observable.bindNodeCallback(someFunction);
       * boundSomeFunction()
       * .subscribe(
       *   value => {}             // never gets called
       *   err => console.log(err) // 5
       *);
       *
       *
       * @see {@link bindCallback}
       * @see {@link from}
       * @see {@link fromPromise}
       *
       * @param {function} func Function with a Node.js-style callback as the last parameter.
       * @param {function} [selector] A function which takes the arguments from the
       * callback and maps those to a value to emit on the output Observable.
       * @param {Scheduler} [scheduler] The scheduler on which to schedule the
       * callbacks.
       * @return {function(...params: *): Observable} A function which returns the
       * Observable that delivers the same values the Node.js callback would
       * deliver.
       * @static true
       * @name bindNodeCallback
       * @owner Observable
       */
    BoundNodeCallbackObservable.create = function (func, selector, scheduler) {
      if (selector === void 0) {
        selector = undefined
      }
      return function () {
        var args = []
        for (var _i = 0; _i < arguments.length; _i++) {
          args[_i - 0] = arguments[_i]
        }
        return new BoundNodeCallbackObservable(func, selector, args, this, scheduler)
      }
    }
    /** @deprecated internal use only */ BoundNodeCallbackObservable.prototype._subscribe = function (subscriber) {
      var callbackFunc = this.callbackFunc
      var args = this.args
      var scheduler = this.scheduler
      var subject = this.subject
      if (!scheduler) {
        if (!subject) {
          subject = this.subject = new AsyncSubject()
          var handler = function handlerFn () {
            var innerArgs = []
            for (var _i = 0; _i < arguments.length; _i++) {
              innerArgs[_i - 0] = arguments[_i]
            }
            var source = handlerFn.source
            var selector = source.selector; var subject = source.subject
            var err = innerArgs.shift()
            if (err) {
              subject.error(err)
            } else if (selector) {
              var result_1 = tryCatch(selector).apply(this, innerArgs)
              if (result_1 === errorObject) {
                subject.error(errorObject.e)
              } else {
                subject.next(result_1)
                subject.complete()
              }
            } else {
              subject.next(innerArgs.length <= 1 ? innerArgs[0] : innerArgs)
              subject.complete()
            }
          }
          // use named function instance to avoid closure.
          handler.source = this
          var result = tryCatch(callbackFunc).apply(this.context, args.concat(handler))
          if (result === errorObject) {
            subject.error(errorObject.e)
          }
        }
        return subject.subscribe(subscriber)
      } else {
        return scheduler.schedule(dispatch, 0, { source: this, subscriber: subscriber, context: this.context })
      }
    }
    return BoundNodeCallbackObservable
  }(Observable))
  function dispatch (state) {
    var self = this
    var source = state.source; var subscriber = state.subscriber; var context = state.context
    // XXX: cast to `any` to access to the private field in `source`.
    var _a = source; var callbackFunc = _a.callbackFunc; var args = _a.args; var scheduler = _a.scheduler
    var subject = source.subject
    if (!subject) {
      subject = source.subject = new AsyncSubject()
      var handler = function handlerFn () {
        var innerArgs = []
        for (var _i = 0; _i < arguments.length; _i++) {
          innerArgs[_i - 0] = arguments[_i]
        }
        var source = handlerFn.source
        var selector = source.selector; var subject = source.subject
        var err = innerArgs.shift()
        if (err) {
          self.add(scheduler.schedule(dispatchError, 0, { err: err, subject: subject }))
        } else if (selector) {
          var result_2 = tryCatch(selector).apply(this, innerArgs)
          if (result_2 === errorObject) {
            self.add(scheduler.schedule(dispatchError, 0, { err: errorObject.e, subject: subject }))
          } else {
            self.add(scheduler.schedule(dispatchNext, 0, { value: result_2, subject: subject }))
          }
        } else {
          var value = innerArgs.length <= 1 ? innerArgs[0] : innerArgs
          self.add(scheduler.schedule(dispatchNext, 0, { value: value, subject: subject }))
        }
      }
      // use named function to pass values in without closure
      handler.source = source
      var result = tryCatch(callbackFunc).apply(context, args.concat(handler))
      if (result === errorObject) {
        self.add(scheduler.schedule(dispatchError, 0, { err: errorObject.e, subject: subject }))
      }
    }
    self.add(subject.subscribe(subscriber))
  }
  function dispatchNext (arg) {
    var value = arg.value; var subject = arg.subject
    subject.next(value)
    subject.complete()
  }
  function dispatchError (arg) {
    var err = arg.err; var subject = arg.subject
    subject.error(err)
  }
  // # sourceMappingURL=BoundNodeCallbackObservable.js.map
  