text: // Tab management.
  
  'use strict';
  
  var _get = require('babel-runtime/helpers/get')['default'];
  
  var _inherits = require('babel-runtime/helpers/inherits')['default'];
  
  var _createClass = require('babel-runtime/helpers/create-class')['default'];
  
  var _classCallCheck = require('babel-runtime/helpers/class-call-check')['default'];
  
  var _getIterator = require('babel-runtime/core-js/get-iterator')['default'];
  
  var _ = require('lodash');
  var createHistory = require('./history');
  
  module.exports = (function (_Array) {
    _inherits(Tabs, _Array);
  
    function Tabs(browser) {
      _classCallCheck(this, Tabs);
  
      _get(Object.getPrototypeOf(Tabs.prototype), 'constructor', this).call(this);
      this._current = null;
      this._browser = browser;
      this.length = 0;
      Object.defineProperty(this, 'length', { enumerable: false, writable: true });
      Object.defineProperty(this, '_browser', { enumerable: false, writable: true });
      Object.defineProperty(this, '_current', { enumerable: false, writable: true });
    }
  
    // Get the currently open tab
  
    _createClass(Tabs, [{
      key: 'find',
  
      // Returns window by index or name. Use this for window names that shadow
      // existing properties (e.g. tabs['open'] is a function, use
      value: function find(nameOrWindow) {
        if (this.propertyIsEnumerable(nameOrWindow)) return this[nameOrWindow];
        var byName = _.find(this, { name: nameOrWindow });
        if (byName) return byName;
        if (this._indexOf(nameOrWindow) >= 0) return nameOrWindow;
        return null;
      }
  
      // Index of currently selected tab.
    }, {
      key: 'open',
  
      // Opens and returns a tab.  If an open window by the same name already exists,
      // opens this window in the same tab.  Omit name or use '_blank' to always open
      // a new tab.
      //
      // name    - Window name (optional)
      // opener  - Opening window (window.open call)
      // referer - Referrer
      // url     - Set document location to this URL upon opening
      // html    - Document contents (browser.load)
      value: function open() {
        var _this = this;
  
        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
  
        // If name window in open tab, reuse that tab. Otherwise, open new window.
        var named = options.name && this.find(options.name.toString());
        if (named) {
          // Select this as the currenly open tab. Changing the location would then
          // select a different window.
          this._current = named;
          if (options.url) this._current.location = options.url;
          return this._current;
        }
  
        // When window changes we need to change tab slot. We can't keep the index
        // around, since tab order changes, so we look up the currently known
        // active window and switch that around.
        var active = null;
        var open = createHistory(this._browser, function (window) {
          // Focus changes to different window, make it the active window
          if (!Tabs.sameWindow(window, active)) {
            var index = _this._indexOf(active);
            if (index >= 0) _this[index] = window;
            _this.current = active = window;
          }
          if (window) _this._browser._eventLoop.setActiveWindow(window);
        });
  
        var name = options.name === '_blank' ? '' : options.name || '';
        options.name = name;
        var window = open(options);
        this.push(window);
        if (name && (this.propertyIsEnumerable(name) || !this[name])) this[name] = window;
        // Select this as the currenly open tab
        this.current = active = window;
        return window;
      }
  
      // Close an open tab.
      //
      // With no argument, closes the currently open tab (tabs.current).
      //
      // Argument can be the window, window name or tab position (same as find).
    }, {
      key: 'close',
      value: function close(nameOrWindow) {
        var window = nameOrWindow ? this.find(nameOrWindow) : this._current;
        if (this._indexOf(window) >= 0) window.close();
      }
  
      // Closes all open tabs/windows.
    }, {
      key: 'closeAll',
      value: function closeAll() {
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;
  
        try {
          for (var _iterator = _getIterator(this.slice()), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
            var tab = _step.value;
  
            tab.close();
          }
        } catch (err) {
          _didIteratorError = true;
          _iteratorError = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion && _iterator['return']) {
              _iterator['return']();
            }
          } finally {
            if (_didIteratorError) {
              throw _iteratorError;
            }
          }
        }
      }
  
      // Dump list of all open tabs to stdout or output stream.
    }, {
      key: 'dump',
      value: function dump() {
        var output = arguments.length <= 0 || arguments[0] === undefined ? process.stdout : arguments[0];
  
        if (this.length === 0) {
          output.write('No open tabs.\n');
          return;
        }
        var _iteratorNormalCompletion2 = true;
        var _didIteratorError2 = false;
        var _iteratorError2 = undefined;
  
        try {
          for (var _iterator2 = _getIterator(this), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
            var tab = _step2.value;
  
            output.write('Window ' + (tab.name || 'unnamed') + ' open to ' + tab.location.href + '\n');
          }
        } catch (err) {
          _didIteratorError2 = true;
          _iteratorError2 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion2 && _iterator2['return']) {
              _iterator2['return']();
            }
          } finally {
            if (_didIteratorError2) {
              throw _iteratorError2;
            }
          }
        }
      }
  
      // Find the position of this window in the tabs array
    }, {
      key: '_indexOf',
      value: function _indexOf(window) {
        if (!window) return -1;
        return this.slice().map(function (tab) {
          return tab._globalProxy;
        }).indexOf(window._globalProxy);
      }
  
      // Called when window closed to remove it from tabs list.
    }, {
      key: '_closed',
      value: function _closed(window) {
        var index = this._indexOf(window);
        if (index >= 0) {
          this._browser.emit('inactive', window);
  
          this.splice(index, 1);
          if (this.propertyIsEnumerable(window.name)) delete this[window.name];
  
          // If we closed the currently open tab, need to select another window.
          if (Tabs.sameWindow(window, this._current)) {
            // Don't emit inactive event for closed window.
            this._current = this[index - 1] || this[0];
            if (this._current) this._browser.emit('active', this._current);
          }
        }
      }
  
      // Determine if two windows are the same
    }, {
      key: 'current',
      get: function get() {
        return this._current;
      },
  
      // Sets the currently open tab
      // - Name   - Pick existing window with this name
      // - Number - Pick existing window from tab position
      // - Window - Use this window
      set: function set(nameOrWindow) {
        var window = this.find(nameOrWindow);
        if (this._indexOf(window) < 0) return;
        if (!Tabs.sameWindow(this._current, window)) {
          if (this._current) this._browser.emit('inactive', this._current);
          this._current = window;
          this._browser.emit('active', this._current);
        }
      }
    }, {
      key: 'index',
      get: function get() {
        return this._indexOf(this._current);
      }
    }], [{
      key: 'sameWindow',
      value: function sameWindow(a, b) {
        return a && b && a._globalProxy === b._globalProxy;
      }
    }]);
  
    return Tabs;
  })(Array);
  //# sourceMappingURL=tabs.js.map