scrivito_content_browser 1.8.1 → 1.9.0.rc1

data/app/assets/javascripts/dist/scrivito_content_browser_pkg.js

@@ -44,17 +44,17 @@
 /* 0 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var AppComponent, DialogApp, Filter, Provider, ReactRedux, configureStore;
+	var AppContainer, DialogApp, Filter, Provider, ReactRedux, configureStore;
 
 	__webpack_require__(1);
 
 	DialogApp = __webpack_require__(4);
 
-	Filter = __webpack_require__(7);
+	Filter = __webpack_require__(7)["default"];
 
-	AppComponent = __webpack_require__(18);
+	AppContainer = __webpack_require__(17).AppContainer;
 
-	ReactRedux = __webpack_require__(25);
+	ReactRedux = __webpack_require__(24);
 
 	Provider = ReactRedux.Provider;
 
@@ -125,7 +125,7 @@
 	      store = configureStore();
 	      return this._reactApp = ReactDOM.render(React.createElement(Provider, {
 	        "store": store
-	      }, React.createElement(AppComponent, {
+	      }, React.createElement(AppContainer, {
 	        "initialFilter": filter,
 	        "baseQuery": baseQuery,
 	        "promise": promise,
@@ -418,534 +418,709 @@
 /* 7 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ASC_SORT_ORDER, CheckboxFilter, Filter, Listenable, RadioFilter, TreeFilter,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
 
-	Listenable = __webpack_require__(8);
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	RadioFilter = __webpack_require__(9);
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	TreeFilter = __webpack_require__(13);
+	var _listenable = __webpack_require__(8);
 
-	CheckboxFilter = __webpack_require__(14);
+	var _listenable2 = _interopRequireDefault(_listenable);
 
-	ASC_SORT_ORDER = __webpack_require__(16).ASC_SORT_ORDER;
+	var _radio_filter = __webpack_require__(9);
 
-	Filter = (function(_super) {
-	  __extends(Filter, _super);
+	var _radio_filter2 = _interopRequireDefault(_radio_filter);
 
-	  function Filter(filterDefinitionOrFunction, filterContext) {
-	    var filterDefinition;
-	    Filter.__super__.constructor.call(this);
-	    filterDefinition = this._resolveFunction(filterDefinitionOrFunction, filterContext);
-	    this._lastAdded = false;
-	    if (_.isEmpty(filterDefinition)) {
-	      filterDefinition = this._resolveFunction(__webpack_require__(17), filterContext);
-	    }
-	    this._initFilters(filterDefinition);
-	  }
+	var _tree_filter = __webpack_require__(13);
 
-	  Filter.prototype.deselectHierarchicalFilters = function() {
-	    return _.each(this.getHierarchicalFilters(), function(filter) {
-	      return filter.deselect();
-	    });
-	  };
+	var _tree_filter2 = _interopRequireDefault(_tree_filter);
 
-	  Filter.prototype.setSearchTerm = function(newTerm) {
-	    this.searchTerm = newTerm;
-	    return this.changed();
-	  };
+	var _checkbox_filter = __webpack_require__(14);
 
-	  Filter.prototype.getAllFilters = function() {
-	    return _.union(this.getHierarchicalFilters(), this.additionalFilters);
-	  };
+	var _checkbox_filter2 = _interopRequireDefault(_checkbox_filter);
 
-	  Filter.prototype.hasActiveChildren = function() {
-	    return _.some(this.getAllFilters(), function(subFilter) {
-	      return subFilter.hasActiveChildren();
-	    });
-	  };
+	var _default_filter_definition = __webpack_require__(16);
 
-	  Filter.prototype.getHierarchicalFilters = function() {
-	    return _.flatten(_.map(this.getTreeFilters(), function(filter) {
-	      return filter.subFilters;
-	    }));
-	  };
+	var _default_filter_definition2 = _interopRequireDefault(_default_filter_definition);
 
-	  Filter.prototype.getTreeFilters = function() {
-	    return this.treeFilters;
-	  };
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	  Filter.prototype.hasHierarchicalFilters = function() {
-	    return this.treeFilters.length > 0;
-	  };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	  Filter.prototype.hasAdditionalFilters = function() {
-	    return this.additionalFilters.length > 0;
-	  };
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-	  Filter.prototype._initFilters = function(filterDefinition) {
-	    var definition, name, subFilters, _results;
-	    this.treeFilters = [];
-	    this.additionalFilters = [];
-	    _results = [];
-	    for (name in filterDefinition) {
-	      if (!__hasProp.call(filterDefinition, name)) continue;
-	      definition = filterDefinition[name];
-	      if (!(definition)) {
-	        continue;
-	      }
-	      if ((definition.type == null) || definition.type === 'tree') {
-	        subFilters = [];
-	        _.each(definition.options, (function(_this) {
-	          return function(definition, name) {
-	            return subFilters.push(new TreeFilter(_this, name, definition));
-	          };
-	        })(this));
-	        this.treeFilters.push({
-	          config: definition,
-	          subFilters: subFilters
-	        });
-	      }
-	      if (definition.type === 'radio_button') {
-	        this.additionalFilters.push(new RadioFilter(this, name, definition));
-	      }
-	      if (definition.type === 'check_box') {
-	        _results.push(this.additionalFilters.push(new CheckboxFilter(this, name, definition)));
-	      } else {
-	        _results.push(void 0);
-	      }
-	    }
-	    return _results;
-	  };
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-	  Filter.prototype._resolveFunction = function(objectOrFunction, context) {
-	    if (typeof objectOrFunction === 'function') {
-	      return objectOrFunction(context != null ? context : {});
-	    } else {
-	      return objectOrFunction;
+	var resolveFunction = function resolveFunction(objectOrFunction, context) {
+	  if (typeof objectOrFunction === 'function') {
+	    return objectOrFunction(context || {});
+	  }
+
+	  return objectOrFunction;
+	};
+
+	var Filter = function (_Listenable) {
+	  _inherits(Filter, _Listenable);
+
+	  function Filter(filterDefinitionOrFunction, filterContext) {
+	    _classCallCheck(this, Filter);
+
+	    var _this = _possibleConstructorReturn(this, (Filter.__proto__ || Object.getPrototypeOf(Filter)).call(this));
+
+	    var filterDefinition = resolveFunction(filterDefinitionOrFunction, filterContext);
+
+	    if (_.isEmpty(filterDefinition)) {
+	      filterDefinition = resolveFunction(_default_filter_definition2.default, filterContext);
 	    }
-	  };
+	    _this.initFilters(filterDefinition);
+	    return _this;
+	  }
 
-	  return Filter;
+	  _createClass(Filter, [{
+	    key: 'deselectHierarchicalFilters',
+	    value: function deselectHierarchicalFilters() {
+	      return _.each(this.getHierarchicalFilters(), function (filter) {
+	        return filter.deselect();
+	      });
+	    }
+	  }, {
+	    key: 'setSearchTerm',
+	    value: function setSearchTerm(newTerm) {
+	      this.searchTerm = newTerm;
+	      this.changed();
+	    }
+	  }, {
+	    key: 'getAllFilters',
+	    value: function getAllFilters() {
+	      return _.union(this.getHierarchicalFilters(), this.additionalFilters);
+	    }
+	  }, {
+	    key: 'hasActiveChildren',
+	    value: function hasActiveChildren() {
+	      return _.some(this.getAllFilters(), function (subFilter) {
+	        return subFilter.hasActiveChildren();
+	      });
+	    }
+	  }, {
+	    key: 'getHierarchicalFilters',
+	    value: function getHierarchicalFilters() {
+	      return _.flatten(_.map(this.getTreeFilters(), function (filter) {
+	        return filter.subFilters;
+	      }));
+	    }
+	  }, {
+	    key: 'getTreeFilters',
+	    value: function getTreeFilters() {
+	      return this.treeFilters;
+	    }
+	  }, {
+	    key: 'hasHierarchicalFilters',
+	    value: function hasHierarchicalFilters() {
+	      return this.treeFilters.length > 0;
+	    }
+	  }, {
+	    key: 'hasAdditionalFilters',
+	    value: function hasAdditionalFilters() {
+	      return this.additionalFilters.length > 0;
+	    }
+	  }, {
+	    key: 'initFilters',
+	    value: function initFilters(filterDefinition) {
+	      var _this2 = this;
+
+	      this.treeFilters = [];
+	      this.additionalFilters = [];
+
+	      return function () {
+	        var result = [];
+	        _.each(Object.keys(filterDefinition || {}), function (name) {
+	          var definition = filterDefinition[name];
+
+	          if (definition) {
+	            var item = void 0;
+	            if (definition.type == null || definition.type === 'tree') {
+	              var subFilters = [];
+
+	              _.each(definition.options, function (optionDefinition, title) {
+	                return subFilters.push(new _tree_filter2.default(_this2, title, optionDefinition));
+	              });
+
+	              _this2.treeFilters.push({
+	                config: definition,
+	                subFilters: subFilters
+	              });
+	            }
+	            if (definition.type === 'radio_button') {
+	              _this2.additionalFilters.push(new _radio_filter2.default(_this2, name, definition));
+	            }
+	            if (definition.type === 'check_box') {
+	              item = _this2.additionalFilters.push(new _checkbox_filter2.default(_this2, name, definition));
+	            }
+	            result.push(item);
+	          }
+	        });
 
-	})(Listenable);
+	        return result;
+	      }();
+	    }
+	  }]);
 
-	module.exports = Filter;
+	  return Filter;
+	}(_listenable2.default);
 
+	exports.default = Filter;
 
 /***/ },
 /* 8 */
 /***/ function(module, exports) {
 
-	var Listenable;
-
-	Listenable = (function() {
-	  function Listenable() {
-	    this._callbacks = {};
-	  }
+	'use strict';
 
-	  Listenable.prototype.on = function(eventName, callback) {
-	    var _base;
-	    (_base = this._callbacks)[eventName] || (_base[eventName] = []);
-	    return this._callbacks[eventName].push(callback);
-	  };
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	  Listenable.prototype.trigger = function() {
-	    var callbacks, eventName, params;
-	    eventName = arguments[0];
-	    params = _.toArray(arguments).slice(1);
-	    callbacks = this._callbacks[eventName];
-	    if (callbacks) {
-	      return _.each(callbacks, function(callback) {
-	        return callback.apply(this, params);
-	      });
-	    }
-	  };
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	  Listenable.prototype.onChange = function(callback) {
-	    return this.on('change', callback);
-	  };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	  Listenable.prototype.changed = function() {
-	    return this.trigger('change', this);
-	  };
+	var Listenable = function () {
+	  function Listenable() {
+	    _classCallCheck(this, Listenable);
 
-	  return Listenable;
+	    this.callbacks = {};
+	  }
 
-	})();
+	  _createClass(Listenable, [{
+	    key: 'on',
+	    value: function on(eventName, callback) {
+	      if (!this.callbacks[eventName]) {
+	        this.callbacks[eventName] = [];
+	      }
+	      this.callbacks[eventName].push(callback);
+	    }
+	  }, {
+	    key: 'trigger',
+	    value: function trigger(eventName, listOfParams) {
+	      var _this = this;
+
+	      var callbacks = this.callbacks[eventName];
+	      var params = [listOfParams];
+	      if (callbacks) {
+	        _.each(callbacks, function (callback) {
+	          callback.apply(_this, params);
+	        });
+	      }
+	    }
+	  }, {
+	    key: 'onChange',
+	    value: function onChange(callback) {
+	      this.on('change', callback);
+	    }
+	  }, {
+	    key: 'changed',
+	    value: function changed() {
+	      this.trigger('change', this);
+	    }
+	  }]);
 
-	module.exports = Listenable;
+	  return Listenable;
+	}();
 
+	exports.default = Listenable;
 
 /***/ },
 /* 9 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var FilterCollectionNode, RadioFilter, RadioOption,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _filter_collection_node = __webpack_require__(10);
+
+	var _filter_collection_node2 = _interopRequireDefault(_filter_collection_node);
+
+	var _radio_option = __webpack_require__(12);
+
+	var _radio_option2 = _interopRequireDefault(_radio_option);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	FilterCollectionNode = __webpack_require__(10);
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-	RadioOption = __webpack_require__(12);
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-	RadioFilter = (function(_super) {
-	  __extends(RadioFilter, _super);
+	var RadioFilter = function (_FilterCollectionNode) {
+	  _inherits(RadioFilter, _FilterCollectionNode);
 
 	  function RadioFilter(filter, name, filterDefinition) {
-	    RadioFilter.__super__.constructor.call(this, filter, name, filterDefinition);
-	    this.type = 'radio';
-	    this.children = _.map(filterDefinition.options, (function(_this) {
-	      return function(definition, name) {
-	        return new RadioOption(_this, name, definition);
-	      };
-	    })(this));
-	  }
+	    _classCallCheck(this, RadioFilter);
 
-	  RadioFilter.prototype.activate = function(radioOption) {
-	    _.each(this.children, function(child) {
-	      return child.active = child === radioOption;
-	    });
-	    return this.filter.changed();
-	  };
+	    var _this = _possibleConstructorReturn(this, (RadioFilter.__proto__ || Object.getPrototypeOf(RadioFilter)).call(this, filter, name, filterDefinition));
 
-	  RadioFilter.prototype.deactivateAll = function() {
-	    this.deselect();
-	    return this.filter.changed();
-	  };
+	    _this.type = 'radio';
+	    _this.children = _.map(filterDefinition.options, function (definition, title) {
+	      return new _radio_option2.default(_this, title, definition);
+	    });
+	    return _this;
+	  }
 
-	  return RadioFilter;
+	  _createClass(RadioFilter, [{
+	    key: 'activate',
+	    value: function activate(radioOption) {
+	      _.each(this.children, function (child) {
+	        child.active = child === radioOption;
+	      });
 
-	})(FilterCollectionNode);
+	      this.filter.changed();
+	    }
+	  }, {
+	    key: 'deactivateAll',
+	    value: function deactivateAll() {
+	      this.deselect();
+	      this.filter.changed();
+	    }
+	  }]);
 
-	module.exports = RadioFilter;
+	  return RadioFilter;
+	}(_filter_collection_node2.default);
 
+	exports.default = RadioFilter;
 
 /***/ },
 /* 10 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var FilterCollectionNode, FilterNode,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
 
-	FilterNode = __webpack_require__(11);
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	FilterCollectionNode = (function(_super) {
-	  __extends(FilterCollectionNode, _super);
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	  function FilterCollectionNode(filter, name, filterDefinition) {
-	    FilterCollectionNode.__super__.constructor.call(this, filter, name, filterDefinition);
-	    this.field = filterDefinition.field, this.operator = filterDefinition.operator;
-	    this.expanded = filterDefinition.expanded !== false;
-	    this.children = [];
-	  }
+	var _filter_node = __webpack_require__(11);
 
-	  FilterCollectionNode.prototype.deselect = function() {
-	    return _.each(this.children, function(child) {
-	      return child.active = false;
-	    });
-	  };
+	var _filter_node2 = _interopRequireDefault(_filter_node);
 
-	  FilterCollectionNode.prototype.isExpanded = function() {
-	    return !!this.expanded;
-	  };
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	  FilterCollectionNode.prototype.hasActiveChildren = function() {
-	    return _.some(this.children, function(child) {
-	      return child.isActive();
-	    });
-	  };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	  return FilterCollectionNode;
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var FilterCollectionNode = function (_FilterNode) {
+	  _inherits(FilterCollectionNode, _FilterNode);
+
+	  function FilterCollectionNode(filter, name, filterDefinition) {
+	    _classCallCheck(this, FilterCollectionNode);
+
+	    var _this = _possibleConstructorReturn(this, (FilterCollectionNode.__proto__ || Object.getPrototypeOf(FilterCollectionNode)).call(this, filter, name, filterDefinition));
+
+	    _this.field = filterDefinition.field;
+	    _this.operator = filterDefinition.operator;
 
-	})(FilterNode);
+	    _this.expanded = filterDefinition.expanded !== false;
+	    _this.children = [];
+	    return _this;
+	  }
+
+	  _createClass(FilterCollectionNode, [{
+	    key: 'deselect',
+	    value: function deselect() {
+	      return _.each(this.children, function (child) {
+	        child.active = false;
+	      });
+	    }
+	  }, {
+	    key: 'isExpanded',
+	    value: function isExpanded() {
+	      return !!this.expanded;
+	    }
+	  }, {
+	    key: 'hasActiveChildren',
+	    value: function hasActiveChildren() {
+	      return _.some(this.children, function (child) {
+	        return child.isActive();
+	      });
+	    }
+	  }]);
 
-	module.exports = FilterCollectionNode;
+	  return FilterCollectionNode;
+	}(_filter_node2.default);
 
+	exports.default = FilterCollectionNode;
 
 /***/ },
 /* 11 */
 /***/ function(module, exports) {
 
-	var FilterNode;
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	FilterNode = (function() {
+	var capitalize = function capitalize(string) {
+	  return string.charAt(0).toUpperCase() + string.slice(1);
+	};
+
+	var FilterNode = function () {
 	  function FilterNode(filter, name, filterDefinition) {
+	    _classCallCheck(this, FilterNode);
+
 	    this.filter = filter;
 	    this.name = name;
 	    this.title = filterDefinition.title;
-	    this.title || (this.title = this._fallbackTitle());
+	    if (!this.title) {
+	      this.title = this.fallbackTitle();
+	    }
 	  }
 
-	  FilterNode.prototype._fallbackTitle = function() {
-	    return this._capitalize(this.name.replace(/_/g, ' ').trim());
-	  };
-
-	  FilterNode.prototype._capitalize = function(string) {
-	    return string.charAt(0).toUpperCase() + string.slice(1);
-	  };
+	  _createClass(FilterNode, [{
+	    key: 'fallbackTitle',
+	    value: function fallbackTitle() {
+	      return capitalize(this.name.replace(/_/g, ' ').trim());
+	    }
+	  }]);
 
 	  return FilterNode;
+	}();
 
-	})();
-
-	module.exports = FilterNode;
-
+	exports.default = FilterNode;
 
 /***/ },
 /* 12 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var FilterNode, RadioOption,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _filter_node = __webpack_require__(11);
+
+	var _filter_node2 = _interopRequireDefault(_filter_node);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	FilterNode = __webpack_require__(11);
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	RadioOption = (function(_super) {
-	  __extends(RadioOption, _super);
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var RadioOption = function (_FilterNode) {
+	  _inherits(RadioOption, _FilterNode);
 
 	  function RadioOption(group, name, filterDefinition) {
-	    this.group = group;
-	    RadioOption.__super__.constructor.call(this, this.group.filter, name, filterDefinition);
-	    this.value = filterDefinition.value, this.query = filterDefinition.query, this.preset = filterDefinition.preset, this.enable_create = filterDefinition.enable_create;
-	    this.active = filterDefinition.selected;
-	  }
+	    _classCallCheck(this, RadioOption);
 
-	  RadioOption.prototype.setActive = function() {
-	    return this.group.activate(this);
-	  };
+	    var _this = _possibleConstructorReturn(this, (RadioOption.__proto__ || Object.getPrototypeOf(RadioOption)).call(this, group.filter, name, filterDefinition));
 
-	  RadioOption.prototype.isActive = function() {
-	    return !!this.active;
-	  };
+	    _this.value = filterDefinition.value;
+	    _this.query = filterDefinition.query;
+	    _this.preset = filterDefinition.preset;
+	    _this.enable_create = filterDefinition.enable_create;
 
-	  return RadioOption;
 
-	})(FilterNode);
+	    _this.group = group;
+	    _this.active = filterDefinition.selected;
+	    return _this;
+	  }
+
+	  _createClass(RadioOption, [{
+	    key: 'setActive',
+	    value: function setActive() {
+	      return this.group.activate(this);
+	    }
+	  }, {
+	    key: 'isActive',
+	    value: function isActive() {
+	      return !!this.active;
+	    }
+	  }]);
 
-	module.exports = RadioOption;
+	  return RadioOption;
+	}(_filter_node2.default);
 
+	exports.default = RadioOption;
 
 /***/ },
 /* 13 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var FilterNode, TreeFilter,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _filter_node = __webpack_require__(11);
+
+	var _filter_node2 = _interopRequireDefault(_filter_node);
 
-	FilterNode = __webpack_require__(11);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	TreeFilter = (function(_super) {
-	  __extends(TreeFilter, _super);
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var TreeFilter = function (_FilterNode) {
+	  _inherits(TreeFilter, _FilterNode);
 
 	  function TreeFilter(filter, name, filterDefinition) {
-	    var childrenDefinition;
-	    TreeFilter.__super__.constructor.call(this, filter, name, filterDefinition);
-	    this.type = 'tree';
-	    this.icon = filterDefinition.icon, this.query = filterDefinition.query, this.expanded = filterDefinition.expanded, this.value = filterDefinition.value, this.field = filterDefinition.field, this.operator = filterDefinition.operator, this.preset = filterDefinition.preset, this.enable_create = filterDefinition.enable_create;
-	    this.active = filterDefinition.selected;
-	    childrenDefinition = filterDefinition.options || [];
-	    this.children = _.map(childrenDefinition, function(definition, name) {
-	      return new TreeFilter(filter, name, definition);
-	    });
-	  }
+	    _classCallCheck(this, TreeFilter);
 
-	  TreeFilter.prototype.isLeaf = function() {
-	    return this.children.length === 0;
-	  };
+	    var _this = _possibleConstructorReturn(this, (TreeFilter.__proto__ || Object.getPrototypeOf(TreeFilter)).call(this, filter, name, filterDefinition));
 
-	  TreeFilter.prototype.isExpanded = function() {
-	    return !!this.expanded;
-	  };
+	    _this.type = 'tree';
+	    _this.icon = filterDefinition.icon;
+	    _this.query = filterDefinition.query;
+	    _this.expanded = filterDefinition.expanded;
+	    _this.value = filterDefinition.value;
+	    _this.field = filterDefinition.field;
+	    _this.operator = filterDefinition.operator;
+	    _this.preset = filterDefinition.preset;
+	    _this.enable_create = filterDefinition.enable_create;
 
-	  TreeFilter.prototype.isActive = function() {
-	    return !!this.active;
-	  };
 
-	  TreeFilter.prototype.toggleActive = function() {
-	    if (this.isActive()) {
-	      this.active = false;
-	    } else {
-	      this.filter.deselectHierarchicalFilters();
-	      this.active = true;
-	    }
-	    return this.filter.changed();
-	  };
+	    _this.active = filterDefinition.selected;
 
-	  TreeFilter.prototype.hasActiveChildren = function() {
-	    return this.isActive() || _.some(this.children, function(child) {
-	      return child.isActive();
+	    var childrenDefinition = filterDefinition.options || [];
+	    _this.children = _.map(childrenDefinition, function (definition, title) {
+	      return new TreeFilter(filter, title, definition);
 	    });
-	  };
+	    return _this;
+	  }
 
-	  TreeFilter.prototype.deselect = function() {
-	    this.active = false;
-	    return _.each(this.children, function(filter) {
-	      return filter.deselect();
-	    });
-	  };
+	  _createClass(TreeFilter, [{
+	    key: 'isLeaf',
+	    value: function isLeaf() {
+	      return this.children.length === 0;
+	    }
+	  }, {
+	    key: 'isExpanded',
+	    value: function isExpanded() {
+	      return !!this.expanded;
+	    }
+	  }, {
+	    key: 'isActive',
+	    value: function isActive() {
+	      return !!this.active;
+	    }
+	  }, {
+	    key: 'toggleActive',
+	    value: function toggleActive() {
+	      if (this.isActive()) {
+	        this.active = false;
+	      } else {
+	        this.filter.deselectHierarchicalFilters();
+	        this.active = true;
+	      }
 
-	  return TreeFilter;
+	      this.filter.changed();
+	    }
+	  }, {
+	    key: 'hasActiveChildren',
+	    value: function hasActiveChildren() {
+	      return this.isActive() || _.some(this.children, function (child) {
+	        return child.isActive();
+	      });
+	    }
+	  }, {
+	    key: 'deselect',
+	    value: function deselect() {
+	      this.active = false;
 
-	})(FilterNode);
+	      _.each(this.children, function (filter) {
+	        return filter.deselect();
+	      });
+	    }
+	  }]);
 
-	module.exports = TreeFilter;
+	  return TreeFilter;
+	}(_filter_node2.default);
 
+	exports.default = TreeFilter;
 
 /***/ },
 /* 14 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var CheckboxFilter, CheckboxOption, FilterCollectionNode,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _checkbox_option = __webpack_require__(15);
+
+	var _checkbox_option2 = _interopRequireDefault(_checkbox_option);
+
+	var _filter_collection_node = __webpack_require__(10);
 
-	CheckboxOption = __webpack_require__(15);
+	var _filter_collection_node2 = _interopRequireDefault(_filter_collection_node);
 
-	FilterCollectionNode = __webpack_require__(10);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	CheckboxFilter = (function(_super) {
-	  __extends(CheckboxFilter, _super);
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+	var CheckboxFilter = function (_FilterCollectionNode) {
+	  _inherits(CheckboxFilter, _FilterCollectionNode);
 
 	  function CheckboxFilter(filter, name, filterDefinition) {
-	    CheckboxFilter.__super__.constructor.call(this, filter, name, filterDefinition);
-	    this.type = 'checkbox';
-	    this.children = _.map(filterDefinition.options, (function(_this) {
-	      return function(definition, name) {
-	        return new CheckboxOption(_this.filter, name, definition);
-	      };
-	    })(this));
-	  }
+	    _classCallCheck(this, CheckboxFilter);
 
-	  return CheckboxFilter;
+	    var _this = _possibleConstructorReturn(this, (CheckboxFilter.__proto__ || Object.getPrototypeOf(CheckboxFilter)).call(this, filter, name, filterDefinition));
 
-	})(FilterCollectionNode);
+	    _this.type = 'checkbox';
+	    _this.children = _.map(filterDefinition.options, function (definition, title) {
+	      return new _checkbox_option2.default(filter, title, definition);
+	    });
+	    return _this;
+	  }
 
-	module.exports = CheckboxFilter;
+	  return CheckboxFilter;
+	}(_filter_collection_node2.default);
 
+	exports.default = CheckboxFilter;
 
 /***/ },
 /* 15 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var CheckboxOption, FilterNode,
-	  __hasProp = {}.hasOwnProperty,
-	  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-	FilterNode = __webpack_require__(11);
-
-	CheckboxOption = (function(_super) {
-	  __extends(CheckboxOption, _super);
+	'use strict';
 
-	  function CheckboxOption(filter, name, filterDefinition) {
-	    CheckboxOption.__super__.constructor.call(this, filter, name, filterDefinition);
-	    this.value = filterDefinition.value, this.preset = filterDefinition.preset, this.enable_create = filterDefinition.enable_create;
-	    this.active = filterDefinition.selected;
-	  }
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	  CheckboxOption.prototype.toggleActive = function() {
-	    this.active = !this.active;
-	    return this.filter.changed();
-	  };
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	  CheckboxOption.prototype.isActive = function() {
-	    return !!this.active;
-	  };
+	var _filter_node = __webpack_require__(11);
 
-	  return CheckboxOption;
+	var _filter_node2 = _interopRequireDefault(_filter_node);
 
-	})(FilterNode);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	module.exports = CheckboxOption;
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
+	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
 
-/***/ },
-/* 16 */
-/***/ function(module, exports) {
+	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-	var ASC_SORT_ORDER, CHANGE_SORT_ORDER, DESC_SORT_ORDER, sortInAscOrder, sortInDescOrder, _changeSortOrder;
+	var CheckboxOption = function (_FilterNode) {
+	  _inherits(CheckboxOption, _FilterNode);
 
-	CHANGE_SORT_ORDER = 'CHANGE_SORT_ORDER';
+	  function CheckboxOption(filter, name, filterDefinition) {
+	    _classCallCheck(this, CheckboxOption);
 
-	ASC_SORT_ORDER = 'asc';
+	    var _this = _possibleConstructorReturn(this, (CheckboxOption.__proto__ || Object.getPrototypeOf(CheckboxOption)).call(this, filter, name, filterDefinition));
 
-	DESC_SORT_ORDER = 'desc';
+	    _this.value = filterDefinition.value;
+	    _this.preset = filterDefinition.preset;
+	    _this.enable_create = filterDefinition.enable_create;
 
-	_changeSortOrder = (function(_this) {
-	  return function(criteriaType, sortDirection) {
-	    return {
-	      type: CHANGE_SORT_ORDER,
-	      criteriaType: criteriaType,
-	      sortDirection: sortDirection
-	    };
-	  };
-	})(this);
 
-	sortInAscOrder = (function(_this) {
-	  return function(criteriaType) {
-	    return _changeSortOrder(criteriaType, ASC_SORT_ORDER);
-	  };
-	})(this);
+	    _this.active = filterDefinition.selected;
+	    return _this;
+	  }
 
-	sortInDescOrder = (function(_this) {
-	  return function(criteriaType) {
-	    return _changeSortOrder(criteriaType, DESC_SORT_ORDER);
-	  };
-	})(this);
+	  _createClass(CheckboxOption, [{
+	    key: 'toggleActive',
+	    value: function toggleActive() {
+	      this.active = !this.active;
+	      return this.filter.changed();
+	    }
+	  }, {
+	    key: 'isActive',
+	    value: function isActive() {
+	      return !!this.active;
+	    }
+	  }]);
 
-	module.exports = {
-	  CHANGE_SORT_ORDER: CHANGE_SORT_ORDER,
-	  ASC_SORT_ORDER: ASC_SORT_ORDER,
-	  DESC_SORT_ORDER: DESC_SORT_ORDER,
-	  sortInDescOrder: sortInDescOrder,
-	  sortInAscOrder: sortInAscOrder
-	};
+	  return CheckboxOption;
+	}(_filter_node2.default);
 
+	exports.default = CheckboxOption;
 
 /***/ },
-/* 17 */
+/* 16 */
 /***/ function(module, exports) {
 
-	var defaultFilterDefinition;
+	'use strict';
 
-	defaultFilterDefinition = function(context) {
-	  return {
-	    _obj_class: {
-	      options: context._image ? {
-	        Images: {
-	          icon: 'image',
-	          selected: true,
-	          query: scrivito.obj_where('_obj_class', 'equals', 'Image'),
-	          preset: {
-	            _obj_class: 'Image'
-	          }
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = defaultFilterDefinition;
+	function defaultFilterDefinition(context) {
+	  var options = void 0;
+	  if (context._image) {
+	    options = {
+	      Images: {
+	        icon: 'image',
+	        selected: true,
+	        query: scrivito.obj_where('_obj_class', 'equals', 'Image'),
+	        preset: {
+	          _obj_class: 'Image'
 	        }
-	      } : {
-	        All: {
-	          icon: 'generic',
-	          selected: true,
-	          query: scrivito.obj_where('_last_changed', 'is_greater_than', new Date(0))
-	        },
-	        Images: {
-	          icon: 'image',
-	          query: scrivito.obj_where('_obj_class', 'equals', 'Image'),
-	          preset: {
-	            _obj_class: 'Image'
-	          }
-	        },
-	        Downloads: {
-	          query: scrivito.obj_where('_obj_class', 'equals', 'Download'),
-	          icon: 'zip',
-	          preset: {
-	            _obj_class: 'Download'
-	          }
+	      }
+	    };
+	  } else {
+	    options = {
+	      All: {
+	        icon: 'generic',
+	        selected: true,
+	        query: scrivito.obj_where('_last_changed', 'is_greater_than', new Date(0))
+	      },
+	      Images: {
+	        icon: 'image',
+	        query: scrivito.obj_where('_obj_class', 'equals', 'Image'),
+	        preset: {
+	          _obj_class: 'Image'
+	        }
+	      },
+	      Downloads: {
+	        query: scrivito.obj_where('_obj_class', 'equals', 'Download'),
+	        icon: 'zip',
+	        preset: {
+	          _obj_class: 'Download'
 	        }
 	      }
+	    };
+	  }
+	  return {
+	    _obj_class: {
+	      options: options
 	    },
 	    _last_changed: {
 	      title: 'Changed',
@@ -954,45 +1129,42 @@
 	      field: '_modification',
 	      operator: 'equals',
 	      options: {
-	        "New": {
-	          value: ["new"]
+	        New: {
+	          value: ['new']
 	        },
-	        "Edited": {
-	          value: ["edited"]
+	        Edited: {
+	          value: ['edited']
 	        }
 	      }
 	    }
 	  };
-	};
-
-	module.exports = defaultFilterDefinition;
-
+	}
 
 /***/ },
-/* 18 */
+/* 17 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var App, AppContainer, Filter, Footer, InspectorComponent, Items, LAST_ADDED, ReactRedux, TopBar, changeSelectionMode, createObj, deselectObjs, disableTags, fetchTags, objDeleted, redux, setObjSource, toggleSelect, _ref, _ref1, _ref2, _ref3;
 
-	TopBar = __webpack_require__(19);
+	TopBar = __webpack_require__(18);
 
 	Filter = __webpack_require__(61);
 
 	Items = __webpack_require__(74);
 
-	InspectorComponent = __webpack_require__(108);
+	InspectorComponent = __webpack_require__(108)["default"];
 
 	Footer = __webpack_require__(113);
 
-	ReactRedux = __webpack_require__(25);
+	ReactRedux = __webpack_require__(24);
 
-	redux = __webpack_require__(34);
+	redux = __webpack_require__(33);
 
 	_ref = __webpack_require__(72), setObjSource = _ref.setObjSource, LAST_ADDED = _ref.LAST_ADDED;
 
 	_ref1 = __webpack_require__(112), createObj = _ref1.createObj, objDeleted = _ref1.objDeleted;
 
-	_ref2 = __webpack_require__(104), fetchTags = _ref2.fetchTags, disableTags = _ref2.disableTags;
+	_ref2 = __webpack_require__(105), fetchTags = _ref2.fetchTags, disableTags = _ref2.disableTags;
 
 	_ref3 = __webpack_require__(60), toggleSelect = _ref3.toggleSelect, changeSelectionMode = _ref3.changeSelectionMode, deselectObjs = _ref3.deselectObjs;
 
@@ -1108,24 +1280,27 @@
 	  };
 	})(this))(App);
 
-	module.exports = AppContainer;
+	module.exports = {
+	  App: App,
+	  AppContainer: AppContainer
+	};
 
 
 /***/ },
-/* 19 */
+/* 18 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var SearchBar, SelectionModeToggle, SortMenu, TopBar, ViewModeBar, connect, mapStateToProps;
 
-	ViewModeBar = __webpack_require__(20);
+	ViewModeBar = __webpack_require__(19);
 
-	SortMenu = __webpack_require__(23);
+	SortMenu = __webpack_require__(22);
 
 	SearchBar = __webpack_require__(56);
 
 	SelectionModeToggle = __webpack_require__(59);
 
-	connect = __webpack_require__(25).connect;
+	connect = __webpack_require__(24).connect;
 
 	TopBar = React.createClass({
 	  displayName: 'TopBar',
@@ -1159,14 +1334,14 @@
 
 
 /***/ },
-/* 20 */
+/* 19 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var TABLE_VIEW, THUMBNAIL_VIEW, ViewModeBar, ViewModeBarItem, setViewMode, _ref;
 
-	ViewModeBarItem = __webpack_require__(21);
+	ViewModeBarItem = __webpack_require__(20);
 
-	_ref = __webpack_require__(22), THUMBNAIL_VIEW = _ref.THUMBNAIL_VIEW, TABLE_VIEW = _ref.TABLE_VIEW, setViewMode = _ref.setViewMode;
+	_ref = __webpack_require__(21), THUMBNAIL_VIEW = _ref.THUMBNAIL_VIEW, TABLE_VIEW = _ref.TABLE_VIEW, setViewMode = _ref.setViewMode;
 
 	ViewModeBar = React.createClass({
 	  displayName: 'ViewModeBar',
@@ -1198,7 +1373,7 @@
 
 
 /***/ },
-/* 21 */
+/* 20 */
 /***/ function(module, exports) {
 
 	var ViewModeBarItem;
@@ -1248,7 +1423,7 @@
 
 
 /***/ },
-/* 22 */
+/* 21 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -1266,16 +1441,16 @@
 	}
 
 /***/ },
-/* 23 */
+/* 22 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var ASC_SORT_ORDER, DESC_SORT_ORDER, ReactRedux, SortMenu, SortMenuItem, sortInAscOrder, sortInDescOrder, _ref;
 
-	SortMenuItem = __webpack_require__(24);
+	SortMenuItem = __webpack_require__(23);
 
-	ReactRedux = __webpack_require__(25);
+	ReactRedux = __webpack_require__(24);
 
-	_ref = __webpack_require__(16), sortInAscOrder = _ref.sortInAscOrder, sortInDescOrder = _ref.sortInDescOrder, DESC_SORT_ORDER = _ref.DESC_SORT_ORDER, ASC_SORT_ORDER = _ref.ASC_SORT_ORDER;
+	_ref = __webpack_require__(55), sortInAscOrder = _ref.sortInAscOrder, sortInDescOrder = _ref.sortInDescOrder, DESC_SORT_ORDER = _ref.DESC_SORT_ORDER, ASC_SORT_ORDER = _ref.ASC_SORT_ORDER;
 
 	SortMenu = React.createClass({
 	  displayName: 'SortMenu',
@@ -1373,7 +1548,7 @@
 
 
 /***/ },
-/* 24 */
+/* 23 */
 /***/ function(module, exports) {
 
 	var SortMenuItem;
@@ -1431,7 +1606,7 @@
 
 
 /***/ },
-/* 25 */
+/* 24 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -1440,11 +1615,11 @@
 
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-	var _react = __webpack_require__(26);
+	var _react = __webpack_require__(25);
 
 	var _react2 = _interopRequireDefault(_react);
 
-	var _componentsCreateAll = __webpack_require__(27);
+	var _componentsCreateAll = __webpack_require__(26);
 
 	var _componentsCreateAll2 = _interopRequireDefault(_componentsCreateAll);
 
@@ -1456,13 +1631,13 @@
 	exports.connect = connect;
 
 /***/ },
-/* 26 */
+/* 25 */
 /***/ function(module, exports) {
 
 	module.exports = React;
 
 /***/ },
-/* 27 */
+/* 26 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -1472,11 +1647,11 @@
 
 	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
 
-	var _createProvider = __webpack_require__(28);
+	var _createProvider = __webpack_require__(27);
 
 	var _createProvider2 = _interopRequireDefault(_createProvider);
 
-	var _createConnect = __webpack_require__(30);
+	var _createConnect = __webpack_require__(29);
 
 	var _createConnect2 = _interopRequireDefault(_createConnect);
 
@@ -1490,7 +1665,7 @@
 	module.exports = exports['default'];
 
 /***/ },
-/* 28 */
+/* 27 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -1507,7 +1682,7 @@
 
 	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-	var _utilsCreateStoreShape = __webpack_require__(29);
+	var _utilsCreateStoreShape = __webpack_require__(28);
 
 	var _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);
 
@@ -1622,7 +1797,7 @@
 	module.exports = exports['default'];
 
 /***/ },
-/* 29 */
+/* 28 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -1641,7 +1816,7 @@
 	module.exports = exports["default"];
 
 /***/ },
-/* 30 */
+/* 29 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -1660,23 +1835,23 @@
 
 	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
-	var _utilsCreateStoreShape = __webpack_require__(29);
+	var _utilsCreateStoreShape = __webpack_require__(28);
 
 	var _utilsCreateStoreShape2 = _interopRequireDefault(_utilsCreateStoreShape);
 
-	var _utilsShallowEqual = __webpack_require__(31);
+	var _utilsShallowEqual = __webpack_require__(30);
 
 	var _utilsShallowEqual2 = _interopRequireDefault(_utilsShallowEqual);
 
-	var _utilsIsPlainObject = __webpack_require__(32);
+	var _utilsIsPlainObject = __webpack_require__(31);
 
 	var _utilsIsPlainObject2 = _interopRequireDefault(_utilsIsPlainObject);
 
-	var _utilsWrapActionCreators = __webpack_require__(33);
+	var _utilsWrapActionCreators = __webpack_require__(32);
 
 	var _utilsWrapActionCreators2 = _interopRequireDefault(_utilsWrapActionCreators);
 
-	var _invariant = __webpack_require__(55);
+	var _invariant = __webpack_require__(54);
 
 	var _invariant2 = _interopRequireDefault(_invariant);
 
@@ -1915,7 +2090,7 @@
 	module.exports = exports['default'];
 
 /***/ },
-/* 31 */
+/* 30 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -1949,7 +2124,7 @@
 	module.exports = exports["default"];
 
 /***/ },
-/* 32 */
+/* 31 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -1984,7 +2159,7 @@
 	module.exports = exports['default'];
 
 /***/ },
-/* 33 */
+/* 32 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -1992,7 +2167,7 @@
 	exports.__esModule = true;
 	exports['default'] = wrapActionCreators;
 
-	var _redux = __webpack_require__(34);
+	var _redux = __webpack_require__(33);
 
 	function wrapActionCreators(actionCreators) {
 	  return function (dispatch) {
@@ -2003,7 +2178,7 @@
 	module.exports = exports['default'];
 
 /***/ },
-/* 34 */
+/* 33 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -2011,27 +2186,27 @@
 	exports.__esModule = true;
 	exports.compose = exports.applyMiddleware = exports.bindActionCreators = exports.combineReducers = exports.createStore = undefined;
 
-	var _createStore = __webpack_require__(35);
+	var _createStore = __webpack_require__(34);
 
 	var _createStore2 = _interopRequireDefault(_createStore);
 
-	var _combineReducers = __webpack_require__(50);
+	var _combineReducers = __webpack_require__(49);
 
 	var _combineReducers2 = _interopRequireDefault(_combineReducers);
 
-	var _bindActionCreators = __webpack_require__(52);
+	var _bindActionCreators = __webpack_require__(51);
 
 	var _bindActionCreators2 = _interopRequireDefault(_bindActionCreators);
 
-	var _applyMiddleware = __webpack_require__(53);
+	var _applyMiddleware = __webpack_require__(52);
 
 	var _applyMiddleware2 = _interopRequireDefault(_applyMiddleware);
 
-	var _compose = __webpack_require__(54);
+	var _compose = __webpack_require__(53);
 
 	var _compose2 = _interopRequireDefault(_compose);
 
-	var _warning = __webpack_require__(51);
+	var _warning = __webpack_require__(50);
 
 	var _warning2 = _interopRequireDefault(_warning);
 
@@ -2054,7 +2229,7 @@
 	exports.compose = _compose2['default'];
 
 /***/ },
-/* 35 */
+/* 34 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -2063,11 +2238,11 @@
 	exports.ActionTypes = undefined;
 	exports['default'] = createStore;
 
-	var _isPlainObject = __webpack_require__(36);
+	var _isPlainObject = __webpack_require__(35);
 
 	var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
 
-	var _symbolObservable = __webpack_require__(46);
+	var _symbolObservable = __webpack_require__(45);
 
 	var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
 
@@ -2320,12 +2495,12 @@
 	}
 
 /***/ },
-/* 36 */
+/* 35 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var baseGetTag = __webpack_require__(37),
-	    getPrototype = __webpack_require__(43),
-	    isObjectLike = __webpack_require__(45);
+	var baseGetTag = __webpack_require__(36),
+	    getPrototype = __webpack_require__(42),
+	    isObjectLike = __webpack_require__(44);
 
 	/** `Object#toString` result references. */
 	var objectTag = '[object Object]';
@@ -2388,12 +2563,12 @@
 
 
 /***/ },
-/* 37 */
+/* 36 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var Symbol = __webpack_require__(38),
-	    getRawTag = __webpack_require__(41),
-	    objectToString = __webpack_require__(42);
+	var Symbol = __webpack_require__(37),
+	    getRawTag = __webpack_require__(40),
+	    objectToString = __webpack_require__(41);
 
 	/** `Object#toString` result references. */
 	var nullTag = '[object Null]',
@@ -2422,10 +2597,10 @@
 
 
 /***/ },
-/* 38 */
+/* 37 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var root = __webpack_require__(39);
+	var root = __webpack_require__(38);
 
 	/** Built-in value references. */
 	var Symbol = root.Symbol;
@@ -2434,10 +2609,10 @@
 
 
 /***/ },
-/* 39 */
+/* 38 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var freeGlobal = __webpack_require__(40);
+	var freeGlobal = __webpack_require__(39);
 
 	/** Detect free variable `self`. */
 	var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
@@ -2449,7 +2624,7 @@
 
 
 /***/ },
-/* 40 */
+/* 39 */
 /***/ function(module, exports) {
 
 	/* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
@@ -2460,10 +2635,10 @@
 	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
 
 /***/ },
-/* 41 */
+/* 40 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var Symbol = __webpack_require__(38);
+	var Symbol = __webpack_require__(37);
 
 	/** Used for built-in method references. */
 	var objectProto = Object.prototype;
@@ -2512,7 +2687,7 @@
 
 
 /***/ },
-/* 42 */
+/* 41 */
 /***/ function(module, exports) {
 
 	/** Used for built-in method references. */
@@ -2540,10 +2715,10 @@
 
 
 /***/ },
-/* 43 */
+/* 42 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var overArg = __webpack_require__(44);
+	var overArg = __webpack_require__(43);
 
 	/** Built-in value references. */
 	var getPrototype = overArg(Object.getPrototypeOf, Object);
@@ -2552,7 +2727,7 @@
 
 
 /***/ },
-/* 44 */
+/* 43 */
 /***/ function(module, exports) {
 
 	/**
@@ -2573,7 +2748,7 @@
 
 
 /***/ },
-/* 45 */
+/* 44 */
 /***/ function(module, exports) {
 
 	/**
@@ -2608,14 +2783,14 @@
 
 
 /***/ },
-/* 46 */
+/* 45 */
 /***/ function(module, exports, __webpack_require__) {
 
-	module.exports = __webpack_require__(47);
+	module.exports = __webpack_require__(46);
 
 
 /***/ },
-/* 47 */
+/* 46 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/* WEBPACK VAR INJECTION */(function(global, module) {'use strict';
@@ -2624,7 +2799,7 @@
 	  value: true
 	});
 
-	var _ponyfill = __webpack_require__(49);
+	var _ponyfill = __webpack_require__(48);
 
 	var _ponyfill2 = _interopRequireDefault(_ponyfill);
 
@@ -2647,10 +2822,10 @@
 
 	var result = (0, _ponyfill2['default'])(root);
 	exports['default'] = result;
-	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(48)(module)))
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(47)(module)))
 
 /***/ },
-/* 48 */
+/* 47 */
 /***/ function(module, exports) {
 
 	module.exports = function(module) {
@@ -2666,7 +2841,7 @@
 
 
 /***/ },
-/* 49 */
+/* 48 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -2694,7 +2869,7 @@
 	};
 
 /***/ },
-/* 50 */
+/* 49 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -2702,13 +2877,13 @@
 	exports.__esModule = true;
 	exports['default'] = combineReducers;
 
-	var _createStore = __webpack_require__(35);
+	var _createStore = __webpack_require__(34);
 
-	var _isPlainObject = __webpack_require__(36);
+	var _isPlainObject = __webpack_require__(35);
 
 	var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
 
-	var _warning = __webpack_require__(51);
+	var _warning = __webpack_require__(50);
 
 	var _warning2 = _interopRequireDefault(_warning);
 
@@ -2841,7 +3016,7 @@
 	}
 
 /***/ },
-/* 51 */
+/* 50 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -2871,7 +3046,7 @@
 	}
 
 /***/ },
-/* 52 */
+/* 51 */
 /***/ function(module, exports) {
 
 	'use strict';
@@ -2927,7 +3102,7 @@
 	}
 
 /***/ },
-/* 53 */
+/* 52 */
 /***/ function(module, exports, __webpack_require__) {
 
 	'use strict';
@@ -2938,7 +3113,7 @@
 
 	exports['default'] = applyMiddleware;
 
-	var _compose = __webpack_require__(54);
+	var _compose = __webpack_require__(53);
 
 	var _compose2 = _interopRequireDefault(_compose);
 
@@ -2990,7 +3165,7 @@
 	}
 
 /***/ },
-/* 54 */
+/* 53 */
 /***/ function(module, exports) {
 
 	"use strict";
@@ -3033,7 +3208,7 @@
 	}
 
 /***/ },
-/* 55 */
+/* 54 */
 /***/ function(module, exports, __webpack_require__) {
 
 	/**
@@ -3089,13 +3264,40 @@
 	module.exports = invariant;
 
 
+/***/ },
+/* 55 */
+/***/ function(module, exports) {
+
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.sortInAscOrder = sortInAscOrder;
+	exports.sortInDescOrder = sortInDescOrder;
+	var CHANGE_SORT_ORDER = exports.CHANGE_SORT_ORDER = 'CHANGE_SORT_ORDER';
+	var ASC_SORT_ORDER = exports.ASC_SORT_ORDER = 'asc';
+	var DESC_SORT_ORDER = exports.DESC_SORT_ORDER = 'desc';
+
+	function changeSortOrder(criteriaType, sortDirection) {
+	  return { type: CHANGE_SORT_ORDER, criteriaType: criteriaType, sortDirection: sortDirection };
+	}
+
+	function sortInAscOrder(criteriaType) {
+	  return changeSortOrder(criteriaType, ASC_SORT_ORDER);
+	}
+
+	function sortInDescOrder(criteriaType) {
+	  return changeSortOrder(criteriaType, DESC_SORT_ORDER);
+	}
+
 /***/ },
 /* 56 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var ActiveNodeConfigCollector, SearchBar;
 
-	ActiveNodeConfigCollector = __webpack_require__(57);
+	ActiveNodeConfigCollector = __webpack_require__(57)["default"];
 
 	SearchBar = React.createClass({
 	  displayName: 'SearchBar',
@@ -3185,172 +3387,205 @@
 /* 57 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ActiveNodeConfig, ActiveNodeConfigCollector;
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _active_node_config = __webpack_require__(58);
+
+	var _active_node_config2 = _interopRequireDefault(_active_node_config);
 
-	ActiveNodeConfig = __webpack_require__(58);
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	ActiveNodeConfigCollector = (function() {
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var ActiveNodeConfigCollector = function () {
 	  function ActiveNodeConfigCollector(filter) {
-	    this._filter = filter;
+	    _classCallCheck(this, ActiveNodeConfigCollector);
+
+	    this.filter = filter;
 	  }
 
-	  ActiveNodeConfigCollector.prototype.findActiveFilterItems = function() {
-	    var filterItems, treeFilterItem;
-	    filterItems = this._findActiveAdditionalFilters();
-	    treeFilterItem = this._findActiveTreeFilterItem();
-	    if (treeFilterItem) {
-	      filterItems.unshift(treeFilterItem);
-	    }
-	    return filterItems;
-	  };
+	  _createClass(ActiveNodeConfigCollector, [{
+	    key: 'findActiveFilterItems',
+	    value: function findActiveFilterItems() {
+	      var filterItems = this.findActiveAdditionalFilters();
+	      var treeFilterItem = this.findActiveTreeFilterItem();
 
-	  ActiveNodeConfigCollector.prototype._findActiveTreeFilterItem = function() {
-	    var activeConfig, subFilter, treeFilter, _i, _j, _len, _len1, _ref, _ref1;
-	    _ref = this._filter.getTreeFilters();
-	    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	      treeFilter = _ref[_i];
-	      _ref1 = treeFilter.subFilters;
-	      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
-	        subFilter = _ref1[_j];
-	        activeConfig = this._findActiveSubFilterItem(subFilter);
-	        if (activeConfig) {
-	          activeConfig.parents.push(treeFilter.config);
-	          return new ActiveNodeConfig(activeConfig.parents, [activeConfig.node]);
-	        }
+	      if (treeFilterItem) {
+	        filterItems.unshift(treeFilterItem);
 	      }
+	      return filterItems;
 	    }
-	  };
+	  }, {
+	    key: 'findActiveTreeFilterItem',
+	    value: function findActiveTreeFilterItem() {
+	      var _this = this;
+
+	      var activeTreeFilterItem = null;
+	      _.each(this.filter.getTreeFilters(), function (treeFilter) {
+	        _.each(treeFilter.subFilters, function (subFilter) {
+	          var activeConfig = _this.findActiveSubFilterItem(subFilter);
+
+	          if (activeConfig) {
+	            activeConfig.parents.push(treeFilter.config);
+	            activeTreeFilterItem = new _active_node_config2.default(activeConfig.parents, [activeConfig.node]);
+	          }
+	        });
+	      });
 
-	  ActiveNodeConfigCollector.prototype._findActiveAdditionalFilters = function() {
-	    var activeChildren, activeFilters, additionalFilter, _i, _len, _ref;
-	    activeFilters = [];
-	    _ref = this._filter.additionalFilters;
-	    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	      additionalFilter = _ref[_i];
-	      activeChildren = _.filter(additionalFilter.children, function(child) {
-	        return child.isActive();
+	      return activeTreeFilterItem;
+	    }
+	  }, {
+	    key: 'findActiveAdditionalFilters',
+	    value: function findActiveAdditionalFilters() {
+	      var activeFilters = [];
+	      _.each(this.filter.additionalFilters, function (additionalFilter) {
+	        var activeChildren = _.filter(additionalFilter.children, function (child) {
+	          return child.isActive();
+	        });
+
+	        if (activeChildren.length > 0) {
+	          activeFilters.push(new _active_node_config2.default([additionalFilter], activeChildren));
+	        }
 	      });
-	      if (activeChildren.length > 0) {
-	        activeFilters.push(new ActiveNodeConfig([additionalFilter], activeChildren));
-	      }
+
+	      return activeFilters;
 	    }
-	    return activeFilters;
-	  };
+	  }, {
+	    key: 'findActiveSubFilterItem',
+	    value: function findActiveSubFilterItem(filterNode) {
+	      var _this2 = this;
 
-	  ActiveNodeConfigCollector.prototype._findActiveSubFilterItem = function(filterNode) {
-	    var activeConfig, childNode, _i, _len, _ref;
-	    if (filterNode.isActive()) {
-	      return {
-	        node: filterNode,
-	        parents: []
-	      };
-	    } else {
-	      _ref = filterNode.children;
-	      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	        childNode = _ref[_i];
-	        activeConfig = this._findActiveSubFilterItem(childNode);
+	      if (filterNode.isActive()) {
+	        return { node: filterNode, parents: [] };
+	      }
+
+	      var activeConfig = void 0;
+
+	      _.some(filterNode.children, function (childNode) {
+	        activeConfig = _this2.findActiveSubFilterItem(childNode);
 	        if (activeConfig) {
 	          activeConfig.parents.push(filterNode);
 	          return activeConfig;
 	        }
-	      }
+	      });
+	      return activeConfig;
 	    }
-	  };
+	  }]);
 
 	  return ActiveNodeConfigCollector;
+	}();
 
-	})();
-
-	module.exports = ActiveNodeConfigCollector;
-
+	exports.default = ActiveNodeConfigCollector;
 
 /***/ },
 /* 58 */
 /***/ function(module, exports) {
 
-	var ActiveNodeConfig;
-
-	ActiveNodeConfig = (function() {
-	  function ActiveNodeConfig(parents, nodes) {
-	    this._parents = parents;
-	    this._activeNodes = nodes;
-	  }
+	'use strict';
 
-	  ActiveNodeConfig.prototype.activeNodes = function() {
-	    return this._activeNodes;
-	  };
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	  ActiveNodeConfig.prototype.values = function() {
-	    return _.flatten(_.map(this._activeNodes, this._valueForNode));
-	  };
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	  ActiveNodeConfig.prototype.query = function() {
-	    return this._filter().type !== 'checkbox' && this._activeNodes[0].query;
-	  };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	  ActiveNodeConfig.prototype.hasQuery = function() {
-	    return !!this.query();
-	  };
-
-	  ActiveNodeConfig.prototype.field = function() {
-	    return this._findConfig('field');
-	  };
+	var valueForNode = function valueForNode(node) {
+	  if (node.value === undefined) {
+	    return node.name;
+	  }
+	  return node.value;
+	};
 
-	  ActiveNodeConfig.prototype.hasField = function() {
-	    return !!this.field();
-	  };
+	var findConfig = function findConfig(attrName, activeNodes, parents) {
+	  var activeNode = activeNodes[0];
+	  if (_.last(parents).type !== 'checkbox' && activeNode[attrName]) {
+	    return activeNode[attrName];
+	  }
 
-	  ActiveNodeConfig.prototype.preventsCreation = function() {
-	    return this.nodesPreventingCreation().length > 0;
-	  };
+	  var parentWithAttribute = _.find(parents, function (node) {
+	    return node[attrName];
+	  });
+	  return parentWithAttribute && parentWithAttribute[attrName];
+	};
 
-	  ActiveNodeConfig.prototype.nodesPreventingCreation = function() {
-	    return _.select(this.activeNodes(), function(node) {
-	      return node.enable_create === false;
-	    });
-	  };
+	// This class is tested in the QueryBuilder specs for now
 
-	  ActiveNodeConfig.prototype.enablesCreation = function() {
-	    return _.some(this.activeNodes(), function(node) {
-	      return node.enable_create === true;
-	    });
-	  };
+	var ActiveNodeConfig = function () {
+	  function ActiveNodeConfig(parentNodes, nodes) {
+	    _classCallCheck(this, ActiveNodeConfig);
 
-	  ActiveNodeConfig.prototype.operator = function() {
-	    return this._findConfig('operator') || 'equals';
-	  };
+	    this.parents = parentNodes;
+	    this.nodes = nodes;
+	  }
 
-	  ActiveNodeConfig.prototype._valueForNode = function(node) {
-	    if (node.value === void 0) {
-	      return node.name;
-	    } else {
-	      return node.value;
+	  _createClass(ActiveNodeConfig, [{
+	    key: 'activeNodes',
+	    value: function activeNodes() {
+	      return this.nodes;
 	    }
-	  };
-
-	  ActiveNodeConfig.prototype._findConfig = function(attrName) {
-	    var activeNode, parentWithAttribute;
-	    activeNode = this._activeNodes[0];
-	    if (this._filter().type !== 'checkbox' && activeNode[attrName]) {
-	      return activeNode[attrName];
-	    } else {
-	      parentWithAttribute = _.find(this._parents, function(node) {
-	        return node[attrName];
+	  }, {
+	    key: 'values',
+	    value: function values() {
+	      return _.flatten(_.map(this.activeNodes(), valueForNode));
+	    }
+	  }, {
+	    key: 'query',
+	    value: function query() {
+	      return _.last(this.parents).type !== 'checkbox' && this.activeNodes()[0].query;
+	    }
+	  }, {
+	    key: 'hasQuery',
+	    value: function hasQuery() {
+	      return !!this.query();
+	    }
+	  }, {
+	    key: 'field',
+	    value: function field() {
+	      return findConfig('field', this.activeNodes(), this.parents);
+	    }
+	  }, {
+	    key: 'hasField',
+	    value: function hasField() {
+	      return !!this.field();
+	    }
+	  }, {
+	    key: 'preventsCreation',
+	    value: function preventsCreation() {
+	      return this.nodesPreventingCreation().length > 0;
+	    }
+	  }, {
+	    key: 'nodesPreventingCreation',
+	    value: function nodesPreventingCreation() {
+	      return _.select(this.activeNodes(), function (node) {
+	        return node.enable_create === false;
 	      });
-	      return parentWithAttribute && parentWithAttribute[attrName];
 	    }
-	  };
-
-	  ActiveNodeConfig.prototype._filter = function() {
-	    return _.last(this._parents);
-	  };
+	  }, {
+	    key: 'enablesCreation',
+	    value: function enablesCreation() {
+	      return _.some(this.activeNodes(), function (node) {
+	        return node.enable_create === true;
+	      });
+	    }
+	  }, {
+	    key: 'operator',
+	    value: function operator() {
+	      return findConfig('operator', this.activeNodes(), this.parents) || 'equals';
+	    }
+	  }]);
 
 	  return ActiveNodeConfig;
+	}();
 
-	})();
-
-	module.exports = ActiveNodeConfig;
-
+	exports.default = ActiveNodeConfig;
 
 /***/ },
 /* 59 */
@@ -3394,53 +3629,31 @@
 /* 60 */
 /***/ function(module, exports) {
 
-	var CHANGE_SELECTION_MODE, DESELECT_OBJS, MULTI_SELECTION_MODE, SINGLE_SELECTION_MODE, TOGGLE_SELECT, changeSelectionMode, deselectObjs, toggleSelect;
-
-	TOGGLE_SELECT = 'TOGGLE_SELECT';
-
-	DESELECT_OBJS = 'DESELECT_OBJS';
-
-	CHANGE_SELECTION_MODE = 'CHANGE_SELECTION_MODE';
-
-	SINGLE_SELECTION_MODE = 'single';
-
-	MULTI_SELECTION_MODE = 'multi';
-
-	toggleSelect = (function(_this) {
-	  return function(objId) {
-	    return {
-	      type: TOGGLE_SELECT,
-	      objId: objId
-	    };
-	  };
-	})(this);
-
-	changeSelectionMode = (function(_this) {
-	  return function(mode) {
-	    return {
-	      type: CHANGE_SELECTION_MODE,
-	      mode: mode
-	    };
-	  };
-	})(this);
+	'use strict';
 
-	deselectObjs = function() {
-	  return {
-	    type: DESELECT_OBJS
-	  };
-	};
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.toggleSelect = toggleSelect;
+	exports.changeSelectionMode = changeSelectionMode;
+	exports.deselectObjs = deselectObjs;
+	var TOGGLE_SELECT = exports.TOGGLE_SELECT = 'TOGGLE_SELECT';
+	var DESELECT_OBJS = exports.DESELECT_OBJS = 'DESELECT_OBJS';
+	var CHANGE_SELECTION_MODE = exports.CHANGE_SELECTION_MODE = 'CHANGE_SELECTION_MODE';
+	var SINGLE_SELECTION_MODE = exports.SINGLE_SELECTION_MODE = 'single';
+	var MULTI_SELECTION_MODE = exports.MULTI_SELECTION_MODE = 'multi';
+
+	function toggleSelect(objId) {
+	  return { type: TOGGLE_SELECT, objId: objId };
+	}
 
-	module.exports = {
-	  DESELECT_OBJS: DESELECT_OBJS,
-	  TOGGLE_SELECT: TOGGLE_SELECT,
-	  CHANGE_SELECTION_MODE: CHANGE_SELECTION_MODE,
-	  SINGLE_SELECTION_MODE: SINGLE_SELECTION_MODE,
-	  MULTI_SELECTION_MODE: MULTI_SELECTION_MODE,
-	  toggleSelect: toggleSelect,
-	  changeSelectionMode: changeSelectionMode,
-	  deselectObjs: deselectObjs
-	};
+	function changeSelectionMode(mode) {
+	  return { type: CHANGE_SELECTION_MODE, mode: mode };
+	}
 
+	function deselectObjs() {
+	  return { type: DESELECT_OBJS };
+	}
 
 /***/ },
 /* 61 */
@@ -3914,33 +4127,20 @@
 /* 72 */
 /***/ function(module, exports) {
 
-	var FILTER, LAST_ADDED, SELECTED, SET_OBJ_SOURCE, setObjSource;
-
-	SET_OBJ_SOURCE = 'SET_OBJ_SOURCE';
-
-	FILTER = 'FILTER';
-
-	LAST_ADDED = 'LAST_ADDED';
-
-	SELECTED = 'SELECTED';
-
-	setObjSource = (function(_this) {
-	  return function(activeSource) {
-	    return {
-	      type: SET_OBJ_SOURCE,
-	      activeSource: activeSource
-	    };
-	  };
-	})(this);
-
-	module.exports = {
-	  SET_OBJ_SOURCE: SET_OBJ_SOURCE,
-	  LAST_ADDED: LAST_ADDED,
-	  FILTER: FILTER,
-	  SELECTED: SELECTED,
-	  setObjSource: setObjSource
-	};
+	'use strict';
 
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.setObjSource = setObjSource;
+	var SET_OBJ_SOURCE = exports.SET_OBJ_SOURCE = 'SET_OBJ_SOURCE';
+	var FILTER = exports.FILTER = 'FILTER';
+	var LAST_ADDED = exports.LAST_ADDED = 'LAST_ADDED';
+	var SELECTED = exports.SELECTED = 'SELECTED';
+
+	function setObjSource(activeSource) {
+	  return { type: SET_OBJ_SOURCE, activeSource: activeSource };
+	}
 
 /***/ },
 /* 73 */
@@ -3979,15 +4179,15 @@
 /* 74 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var DEFAULT_NUMBER_TO_LOAD, FILTER, Items, LAST_ADDED, LastAddedItems, PresetBuilder, QueryBuilder, SELECTED, SelectedItems, TableView, TableViewContent, TagBar, ThumbnailItems, loadAllUntil, loadMoreObjs, loadWithDefault, objDisplayAction, toggleExpandTagBar, toggleTag, _ref, _ref1, _ref2, _ref3;
+	var DEFAULT_NUMBER_TO_LOAD, FILTER, Items, LAST_ADDED, LastAddedItems, PresetBuilder, QueryBuilder, SELECTED, SelectedItems, Spinner, TableView, TableViewContent, TagBar, ThumbnailItems, loadMoreObjs, objDisplayAction, toggleExpandTagBar, toggleTag, _ref, _ref1, _ref2;
 
 	TableView = __webpack_require__(75);
 
-	ThumbnailItems = __webpack_require__(76);
+	ThumbnailItems = __webpack_require__(76)["default"];
 
 	SelectedItems = __webpack_require__(87);
 
-	PresetBuilder = __webpack_require__(86);
+	PresetBuilder = __webpack_require__(86)["default"];
 
 	LastAddedItems = __webpack_require__(91);
 
@@ -3995,17 +4195,17 @@
 
 	TagBar = __webpack_require__(103);
 
-	objDisplayAction = __webpack_require__(22);
+	Spinner = __webpack_require__(104)["default"];
 
-	_ref = __webpack_require__(72), SELECTED = _ref.SELECTED, LAST_ADDED = _ref.LAST_ADDED, FILTER = _ref.FILTER;
+	objDisplayAction = __webpack_require__(21);
 
-	_ref1 = __webpack_require__(104), toggleExpandTagBar = _ref1.toggleExpandTagBar, toggleTag = _ref1.toggleTag;
+	_ref = __webpack_require__(72), SELECTED = _ref.SELECTED, LAST_ADDED = _ref.LAST_ADDED, FILTER = _ref.FILTER;
 
-	_ref2 = __webpack_require__(105), loadMoreObjs = _ref2.loadMoreObjs, DEFAULT_NUMBER_TO_LOAD = _ref2.DEFAULT_NUMBER_TO_LOAD;
+	_ref1 = __webpack_require__(105), toggleExpandTagBar = _ref1.toggleExpandTagBar, toggleTag = _ref1.toggleTag;
 
-	_ref3 = __webpack_require__(106), loadAllUntil = _ref3.loadAllUntil, loadWithDefault = _ref3.loadWithDefault;
+	_ref2 = __webpack_require__(106), loadMoreObjs = _ref2.loadMoreObjs, DEFAULT_NUMBER_TO_LOAD = _ref2.DEFAULT_NUMBER_TO_LOAD;
 
-	QueryBuilder = __webpack_require__(107);
+	QueryBuilder = __webpack_require__(107)["default"];
 
 	Items = scrivito.createReactClass({
 	  displayName: 'Items',
@@ -4078,9 +4278,9 @@
 	    };
 	  },
 	  _handleFileDrop: function(event) {
-	    var files, _ref4;
+	    var files, _ref3;
 	    this._changeDragState(false)(event);
-	    files = (_ref4 = event.dataTransfer) != null ? _ref4.files : void 0;
+	    files = (_ref3 = event.dataTransfer) != null ? _ref3.files : void 0;
 	    if (this.props.editingView && (files != null ? files.length : void 0)) {
 	      return this._uploadFiles(files);
 	    }
@@ -4130,7 +4330,7 @@
 	    tags = [];
 	    queryRequest = this._getQueryRequest();
 	    if (queryRequest && this.props.activeSource === FILTER) {
-	      tags = loadWithDefault(tags, function() {
+	      tags = scrivito.loadWithDefault(tags, function() {
 	        return queryRequest.facet('tags', {
 	          limit: 100
 	        });
@@ -4145,7 +4345,7 @@
 	    var queryRequest;
 	    queryRequest = this._getQueryRequest();
 	    if (queryRequest !== void 0) {
-	      return loadAllUntil(queryRequest.iterator(), this.props.numToLoad);
+	      return scrivito.loadAllUntil(queryRequest.iterator(), this.props.numToLoad);
 	    } else {
 	      return {
 	        objs: [],
@@ -4154,7 +4354,7 @@
 	    }
 	  },
 	  render: function() {
-	    var done, isLoading, objs, _ref4;
+	    var done, isLoading, objs, _ref3;
 	    return React.createElement("div", {
 	      "className": this.dropZoneClass(this._getTags()),
 	      "onDragOver": this._changeDragState(true),
@@ -4165,11 +4365,7 @@
 	      "toggleTag": this.toggleTagAction,
 	      "activeTags": this.props.tags.activeTags,
 	      "toggleExpandTagBar": this.toggleExpandTagBar
-	    }), ((_ref4 = this._loadObjs(), objs = _ref4.objs, done = _ref4.done, _ref4), isLoading = !done && objs.length < this.props.numToLoad, isLoading && this.props.numToLoad === DEFAULT_NUMBER_TO_LOAD ? React.createElement("div", {
-	      "className": "scrivito-content-browser-loading"
-	    }, React.createElement("i", {
-	      "className": "scrivito_icon scrivito_icon_refresh"
-	    })) : this.props.activeSource === SELECTED ? React.createElement(SelectedItems, {
+	    }), ((_ref3 = this._loadObjs(), objs = _ref3.objs, done = _ref3.done, _ref3), isLoading = !done && objs.length < this.props.numToLoad, isLoading && this.props.numToLoad === DEFAULT_NUMBER_TO_LOAD ? React.createElement(Spinner, null) : this.props.activeSource === SELECTED ? React.createElement(SelectedItems, {
 	      "selectionMode": this.props.selectionMode,
 	      "currentlyAndPreviouslySelectedObjIds": this.props.currentlyAndPreviouslySelectedObjIds,
 	      "toggleObjSelection": this.props.toggleObjSelection,
@@ -4252,71 +4448,102 @@
 /* 76 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var InfiniteScrollLoader, ObjCreation, ThumbnailAddItem, ThumbnailItem, ThumbnailItems;
+	'use strict';
 
-	ThumbnailItem = __webpack_require__(77);
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	ThumbnailAddItem = __webpack_require__(81);
+	var _thumbnail_item = __webpack_require__(77);
 
-	InfiniteScrollLoader = __webpack_require__(83);
+	var _thumbnail_item2 = _interopRequireDefault(_thumbnail_item);
 
-	ObjCreation = __webpack_require__(85);
+	var _thumbnail_add_item = __webpack_require__(81);
 
-	ThumbnailItems = scrivito.createReactClass({
-	  objCreation: function() {
-	    return new ObjCreation(this.props.filter);
+	var _thumbnail_add_item2 = _interopRequireDefault(_thumbnail_add_item);
+
+	var _infinite_scroll_loader = __webpack_require__(83);
+
+	var _infinite_scroll_loader2 = _interopRequireDefault(_infinite_scroll_loader);
+
+	var _obj_creation = __webpack_require__(85);
+
+	var _obj_creation2 = _interopRequireDefault(_obj_creation);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	var ThumbnailItems = scrivito.createReactClass({
+	  render: function render() {
+	    var _props = this.props,
+	        isLoading = _props.isLoading,
+	        fetch = _props.fetch,
+	        hasMore = _props.hasMore;
+
+
+	    return React.createElement(
+	      _infinite_scroll_loader2.default,
+	      {
+	        tag: 'ul',
+	        className: 'items scrivito-content-browser-thumbnails small',
+	        isLoading: isLoading,
+	        hasMore: hasMore,
+	        fetch: fetch
+	      },
+	      this._renderCreationItem(),
+	      this._renderItems()
+	    );
 	  },
-	  baseSelectClass: function() {
-	    return 'scrivito-content-browser-meta ';
+	  _renderCreationItem: function _renderCreationItem() {
+	    var _props2 = this.props,
+	        activeTags = _props2.activeTags,
+	        basePreset = _props2.basePreset,
+	        createObj = _props2.createObj,
+	        editingView = _props2.editingView,
+	        filter = _props2.filter;
+
+	    var objCreation = new _obj_creation2.default(filter);
+
+	    if (objCreation.showCreationItem() && editingView) {
+	      return React.createElement(_thumbnail_add_item2.default, {
+	        activeTags: activeTags,
+	        objCreation: objCreation,
+	        basePreset: basePreset,
+	        createObj: createObj
+	      });
+	    }
 	  },
-	  buildItems: function(objs) {
-	    var withoutDeleted;
-	    withoutDeleted = _.reject(objs, function(obj) {
+	  _renderItems: function _renderItems() {
+	    var _props3 = this.props,
+	        objs = _props3.objs,
+	        selectedObjs = _props3.selectedObjs,
+	        selectionMode = _props3.selectionMode,
+	        toggleObjSelection = _props3.toggleObjSelection;
+
+
+	    var withoutDeleted = _.reject(objs, function (obj) {
 	      return obj.isDeleted();
 	    });
-	    return _.map(withoutDeleted, (function(_this) {
-	      return function(obj) {
-	        return React.createElement(ThumbnailItem, {
-	          "key": obj.id,
-	          "selectedObjs": _this.props.selectedObjs,
-	          "objId": obj.id,
-	          "baseSelectClass": _this.baseSelectClass(),
-	          "toggleObjSelection": _this.props.toggleObjSelection,
-	          "selectionMode": _this.props.selectionMode
-	        });
-	      };
-	    })(this));
-	  },
-	  render: function() {
-	    return React.createElement(InfiniteScrollLoader, {
-	      "isLoading": this.props.isLoading,
-	      "hasMore": this.props.hasMore,
-	      "fetch": this.props.fetch,
-	      "tag": 'ul',
-	      "className": 'items scrivito-content-browser-thumbnails small'
-	    }, (this.objCreation().showCreationItem() && this.props.editingView ? React.createElement(ThumbnailAddItem, {
-	      "activeTags": this.props.activeTags,
-	      "objCreation": this.objCreation(),
-	      "basePreset": true,
-	      "props": true,
-	      "ps": true,
-	      "basePreset": true,
-	      "t": true,
-	      "createObj": this.props.createObj
-	    }) : void 0), this.buildItems(this.props.objs));
+	    return _.map(withoutDeleted, function (obj) {
+	      return React.createElement(_thumbnail_item2.default, { key: obj.id,
+	        selectedObjs: selectedObjs,
+	        objId: obj.id,
+	        baseSelectClass: 'scrivito-content-browser-meta',
+	        toggleObjSelection: toggleObjSelection,
+	        selectionMode: selectionMode
+	      });
+	    });
 	  }
 	});
 
-	module.exports = ThumbnailItems;
-
+	exports.default = ThumbnailItems;
 
 /***/ },
 /* 77 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var LoadableSpan, MimeTypeIcon, SINGLE_SELECTION_MODE, ThumbnailItem, inspectComponentWrapper;
+	var LoadableSpan, SINGLE_SELECTION_MODE, ThumbnailItem, getMimeTypeIconClassName, inspectComponentWrapper;
 
-	MimeTypeIcon = __webpack_require__(78);
+	getMimeTypeIconClassName = __webpack_require__(78)["default"];
 
 	LoadableSpan = __webpack_require__(79);
 
@@ -4354,7 +4581,7 @@
 	  _mimeTypeIconClassName: function(contentType) {
 	    var className;
 	    className = 'scrivito_icon ';
-	    className += MimeTypeIcon.getMimeTypeIconClassName(contentType);
+	    className += getMimeTypeIconClassName(contentType);
 	    return className;
 	  },
 	  _isTransformable: function(contentType) {
@@ -4378,6 +4605,10 @@
 	        return React.createElement("div", {
 	          "className": "scrivito-content-browser-preview image-too-large"
 	        });
+	      } else if (error instanceof scrivito.TransformationSourceInvalidError) {
+	        return React.createElement("div", {
+	          "className": "scrivito-content-browser-preview image-invalid"
+	        });
 	      } else {
 	        throw error;
 	      }
@@ -4386,7 +4617,7 @@
 	  _previewImage: function() {
 	    var blob, contentType;
 	    blob = this._obj().get('blob', 'binary');
-	    contentType = blob != null ? blob.contentType : void 0;
+	    contentType = blob != null ? blob.raw.contentType : void 0;
 	    if (this._isTransformable(contentType)) {
 	      return this._handleImageTransformation(blob);
 	    } else if (contentType && contentType.indexOf('image/') === 0) {
@@ -4447,48 +4678,44 @@
 /* 78 */
 /***/ function(module, exports) {
 
-	var MimeTypeIcon;
-
-	MimeTypeIcon = (function() {
-	  function MimeTypeIcon() {}
-
-	  MimeTypeIcon.getMimeTypeIconClassName = function(mimeType) {
-	    var icon, matchedType;
-	    if (mimeType != null) {
-	      matchedType = this._getMatchedIconType(mimeType);
-	      icon = this._mimeTypesHash[matchedType];
-	    }
-	    if (icon == null) {
-	      icon = "scrivito_icon_generic";
-	    }
-	    return icon;
-	  };
-
-	  MimeTypeIcon._mimeTypesHash = {
-	    "video": "scrivito_icon_movie",
-	    "audio": "scrivito_icon_music",
-	    "msword": "scrivito_icon_doc",
-	    "zip": "scrivito_icon_zip",
-	    "pdf": "scrivito_icon_pdf",
-	    "ms-excel": "scrivito_icon_xls",
-	    "ms-powerpoint": "scrivito_icon_ppt",
-	    "openxmlformats-officedocument.spreadsheetml": "scrivito_icon_xls",
-	    "wordprocessingml": "scrivito_icon_doc",
-	    "presentationml": "scrivito_icon_ppt"
-	  };
+	'use strict';
 
-	  MimeTypeIcon._getMatchedIconType = function(mimeType) {
-	    return _.find(Object.keys(this._mimeTypesHash), function(keyName) {
-	      return mimeType.match(RegExp("\\b" + keyName + "\\b"));
-	    });
-	  };
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.default = getMimeTypeIconClassName;
+	var MIME_TYPES_HASH = {
+	  video: 'scrivito_icon_movie',
+	  audio: 'scrivito_icon_music',
+	  msword: 'scrivito_icon_doc',
+	  zip: 'scrivito_icon_zip',
+	  pdf: 'scrivito_icon_pdf',
+	  'ms-excel': 'scrivito_icon_xls',
+	  'ms-powerpoint': 'scrivito_icon_ppt',
+	  'openxmlformats-officedocument.spreadsheetml': 'scrivito_icon_xls',
+	  wordprocessingml: 'scrivito_icon_doc',
+	  presentationml: 'scrivito_icon_ppt'
+	};
 
-	  return MimeTypeIcon;
+	var getMatchedIconType = function getMatchedIconType(mimeType) {
+	  return _.find(Object.keys(MIME_TYPES_HASH), function (keyName) {
+	    return mimeType.match(new RegExp('\\b' + keyName + '\\b'));
+	  });
+	};
 
-	})();
+	function getMimeTypeIconClassName(mimeType) {
+	  var icon = void 0;
+	  if (mimeType) {
+	    var matchedType = getMatchedIconType(mimeType);
+	    icon = MIME_TYPES_HASH[matchedType];
+	  }
 
-	module.exports = MimeTypeIcon;
+	  if (!icon) {
+	    icon = 'scrivito_icon_generic';
+	  }
 
+	  return icon;
+	}
 
 /***/ },
 /* 79 */
@@ -4577,7 +4804,7 @@
 
 	var AddItemMixin, ThumbnailAddItem;
 
-	AddItemMixin = __webpack_require__(82);
+	AddItemMixin = __webpack_require__(82)["default"];
 
 	ThumbnailAddItem = React.createClass({
 	  displayName: 'ThumbnailAddItem',
@@ -4604,95 +4831,139 @@
 /* 82 */
 /***/ function(module, exports) {
 
-	var AddItemMixin;
+	'use strict';
 
-	AddItemMixin = {
-	  itemClassName: function() {
-	    var className;
-	    className = "scrivito-content-browser-add";
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	var AddItemMixin = {
+	  itemClassName: function itemClassName() {
+	    var className = 'scrivito-content-browser-add';
 	    if (!this.props.objCreation.isActive()) {
-	      className += " disabled";
+	      className += ' disabled';
 	    }
 	    return className;
 	  },
-	  iconClassName: function() {
-	    var iconClass;
-	    iconClass = this.props.objCreation.isActive() ? "scrivito_icon_plus" : "scrivito_icon_disabled";
-	    return "scrivito_icon " + iconClass;
-	  },
-	  creationNotPossibleBody: function(error) {
-	    return React.createElement("ul", null, _.map(error.nodeTitles, function(title) {
-	      return React.createElement("li", null, title);
-	    }));
+	  iconClassName: function iconClassName() {
+	    if (this.props.objCreation.isActive()) {
+	      return 'scrivito_icon scrivito_icon_plus';
+	    }
+
+	    return 'scrivito_icon scrivito_icon_disabled';
+	  },
+	  creationNotPossibleBody: function creationNotPossibleBody(error) {
+	    return React.createElement(
+	      'ul',
+	      null,
+	      error.nodeTitles.map(function (title) {
+	        return React.createElement(
+	          'li',
+	          { key: title },
+	          title
+	        );
+	      })
+	    );
 	  },
-	  presetConflictBody: function(error) {
-	    return React.createElement("div", null, (scrivito.translate('content_browser.add_item.preset_conflict'), _.map(error.fields, function(values, field) {
-	      return React.createElement("div", null, React.createElement("h4", null, field), React.createElement("ul", null, _.map(values, function(value) {
-	        return React.createElement("li", null, value);
-	      })));
-	    })));
+	  presetConflictBody: function presetConflictBody(error) {
+	    return React.createElement(
+	      'div',
+	      null,
+	      scrivito.translate('content_browser.add_item.preset_conflict'),
+	      _.map(error.fields, function (values, field) {
+	        return React.createElement(
+	          'div',
+	          { key: field },
+	          React.createElement(
+	            'h4',
+	            null,
+	            field
+	          ),
+	          React.createElement(
+	            'ul',
+	            null,
+	            values.map(function (value) {
+	              return React.createElement(
+	                'li',
+	                { key: value },
+	                value
+	              );
+	            })
+	          )
+	        );
+	      })
+	    );
 	  },
-	  showErrorAlert: function(error) {
-	    var alertProps;
-	    alertProps = (function() {
-	      switch (error.type) {
-	        case 'creation_not_possible':
-	          return {
-	            subtitle: scrivito.translate('content_browser.add_item.disabled_filters'),
-	            body: this.creationNotPossibleBody(error)
-	          };
-	        case 'obj_class_not_provided':
-	          return {
-	            subtitle: scrivito.translate('content_browser.add_item.error_no_obj_class')
-	          };
-	        case 'preset_conflict':
-	          return {
-	            body: this.presetConflictBody(error)
-	          };
-	      }
-	    }).call(this);
+	  showErrorAlert: function showErrorAlert(error) {
+	    var alertProps = void 0;
+	    if (error.type === 'creation_not_possible') {
+	      alertProps = {
+	        subtitle: scrivito.translate('content_browser.add_item.disabled_filters'),
+	        body: this.creationNotPossibleBody(error)
+	      };
+	    }
+
+	    if (error.type === 'obj_class_not_provided') {
+	      alertProps = {
+	        subtitle: scrivito.translate('content_browser.add_item.error_no_obj_class')
+	      };
+	    }
+
+	    if (error.type === 'preset_conflict') {
+	      alertProps = { body: this.presetConflictBody(error) };
+	    }
+
 	    alertProps.title = scrivito.translate('content_browser.add_item.create_imposible');
-	    return scrivito.content_browser._showAlert(alertProps);
-	  },
-	  buildErrorMessage: function(error) {
-	    var message, nodesString;
-	    switch (error.type) {
-	      case 'creation_not_possible':
-	        nodesString = error.nodeTitles.join(', ');
-	        return scrivito.translate('content_browser.add_item.prevent_creation', nodesString);
-	      case 'obj_class_not_provided':
-	        return scrivito.translate('content_browser.add_item.error_no_obj_class');
-	      case 'preset_conflict':
-	        message = scrivito.translate('content_browser.add_item.failed');
-	        _.each(error.fields, function(value, field) {
-	          return message += "" + field + ": " + (value.join(', ')) + "\n";
-	        });
-	        return message;
+	    scrivito.content_browser._showAlert(alertProps);
+	  },
+	  buildErrorMessage: function buildErrorMessage(error) {
+	    if (error.type === 'creation_not_possible') {
+	      var nodesString = error.nodeTitles.join(', ');
+	      return scrivito.translate('content_browser.add_item.prevent_creation', nodesString);
+	    }
+
+	    if (error.type === 'obj_class_not_provided') {
+	      return scrivito.translate('content_browser.add_item.error_no_obj_class');
+	    }
+
+	    if (error.type === 'preset_conflict') {
+	      var message = scrivito.translate('content_browser.add_item.failed');
+
+	      _.each(error.fields, function (value, field) {
+	        message += field + ': ' + value.join(', ') + '\n';
+	      });
+
+	      return message;
 	    }
 	  },
-	  iconTitle: function() {
+	  iconTitle: function iconTitle() {
 	    if (!this.props.objCreation.isActive()) {
 	      return this.buildErrorMessage(this.props.objCreation.error());
 	    }
 	  },
-	  textMessage: function() {
+	  textMessage: function textMessage() {
 	    if (this.props.objCreation.isActive()) {
 	      return scrivito.translate('content_browser.add_item.create_item');
-	    } else {
-	      return scrivito.translate('content_browser.add_item.create_imposible');
 	    }
+
+	    return scrivito.translate('content_browser.add_item.create_imposible');
 	  },
-	  createClick: function() {
-	    if (this.props.objCreation.isActive()) {
-	      return this.props.createObj(null, this.props.basePreset, this.props.objCreation.preset(), this.props.activeTags);
+	  createClick: function createClick() {
+	    var _props = this.props,
+	        objCreation = _props.objCreation,
+	        createObj = _props.createObj,
+	        basePreset = _props.basePreset,
+	        activeTags = _props.activeTags;
+
+	    if (objCreation.isActive()) {
+	      createObj({}, basePreset, objCreation.preset(), activeTags);
+	      objCreation.filter.deselectHierarchicalFilters();
 	    } else {
-	      return this.showErrorAlert(this.props.objCreation.error());
+	      this.showErrorAlert(objCreation.error());
 	    }
 	  }
 	};
 
-	module.exports = AddItemMixin;
-
+	exports.default = AddItemMixin;
 
 /***/ },
 /* 83 */
@@ -4794,184 +5065,220 @@
 /* 85 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ActiveNodeConfigCollector, ObjCreation, PresetBuilder;
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	ActiveNodeConfigCollector = __webpack_require__(57);
+	var _active_node_config_collector = __webpack_require__(57);
 
-	PresetBuilder = __webpack_require__(86);
+	var _active_node_config_collector2 = _interopRequireDefault(_active_node_config_collector);
 
-	ObjCreation = (function() {
-	  function ObjCreation(filter) {
-	    var collector, presetBuilder;
-	    collector = new ActiveNodeConfigCollector(filter);
-	    this.activeConfigs = collector.findActiveFilterItems();
-	    presetBuilder = new PresetBuilder(filter);
-	    this._preset = presetBuilder.generatePreset();
-	  }
+	var _preset_builder = __webpack_require__(86);
 
-	  ObjCreation.prototype.preset = function() {
-	    return this._preset.values();
-	  };
+	var _preset_builder2 = _interopRequireDefault(_preset_builder);
 
-	  ObjCreation.prototype.showCreationItem = function() {
-	    return _.some(this.activeConfigs, function(nodeConfig) {
-	      return nodeConfig.enablesCreation();
-	    });
-	  };
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	  ObjCreation.prototype.isActive = function() {
-	    return !!(!this._preventCreation() && this._presetIsValid());
-	  };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	  ObjCreation.prototype.error = function() {
-	    if (this._preventCreation()) {
-	      return {
-	        type: 'creation_not_possible',
-	        nodeTitles: this._nodeTitlesPreventingCreation()
-	      };
-	    } else if (this._preset.isValid()) {
-	      return {
-	        type: 'obj_class_not_provided'
-	      };
-	    } else {
-	      return {
-	        type: 'preset_conflict',
-	        fields: this._buildPresetConflictError()
-	      };
-	    }
-	  };
+	var ObjCreation = function () {
+	  function ObjCreation(filter) {
+	    _classCallCheck(this, ObjCreation);
 
-	  ObjCreation.prototype._preventCreation = function() {
-	    return _.some(this.activeConfigs, function(nodeConfig) {
-	      return nodeConfig.preventsCreation();
-	    });
-	  };
+	    this.filter = filter;
 
-	  ObjCreation.prototype._presetIsValid = function() {
-	    return this._preset.isValid() && this.preset()['_obj_class'];
-	  };
+	    var collector = new _active_node_config_collector2.default(filter);
+	    this.activeConfigs = collector.findActiveFilterItems();
 
-	  ObjCreation.prototype._nodeTitlesPreventingCreation = function() {
-	    var nodes;
-	    nodes = _.flatten(_.map(this.activeConfigs, function(node) {
-	      return node.nodesPreventingCreation();
-	    }));
-	    return _.map(nodes, function(node) {
-	      return node.title;
-	    });
-	  };
+	    var presetBuilder = new _preset_builder2.default(filter);
+	    this.presetValues = presetBuilder.generatePreset();
+	  }
 
-	  ObjCreation.prototype._buildPresetConflictError = function() {
-	    var presetConflicts;
-	    presetConflicts = {};
-	    _.each(this._preset.errors(), function(values, field) {
-	      return presetConflicts[field] = values;
-	    });
-	    return presetConflicts;
-	  };
+	  _createClass(ObjCreation, [{
+	    key: 'preset',
+	    value: function preset() {
+	      return this.presetValues.values();
+	    }
+	  }, {
+	    key: 'showCreationItem',
+	    value: function showCreationItem() {
+	      return _.some(this.activeConfigs, function (nodeConfig) {
+	        return nodeConfig.enablesCreation();
+	      });
+	    }
+	  }, {
+	    key: 'isActive',
+	    value: function isActive() {
+	      return !!(!this.preventCreation() && this.presetIsValid());
+	    }
+	  }, {
+	    key: 'error',
+	    value: function error() {
+	      if (this.preventCreation()) {
+	        return { type: 'creation_not_possible', nodeTitles: this.nodeTitlesPreventingCreation() };
+	      } else if (this.presetValues.isValid()) {
+	        return { type: 'obj_class_not_provided' };
+	      }
 
-	  return ObjCreation;
+	      return { type: 'preset_conflict', fields: this.buildPresetConflictError() };
+	    }
+	  }, {
+	    key: 'preventCreation',
+	    value: function preventCreation() {
+	      return _.some(this.activeConfigs, function (nodeConfig) {
+	        return nodeConfig.preventsCreation();
+	      });
+	    }
+	  }, {
+	    key: 'presetIsValid',
+	    value: function presetIsValid() {
+	      return this.presetValues.isValid() && this.preset()._obj_class;
+	    }
+	  }, {
+	    key: 'nodeTitlesPreventingCreation',
+	    value: function nodeTitlesPreventingCreation() {
+	      var nodes = _.flatten(_.map(this.activeConfigs, function (node) {
+	        return node.nodesPreventingCreation();
+	      }));
+	      return _.map(nodes, function (node) {
+	        return node.title;
+	      });
+	    }
+	  }, {
+	    key: 'buildPresetConflictError',
+	    value: function buildPresetConflictError() {
+	      var presetConflicts = {};
+	      _.each(this.presetValues.errors(), function (values, field) {
+	        presetConflicts[field] = values;
+	        return presetConflicts[field];
+	      });
 
-	})();
+	      return presetConflicts;
+	    }
+	  }]);
 
-	module.exports = ObjCreation;
+	  return ObjCreation;
+	}();
 
+	exports.default = ObjCreation;
 
 /***/ },
 /* 86 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ActiveNodeConfigCollector, PresetBuilder;
+	'use strict';
 
-	ActiveNodeConfigCollector = __webpack_require__(57);
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
 
-	PresetBuilder = (function() {
-	  var Preset;
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
 
-	  Preset = (function() {
-	    function Preset() {
-	      this._errors = {};
-	      this._values = {};
-	      this._titles = {};
-	    }
+	var _active_node_config_collector = __webpack_require__(57);
 
-	    Preset.prototype.isValid = function() {
-	      return _.keys(this.errors()).length === 0;
-	    };
+	var _active_node_config_collector2 = _interopRequireDefault(_active_node_config_collector);
 
-	    Preset.prototype.values = function() {
-	      if (this.isValid()) {
-	        return this._values;
-	      } else {
-	        throw new Error(scrivito.translate('content_browser.last_added.preset_error'));
-	      }
-	    };
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	    Preset.prototype.errors = function() {
-	      return this._errors;
-	    };
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-	    Preset.prototype._addValue = function(key, value, title) {
-	      if (this._values.hasOwnProperty(key)) {
-	        return this._addError(key, this._titles[key], title);
-	      } else {
-	        this._values[key] = value;
-	        return this._titles[key] = title;
-	      }
-	    };
+	var Preset = function () {
+	  function Preset() {
+	    _classCallCheck(this, Preset);
 
-	    Preset.prototype._addError = function(key, previouslySetValue, newValue) {
-	      if (this._errors[key]) {
-	        return this._errors[key].push(newValue);
-	      } else {
-	        return this._errors[key] = [previouslySetValue, newValue];
-	      }
-	    };
+	    this.presetErrors = {};
+	    this.presetValues = {};
+	    this.titles = {};
+	  }
 
-	    return Preset;
+	  _createClass(Preset, [{
+	    key: 'isValid',
+	    value: function isValid() {
+	      return _.keys(this.errors()).length === 0;
+	    }
+	  }, {
+	    key: 'values',
+	    value: function values() {
+	      if (this.isValid()) {
+	        return this.presetValues;
+	      }
+	      throw new Error(scrivito.translate('content_browser.last_added.preset_error'));
+	    }
+	  }, {
+	    key: 'errors',
+	    value: function errors() {
+	      return this.presetErrors;
+	    }
+	  }, {
+	    key: 'addValue',
+	    value: function addValue(key, value, title) {
+	      if (Object.prototype.hasOwnProperty.call(this.presetValues, key)) {
+	        return this.addError(key, this.titles[key], title);
+	      }
+	      this.presetValues[key] = value;
+	      this.titles[key] = title;
+	    }
+	  }, {
+	    key: 'addError',
+	    value: function addError(key, previouslySetValue, newValue) {
+	      if (this.presetErrors[key]) {
+	        return this.presetErrors[key].push(newValue);
+	      }
+	      this.presetErrors[key] = [previouslySetValue, newValue];
+	    }
+	  }]);
 
-	  })();
+	  return Preset;
+	}();
 
+	var PresetBuilder = function () {
 	  function PresetBuilder(filter) {
-	    this._collector = new ActiveNodeConfigCollector(filter);
-	  }
-
-	  PresetBuilder.prototype.generatePreset = function() {
-	    var activeNodeConfigs, presetCollection;
-	    presetCollection = new Preset();
-	    activeNodeConfigs = this._collector.findActiveFilterItems();
-	    _.each(activeNodeConfigs, (function(_this) {
-	      return function(activeNodeConfig) {
-	        var nodesWithPreset;
-	        nodesWithPreset = _this._nodesWithPreset(activeNodeConfig);
-	        return _.each(nodesWithPreset, function(filterNode) {
-	          return _this._addPresetsForFilterNode(filterNode, presetCollection);
-	        });
-	      };
-	    })(this));
-	    return presetCollection;
-	  };
+	    _classCallCheck(this, PresetBuilder);
 
-	  PresetBuilder.prototype._nodesWithPreset = function(config) {
-	    return _.select(config.activeNodes(), function(node) {
-	      return node.preset;
-	    });
-	  };
+	    this.collector = new _active_node_config_collector2.default(filter);
+	  }
 
-	  PresetBuilder.prototype._addPresetsForFilterNode = function(node, presetCollection) {
-	    return _.each(node.preset, function(value, key) {
-	      if (value !== void 0) {
-	        return presetCollection._addValue(key, value, node.title);
-	      }
-	    });
-	  };
+	  _createClass(PresetBuilder, [{
+	    key: 'generatePreset',
+	    value: function generatePreset() {
+	      var presetCollection = new Preset();
+	      var activeNodeConfigs = this.collector.findActiveFilterItems();
 
-	  return PresetBuilder;
+	      _.each(activeNodeConfigs, function (activeNodeConfig) {
+	        var nodesWithPreset = PresetBuilder.nodesWithPreset(activeNodeConfig);
+	        _.each(nodesWithPreset, function (filterNode) {
+	          PresetBuilder.addPresetsForFilterNode(filterNode, presetCollection);
+	        });
+	      });
 
-	})();
+	      return presetCollection;
+	    }
+	  }], [{
+	    key: 'nodesWithPreset',
+	    value: function nodesWithPreset(config) {
+	      return _.select(config.activeNodes(), function (node) {
+	        return node.preset;
+	      });
+	    }
+	  }, {
+	    key: 'addPresetsForFilterNode',
+	    value: function addPresetsForFilterNode(node, presetCollection) {
+	      _.each(node.preset, function (value, key) {
+	        if (value !== undefined) {
+	          presetCollection.addValue(key, value, node.title);
+	        }
+	      });
+	    }
+	  }]);
 
-	module.exports = PresetBuilder;
+	  return PresetBuilder;
+	}();
 
+	exports.default = PresetBuilder;
 
 /***/ },
 /* 87 */
@@ -4985,7 +5292,7 @@
 
 	TableView = __webpack_require__(75);
 
-	TABLE_VIEW = __webpack_require__(22).TABLE_VIEW;
+	TABLE_VIEW = __webpack_require__(21).TABLE_VIEW;
 
 	SelectedItems = React.createClass({
 	  displayName: 'SelectedItems',
@@ -5068,14 +5375,14 @@
 	    var blob;
 	    blob = this._obj().get('blob', 'binary');
 	    if (blob) {
-	      return blob.contentType;
+	      return blob.raw.contentType;
 	    }
 	  },
 	  _contentLength: function() {
 	    var blob;
 	    blob = this._obj().get('blob', 'binary');
 	    if (blob) {
-	      return filesize(blob.contentLength);
+	      return filesize(blob.raw.contentLength);
 	    }
 	  },
 	  _getLastChangedFormatedDate: function() {
@@ -5196,13 +5503,13 @@
 	/**
 	 * filesize
 	 *
-	 * @copyright 2016 Jason Mulligan <jason.mulligan@avoidwork.com>
+	 * @copyright 2017 Jason Mulligan <jason.mulligan@avoidwork.com>
 	 * @license BSD-3-Clause
-	 * @version 3.3.0
+	 * @version 3.5.4
 	 */
 	(function (global) {
-		var b = /^(b|B)$/;
-		var symbol = {
+		var b = /^(b|B)$/,
+		    symbol = {
 			iec: {
 				bits: ["b", "Kib", "Mib", "Gib", "Tib", "Pib", "Eib", "Zib", "Yib"],
 				bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
@@ -5211,6 +5518,10 @@
 				bits: ["b", "Kb", "Mb", "Gb", "Tb", "Pb", "Eb", "Zb", "Yb"],
 				bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
 			}
+		},
+		    fullform = {
+			iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
+			jedec: ["", "kilo", "mega", "giga", "tera", "peta", "exa", "zetta", "yotta"]
 		};
 
 		/**
@@ -5222,7 +5533,7 @@
 	  * @return {String}             Readable file size String
 	  */
 		function filesize(arg) {
-			var descriptor = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
+			var descriptor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
 			var result = [],
 			    val = 0,
@@ -5230,6 +5541,8 @@
 			    base = void 0,
 			    bits = void 0,
 			    ceil = void 0,
+			    full = void 0,
+			    fullforms = void 0,
 			    neg = void 0,
 			    num = void 0,
 			    output = void 0,
@@ -5251,6 +5564,8 @@
 			symbols = descriptor.symbols || descriptor.suffixes || {};
 			standard = base === 2 ? descriptor.standard || "jedec" : "jedec";
 			output = descriptor.output || "string";
+			full = descriptor.fullform === true;
+			fullforms = descriptor.fullforms instanceof Array ? descriptor.fullforms : [];
 			e = descriptor.exponent !== undefined ? descriptor.exponent : -1;
 			num = Number(arg);
 			neg = num < 0;
@@ -5263,6 +5578,7 @@
 
 			// Zero is now a special case because bytes divide by 1
 			if (num === 0) {
+				e = 0;
 				result[0] = 0;
 				result[1] = unix ? "" : !bits ? "B" : "b";
 			} else {
@@ -5280,12 +5596,12 @@
 					e = 8;
 				}
 
-				val = base === 2 ? num / Math.pow(2, e * 10) : num / Math.pow(1000, e);
+				val = num / (base === 2 ? Math.pow(2, e * 10) : Math.pow(1000, e));
 
 				if (bits) {
 					val = val * 8;
 
-					if (val > ceil && e < 8) {
+					if (val >= ceil && e < 8) {
 						val = val / ceil;
 						e++;
 					}
@@ -5325,9 +5641,20 @@
 				return { value: result[0], suffix: result[1], symbol: result[1] };
 			}
 
+			if (full) {
+				result[1] = fullforms[e] ? fullforms[e] : fullform[standard][e] + (bits ? "bit" : "byte") + (result[0] === 1 ? "" : "s");
+			}
+
 			return result.join(spacer);
 		}
 
+		// Partial application for functional programming
+		filesize.partial = function (opt) {
+			return function (arg) {
+				return filesize(arg, opt);
+			};
+		};
+
 		// CommonJS, AMD, script tag
 		if (true) {
 			module.exports = filesize;
@@ -5354,7 +5681,7 @@
 
 	TableView = __webpack_require__(75);
 
-	objDisplayAction = __webpack_require__(22);
+	objDisplayAction = __webpack_require__(21);
 
 	LastAddedItems = React.createClass({
 	  displayName: 'LastAddedItems',
@@ -5567,42 +5894,35 @@
 /* 97 */
 /***/ function(module, exports) {
 
-	var failed, isActive, isCompleted, isFailed, status;
+	'use strict';
 
-	status = function(addition) {
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	var status = exports.status = function status(addition) {
 	  if (addition.progress === 0) {
-	    return "failed";
-	  } else if (addition.progress === 100) {
-	    return "completed";
-	  } else {
-	    return "active";
+	    return 'failed';
 	  }
-	};
 
-	isActive = function(addition) {
-	  return status(addition) === "active";
-	};
+	  if (addition.progress === 100) {
+	    return 'completed';
+	  }
 
-	isCompleted = function(addition) {
-	  return status(addition) === "completed";
+	  return 'active';
 	};
 
-	isFailed = function(addition) {
-	  return status(addition) === "failed";
+	var isActive = exports.isActive = function isActive(addition) {
+	  return status(addition) === 'active';
 	};
-
-	failed = function(additions) {
-	  return _.filter(additions, isFailed);
+	var isCompleted = exports.isCompleted = function isCompleted(addition) {
+	  return status(addition) === 'completed';
 	};
-
-	module.exports = {
-	  status: status,
-	  failed: failed,
-	  isActive: isActive,
-	  isCompleted: isCompleted,
-	  isFailed: isFailed
+	var isFailed = exports.isFailed = function isFailed(addition) {
+	  return status(addition) === 'failed';
+	};
+	var failed = exports.failed = function failed(additions) {
+	  return _.filter(additions, isFailed);
 	};
-
 
 /***/ },
 /* 98 */
@@ -5740,7 +6060,7 @@
 
 	TableViewAddItem = __webpack_require__(102);
 
-	ObjCreation = __webpack_require__(85);
+	ObjCreation = __webpack_require__(85)["default"];
 
 	InfiniteScrollLoader = __webpack_require__(83);
 
@@ -5798,7 +6118,7 @@
 
 	var AddItemMixin, TableViewAddItem;
 
-	AddItemMixin = __webpack_require__(82);
+	AddItemMixin = __webpack_require__(82)["default"];
 
 	TableViewAddItem = React.createClass({
 	  mixins: [AddItemMixin],
@@ -5871,254 +6191,228 @@
 /* 104 */
 /***/ function(module, exports) {
 
-	var EXPAND_TOGGLE, TOGGLE_TAG, toggleExpandTagBar, toggleTag;
-
-	EXPAND_TOGGLE = 'EXPAND_TOGGLE';
-
-	TOGGLE_TAG = 'TOGGLE_TAG';
-
-	toggleExpandTagBar = function() {
-	  return {
-	    type: EXPAND_TOGGLE
-	  };
-	};
-
-	toggleTag = (function(_this) {
-	  return function(tag) {
-	    return {
-	      type: TOGGLE_TAG,
-	      tag: tag
-	    };
-	  };
-	})(this);
-
-	module.exports = {
-	  toggleTag: toggleTag,
-	  toggleExpandTagBar: toggleExpandTagBar,
-	  EXPAND_TOGGLE: EXPAND_TOGGLE,
-	  TOGGLE_TAG: TOGGLE_TAG
-	};
+	"use strict";
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	function Spinner() {
+	  return React.createElement(
+	    "div",
+	    { className: "scrivito-content-browser-loading" },
+	    React.createElement("i", { className: "scrivito_icon scrivito_icon_refresh" })
+	  );
+	}
 
+	exports.default = Spinner;
 
 /***/ },
 /* 105 */
 /***/ function(module, exports) {
 
-	var DEFAULT_NUMBER_TO_LOAD, LOAD_MORE_OBJS, loadMoreObjs;
-
-	LOAD_MORE_OBJS = "LOAD_MORE_OBJS";
-
-	DEFAULT_NUMBER_TO_LOAD = 24;
+	'use strict';
 
-	loadMoreObjs = (function(_this) {
-	  return function(numToLoad) {
-	    return {
-	      type: LOAD_MORE_OBJS,
-	      numToLoad: numToLoad
-	    };
-	  };
-	})(this);
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.toggleExpandTagBar = toggleExpandTagBar;
+	exports.toggleTag = toggleTag;
+	var EXPAND_TOGGLE = exports.EXPAND_TOGGLE = 'EXPAND_TOGGLE';
+	var TOGGLE_TAG = exports.TOGGLE_TAG = 'TOGGLE_TAG';
 
-	module.exports = {
-	  loadMoreObjs: loadMoreObjs,
-	  LOAD_MORE_OBJS: LOAD_MORE_OBJS,
-	  DEFAULT_NUMBER_TO_LOAD: DEFAULT_NUMBER_TO_LOAD
-	};
+	function toggleExpandTagBar() {
+	  return { type: EXPAND_TOGGLE };
+	}
 
+	function toggleTag(tag) {
+	  return { type: TOGGLE_TAG, tag: tag };
+	}
 
 /***/ },
 /* 106 */
 /***/ function(module, exports) {
 
-	var loadAllUntil, loadWithDefault;
-
-	loadAllUntil = function(iterable, maxItems, objs) {
-	  var done, e, value, _ref;
-	  if (objs == null) {
-	    objs = [];
-	  }
-	  try {
-	    _ref = iterable.next(), value = _ref.value, done = _ref.done;
-	    if (done || maxItems === 0) {
-	      return {
-	        done: done,
-	        objs: objs
-	      };
-	    } else {
-	      return loadAllUntil(iterable, maxItems - 1, objs.concat([value]));
-	    }
-	  } catch (_error) {
-	    e = _error;
-	    if (e instanceof scrivito.NotLoadedError) {
-	      e.load();
-	      return {
-	        done: false,
-	        objs: objs
-	      };
-	    } else {
-	      throw e;
-	    }
-	  }
-	};
-
-	loadWithDefault = function(theDefault, loadFn) {
-	  var e;
-	  try {
-	    return loadFn();
-	  } catch (_error) {
-	    e = _error;
-	    if (scrivito.isNotLoadedError(e)) {
-	      e.load();
-	      return theDefault;
-	    } else {
-	      throw e;
-	    }
-	  }
-	};
+	'use strict';
 
-	module.exports = {
-	  loadAllUntil: loadAllUntil,
-	  loadWithDefault: loadWithDefault
-	};
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.loadMoreObjs = loadMoreObjs;
+	var LOAD_MORE_OBJS = exports.LOAD_MORE_OBJS = 'LOAD_MORE_OBJS';
+	var DEFAULT_NUMBER_TO_LOAD = exports.DEFAULT_NUMBER_TO_LOAD = 24;
 
+	function loadMoreObjs(numToLoad) {
+	  return { type: LOAD_MORE_OBJS, numToLoad: numToLoad };
+	}
 
 /***/ },
 /* 107 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ActiveNodeConfigCollector, DESC_SORT_ORDER, QueryBuilder;
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+	var _active_node_config_collector = __webpack_require__(57);
+
+	var _active_node_config_collector2 = _interopRequireDefault(_active_node_config_collector);
 
-	ActiveNodeConfigCollector = __webpack_require__(57);
+	var _sort_criteria = __webpack_require__(55);
 
-	DESC_SORT_ORDER = __webpack_require__(16).DESC_SORT_ORDER;
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-	QueryBuilder = (function() {
+	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+	var QueryBuilder = function () {
 	  function QueryBuilder(filter, baseQuery, tags, sortCriteria) {
+	    _classCallCheck(this, QueryBuilder);
+
 	    this.filter = filter;
 	    this.tags = tags;
 	    this.sortCriteria = sortCriteria;
-	    this._collector = new ActiveNodeConfigCollector(this.filter);
+	    this.collector = new _active_node_config_collector2.default(this.filter);
+
 	    if (!this.sortCriteria) {
 	      throw new Error('sortCriteria is not initialized. Please explicit initialize the sort criteria param');
 	    }
+
 	    if (baseQuery) {
-	      this._baseQuery = baseQuery.to_basic_obj_search_iterable();
+	      this.baseQuery = baseQuery.to_basic_obj_search_iterable();
 	    }
 	  }
 
-	  QueryBuilder.prototype.searchRequest = function() {
-	    var query;
-	    query = this._baseQuery;
-	    query = this._addFilterQueries(query);
-	    query = this._addSearchTermQuery(query);
-	    query = this._sortQuery(query);
-	    query = this._tagsQuery(query);
-	    return query = this._ignoreMigrationStore(query);
-	  };
-
-	  QueryBuilder.prototype._tagsQuery = function(query) {
-	    if (this.tags && this.tags.length > 0) {
-	      _.each(this.tags, function(tag) {
-	        if (query) {
-	          return query.and('tags', 'equals', tag);
-	        } else {
-	          return query;
-	        }
-	      });
+	  _createClass(QueryBuilder, [{
+	    key: 'searchRequest',
+	    value: function searchRequest() {
+	      var query = this.baseQuery;
+	      query = this.addFilterQueries(query);
+	      query = this.addSearchTermQuery(query);
+	      query = this.sortQuery(query);
+	      query = this.tagsQuery(query);
+	      query = QueryBuilder.ignoreMigrationStore(query);
+	      return query;
 	    }
-	    return query;
-	  };
-
-	  QueryBuilder.prototype._addFilterQueries = function(baseQuery) {
-	    var activeConfig, combinedQuery, searchQuery, _i, _len, _ref;
-	    combinedQuery = baseQuery;
-	    _ref = this._collector.findActiveFilterItems();
-	    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	      activeConfig = _ref[_i];
-	      searchQuery = this._buildActiveChildrenSearchQuery(activeConfig);
-	      if (searchQuery) {
-	        combinedQuery = this._addOrCreateQuery(combinedQuery, searchQuery);
+	  }, {
+	    key: 'tagsQuery',
+	    value: function tagsQuery(query) {
+	      if (this.tags && this.tags.length > 0) {
+	        _.each(this.tags, function (tag) {
+	          if (query) {
+	            query.and('tags', 'equals', tag);
+	          }
+	        });
 	      }
+	      return query;
 	    }
-	    return combinedQuery;
-	  };
+	  }, {
+	    key: 'addFilterQueries',
+	    value: function addFilterQueries(baseQuery) {
+	      var combinedQuery = baseQuery;
+	      var activeItems = this.collector.findActiveFilterItems();
+	      _.each(activeItems, function (activeConfig) {
+	        var searchQuery = QueryBuilder.buildActiveChildrenSearchQuery(activeConfig);
+	        if (searchQuery) {
+	          combinedQuery = QueryBuilder.addOrCreateQuery(combinedQuery, searchQuery);
+	        }
+	      });
 
-	  QueryBuilder.prototype._sortQuery = function(query) {
-	    if (query != null) {
-	      if (this.sortCriteria.sortField === 'relevance') {
-	        if (!this._hasSearchTerm()) {
-	          query.order('_last_changed', DESC_SORT_ORDER);
+	      return combinedQuery;
+	    }
+	  }, {
+	    key: 'sortQuery',
+	    value: function sortQuery(query) {
+	      if (query) {
+	        if (this.sortCriteria.sortField === 'relevance') {
+	          if (!this.hasSearchTerm()) {
+	            query.order('_lastChanged', _sort_criteria.DESC_SORT_ORDER);
+	          }
+	        } else {
+	          query.order(this.sortCriteria.sortField, this.sortCriteria.sortDirection);
 	        }
-	      } else {
-	        query.order(this.sortCriteria.sortField, this.sortCriteria.sortDirection);
 	      }
+	      return query;
 	    }
-	    return query;
-	  };
-
-	  QueryBuilder.prototype._addSearchTermQuery = function(query) {
-	    var searchQuery;
-	    if (this._hasSearchTerm()) {
-	      searchQuery = scrivito.BasicObj.where('*', 'contains_prefix', this.filter.searchTerm);
-	      return this._addOrCreateQuery(query, searchQuery);
-	    } else {
+	  }, {
+	    key: 'addSearchTermQuery',
+	    value: function addSearchTermQuery(query) {
+	      if (this.hasSearchTerm()) {
+	        var searchQuery = scrivito.BasicObj.where('*', 'containsPrefix', this.filter.searchTerm);
+	        return QueryBuilder.addOrCreateQuery(query, searchQuery);
+	      }
 	      return query;
 	    }
-	  };
-
-	  QueryBuilder.prototype._ignoreMigrationStore = function(query) {
-	    if (query != null) {
-	      query.andNot('_obj_class', 'equals', 'MigrationStore');
+	  }, {
+	    key: 'hasSearchTerm',
+	    value: function hasSearchTerm() {
+	      return this.filter.searchTerm && this.filter.searchTerm.length > 0;
 	    }
-	    return query;
-	  };
-
-	  QueryBuilder.prototype._buildActiveChildrenSearchQuery = function(activeConfig) {
-	    if (activeConfig.hasQuery()) {
-	      return activeConfig.query().to_basic_obj_search_iterable();
-	    } else {
-	      return this._buildFOVQuery(activeConfig);
+	  }], [{
+	    key: 'ignoreMigrationStore',
+	    value: function ignoreMigrationStore(query) {
+	      if (query) {
+	        query.andNot('_objClass', 'equals', 'MigrationStore');
+	      }
+	      return query;
 	    }
-	  };
-
-	  QueryBuilder.prototype._buildFOVQuery = function(activeConfig) {
-	    if (activeConfig.hasField()) {
-	      return scrivito.BasicObj.where(activeConfig.field(), activeConfig.operator(), activeConfig.values());
+	  }, {
+	    key: 'buildActiveChildrenSearchQuery',
+	    value: function buildActiveChildrenSearchQuery(activeConfig) {
+	      if (activeConfig.hasQuery()) {
+	        return activeConfig.query().to_basic_obj_search_iterable();
+	      }
+	      return QueryBuilder.buildFOVQuery(activeConfig);
 	    }
-	  };
-
-	  QueryBuilder.prototype._addOrCreateQuery = function(oldQuery, newQuery) {
-	    if (oldQuery) {
-	      return oldQuery.and(newQuery);
-	    } else {
+	  }, {
+	    key: 'buildFOVQuery',
+	    value: function buildFOVQuery(activeConfig) {
+	      if (activeConfig.hasField()) {
+	        return scrivito.BasicObj.where(scrivito.attributeInflection.camelCase(activeConfig.field()), activeConfig.operator(), activeConfig.values());
+	      }
+	    }
+	  }, {
+	    key: 'addOrCreateQuery',
+	    value: function addOrCreateQuery(oldQuery, newQuery) {
+	      if (oldQuery) {
+	        return oldQuery.and(newQuery);
+	      }
 	      return newQuery;
 	    }
-	  };
-
-	  QueryBuilder.prototype._hasSearchTerm = function() {
-	    return this.filter.searchTerm && this.filter.searchTerm.length > 0;
-	  };
+	  }]);
 
 	  return QueryBuilder;
+	}();
 
-	})();
-
-	module.exports = QueryBuilder;
-
+	exports.default = QueryBuilder;
 
 /***/ },
 /* 108 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var Inspector, InspectorHeader, MaximizeInspectorToggle, objDeleted;
+	'use strict';
+
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+
+	var _inspector_header = __webpack_require__(109);
 
-	MaximizeInspectorToggle = __webpack_require__(109);
+	var _inspector_header2 = _interopRequireDefault(_inspector_header);
 
-	InspectorHeader = __webpack_require__(110);
+	var _spinner = __webpack_require__(104);
 
-	objDeleted = __webpack_require__(112).objDeleted;
+	var _spinner2 = _interopRequireDefault(_spinner);
 
-	Inspector = React.createClass({
+	var _obj = __webpack_require__(112);
+
+	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+	function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+	var Inspector = React.createClass({
 	  displayName: 'Inspector',
 	  propTypes: {
 	    editingView: React.PropTypes.bool.isRequired,
@@ -6126,82 +6420,106 @@
 	    selectedObjs: React.PropTypes.arrayOf(React.PropTypes.string).isRequired,
 	    dispatch: React.PropTypes.func.isRequired
 	  },
-	  _detailsViewUrl: function() {
-	    return scrivito.details_url_for_obj_id(this.props.selectedObjs[0]);
+
+	  getInitialState: function getInitialState() {
+	    return { isLoaded: false };
 	  },
-	  _deleteInspectedObjs: function() {
-	    var _ref;
-	    if (this.props.selectedObjs.length) {
-	      return (_ref = scrivito.ConfirmDeleteDialog).open.apply(_ref, this.props.selectedObjs).then((function(_this) {
-	        return function(isConfirmed) {
-	          if (isConfirmed) {
-	            return _.each(scrivito.BasicObj.get(_this.props.selectedObjs), function(obj) {
-	              return _this.props.dispatch(objDeleted(obj.id));
-	            });
-	          }
-	        };
-	      })(this));
+	  componentWillUpdate: function componentWillUpdate(nextProps) {
+	    if (this.state.isLoaded && !_.isEqual(this.props.selectedObjs, nextProps.selectedObjs)) {
+	      this.setState({ isLoaded: false });
 	    }
 	  },
-	  render: function() {
-	    return React.createElement("div", {
-	      "className": "scrivito-content-browser-inspector"
-	    }, (this.props.selectedObjs.length > 0 ? this.props.selectedObjs.length === 1 ? React.createElement("div", null, React.createElement(InspectorHeader, {
-	      "editingView": this.props.editingView,
-	      "disableDelete": this.props.disableDelete,
-	      "dispatch": this.props.dispatch,
-	      "selectedObjs": this.props.selectedObjs,
-	      "deleteInspectedObjs": this._deleteInspectedObjs
-	    }), React.createElement("div", {
-	      "className": "inspector-content"
-	    }, React.createElement("iframe", {
-	      "src": this._detailsViewUrl(),
-	      "name": "scrivito_inspector"
-	    }))) : React.createElement(InspectorHeader, {
-	      "editingView": this.props.editingView,
-	      "disableDelete": this.props.disableDelete,
-	      "dispatch": this.props.dispatch,
-	      "selectedObjs": this.props.selectedObjs,
-	      "deleteInspectedObjs": this._deleteInspectedObjs
-	    }) : void 0));
-	  }
-	});
-
-	module.exports = Inspector;
+	  render: function render() {
+	    return React.createElement(
+	      'div',
+	      { className: 'scrivito-content-browser-inspector' },
+	      this._renderContent()
+	    );
+	  },
+	  _renderContent: function _renderContent() {
+	    var _props = this.props,
+	        selectedObjs = _props.selectedObjs,
+	        editingView = _props.editingView,
+	        disableDelete = _props.disableDelete,
+	        dispatch = _props.dispatch;
 
 
-/***/ },
-/* 109 */
-/***/ function(module, exports) {
+	    if (!selectedObjs.length) {
+	      return null;
+	    }
 
-	var MaximizeInspectorToggle;
+	    if (selectedObjs.length === 1) {
+	      return React.createElement(
+	        'div',
+	        null,
+	        React.createElement(_inspector_header2.default, {
+	          editingView: editingView,
+	          disableDelete: disableDelete,
+	          dispatch: dispatch,
+	          selectedObjs: selectedObjs,
+	          deleteInspectedObjs: this._deleteInspectedObjs
+	        }),
+	        React.createElement(
+	          'div',
+	          { className: 'inspector-content' },
+	          this._renderLoader(),
+	          React.createElement('iframe', {
+	            name: 'scrivito_inspector',
+	            className: this.state.isLoaded ? undefined : 'scrivito_hidden',
+	            src: this._detailsViewUrl(),
+	            onLoad: this._onLoad
+	          })
+	        )
+	      );
+	    }
 
-	MaximizeInspectorToggle = React.createClass({
-	  displayName: 'MaximizeInspectorToggle',
-	  _toggleMaximized: function() {
-	    return this.props.toggleInspectorMaximized();
+	    return React.createElement(_inspector_header2.default, {
+	      editingView: editingView,
+	      disableDelete: disableDelete,
+	      dispatch: dispatch,
+	      selectedObjs: selectedObjs,
+	      deleteInspectedObjs: this._deleteInspectedObjs
+	    });
 	  },
-	  render: function() {
-	    return React.createElement("span", {
-	      "className": "scrivito_move_left",
-	      "title": "Maximize details view",
-	      "onClick": this._toggleMaximized
-	    }, React.createElement("span", {
-	      "className": "scrivito_icon scrivito_icon_chevron_left"
-	    }));
+	  _renderLoader: function _renderLoader() {
+	    if (!this.state.isLoaded) {
+	      return React.createElement(_spinner2.default, null);
+	    }
+	  },
+	  _detailsViewUrl: function _detailsViewUrl() {
+	    return scrivito.details_url_for_obj_id(this.props.selectedObjs[0]);
+	  },
+	  _onLoad: function _onLoad() {
+	    this.setState({ isLoaded: true });
+	  },
+	  _deleteInspectedObjs: function _deleteInspectedObjs() {
+	    var _props2 = this.props,
+	        selectedObjs = _props2.selectedObjs,
+	        dispatch = _props2.dispatch;
+
+	    if (selectedObjs.length) {
+	      var _scrivito$ConfirmDele;
+
+	      (_scrivito$ConfirmDele = scrivito.ConfirmDeleteDialog).open.apply(_scrivito$ConfirmDele, _toConsumableArray(selectedObjs)).then(function (isConfirmed) {
+	        if (isConfirmed) {
+	          _.each(selectedObjs, function (objId) {
+	            return dispatch((0, _obj.objDeleted)(objId));
+	          });
+	        }
+	      });
+	    }
 	  }
 	});
 
-	module.exports = MaximizeInspectorToggle;
-
+	exports.default = Inspector;
 
 /***/ },
-/* 110 */
+/* 109 */
 /***/ function(module, exports, __webpack_require__) {
 
 	var InspectorHeader, MaximizeInspectorToggle, toggleInspectorMaximized;
 
-	MaximizeInspectorToggle = __webpack_require__(109);
+	MaximizeInspectorToggle = __webpack_require__(110);
 
 	toggleInspectorMaximized = __webpack_require__(111).toggleInspectorMaximized;
 
@@ -6257,133 +6575,124 @@
 
 
 /***/ },
-/* 111 */
+/* 110 */
 /***/ function(module, exports) {
 
-	var MAXIMIZE_TOGGLE, toggleInspectorMaximized;
+	var MaximizeInspectorToggle;
+
+	MaximizeInspectorToggle = React.createClass({
+	  displayName: 'MaximizeInspectorToggle',
+	  _toggleMaximized: function() {
+	    return this.props.toggleInspectorMaximized();
+	  },
+	  render: function() {
+	    return React.createElement("span", {
+	      "className": "scrivito_move_left",
+	      "title": "Maximize details view",
+	      "onClick": this._toggleMaximized
+	    }, React.createElement("span", {
+	      "className": "scrivito_icon scrivito_icon_chevron_left"
+	    }));
+	  }
+	});
+
+	module.exports = MaximizeInspectorToggle;
 
-	MAXIMIZE_TOGGLE = 'MAXIMAZED_INSPECTOR_TOGGLE';
 
-	toggleInspectorMaximized = function() {
-	  return {
-	    type: MAXIMIZE_TOGGLE
-	  };
-	};
+/***/ },
+/* 111 */
+/***/ function(module, exports) {
 
-	module.exports = {
-	  MAXIMIZE_TOGGLE: MAXIMIZE_TOGGLE,
-	  toggleInspectorMaximized: toggleInspectorMaximized
-	};
+	'use strict';
 
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.toggleInspectorMaximized = toggleInspectorMaximized;
+	var MAXIMIZE_TOGGLE = exports.MAXIMIZE_TOGGLE = 'MAXIMAZED_INSPECTOR_TOGGLE';
+
+	function toggleInspectorMaximized() {
+	  return { type: MAXIMIZE_TOGGLE };
+	}
 
 /***/ },
 /* 112 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var CREATE_OBJ_FAILED, CREATE_OBJ_FINISH, CREATE_OBJ_START, DELETE_OBJ_FINISH, LAST_ADDED, createObj, objDeleted, _createObjFailed, _createObjFinish, _createObjStart, _getTagsAttributes, _hasCorrectTagAttribute;
-
-	LAST_ADDED = __webpack_require__(72).LAST_ADDED;
-
-	CREATE_OBJ_START = 'CREATE_OBJ_START';
+	'use strict';
 
-	CREATE_OBJ_FINISH = 'CREATE_OBJ_FINISH';
+	Object.defineProperty(exports, "__esModule", {
+	  value: true
+	});
+	exports.DELETE_OBJ_FINISH = exports.CREATE_OBJ_FAILED = exports.CREATE_OBJ_FINISH = exports.CREATE_OBJ_START = undefined;
+	exports.createObjStart = createObjStart;
+	exports.createObjFinish = createObjFinish;
+	exports.createObjFailed = createObjFailed;
+	exports.objDeleted = objDeleted;
+	exports.createObj = createObj;
+
+	var _obj_source = __webpack_require__(72);
+
+	var CREATE_OBJ_START = exports.CREATE_OBJ_START = 'CREATE_OBJ_START';
+	var CREATE_OBJ_FINISH = exports.CREATE_OBJ_FINISH = 'CREATE_OBJ_FINISH';
+	var CREATE_OBJ_FAILED = exports.CREATE_OBJ_FAILED = 'CREATE_OBJ_FAILED';
+	var DELETE_OBJ_FINISH = exports.DELETE_OBJ_FINISH = 'DELETE_OBJ_FINISH';
+
+	function createObjStart(additionId, filename) {
+	  return { type: CREATE_OBJ_START, additionId: additionId, filename: filename, progress: 10 };
+	}
 
-	CREATE_OBJ_FAILED = 'CREATE_OBJ_FAILED';
+	function createObjFinish(additionId, objId, isLastAddedVisible) {
+	  return { type: CREATE_OBJ_FINISH, additionId: additionId, objId: objId, isLastAddedVisible: isLastAddedVisible };
+	}
 
-	DELETE_OBJ_FINISH = 'DELETE_OBJ_FINISH';
+	function createObjFailed(additionId, message) {
+	  return { type: CREATE_OBJ_FAILED, additionId: additionId, message: message };
+	}
 
-	_createObjStart = function(additionId, filename) {
-	  return {
-	    type: CREATE_OBJ_START,
-	    additionId: additionId,
-	    filename: filename,
-	    progress: 10
-	  };
-	};
+	function getTagsAttributes(objClassName, activeTags) {
+	  if (activeTags.length > 0 && scrivito.hasTagsAttribute(objClassName)) {
+	    return { tags: activeTags };
+	  }
+	}
 
-	_createObjFinish = function(additionId, objId, isLastAddedVisible) {
-	  return {
-	    type: CREATE_OBJ_FINISH,
-	    additionId: additionId,
-	    objId: objId,
-	    isLastAddedVisible: isLastAddedVisible
-	  };
-	};
+	function objDeleted(objId) {
+	  scrivito.delete_obj(objId);
+	  return { type: DELETE_OBJ_FINISH, objId: objId };
+	}
 
-	_createObjFailed = function(additionId, message) {
-	  return {
-	    type: CREATE_OBJ_FAILED,
-	    additionId: additionId,
-	    message: message
-	  };
-	};
+	function createObj() {
+	  var attributes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+	  var basePreset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+	  var preset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+	  var activeTags = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
 
-	_hasCorrectTagAttribute = function(objClass) {
-	  var _ref;
-	  return (objClass != null ? (_ref = objClass.attribute('tags')) != null ? _ref.type : void 0 : void 0) === 'stringlist';
-	};
+	  return function (dispatch, getState) {
+	    var additionId = _.uniqueId('addition');
 
-	_getTagsAttributes = function(objClassName, activeTags) {
-	  var objClass;
-	  objClass = scrivito.ObjClass.find(objClassName);
-	  if (activeTags.length > 0 && _hasCorrectTagAttribute(objClass)) {
-	    return {
-	      tags: activeTags
-	    };
-	  }
-	};
+	    var objClassName = attributes._obj_class || preset._obj_class || basePreset._obj_class;
+	    var tags = getTagsAttributes(objClassName, activeTags) || {};
 
-	objDeleted = function(objId) {
-	  scrivito.delete_obj(objId);
-	  return {
-	    type: DELETE_OBJ_FINISH,
-	    objId: objId
-	  };
-	};
+	    var extendedAtrributes = _.extend({}, basePreset, tags, preset, attributes);
 
-	createObj = function(attributes, basePreset, preset, activeTags) {
-	  if (attributes == null) {
-	    attributes = {};
-	  }
-	  if (basePreset == null) {
-	    basePreset = {};
-	  }
-	  if (preset == null) {
-	    preset = {};
-	  }
-	  if (activeTags == null) {
-	    activeTags = [];
-	  }
-	  return function(dispatch, getState) {
-	    var additionId, filename, objClassName, tags, _ref;
-	    additionId = _.uniqueId('addition');
-	    objClassName = attributes._obj_class || preset._obj_class || basePreset._obj_class;
-	    tags = _getTagsAttributes(objClassName, activeTags) || {};
-	    attributes = _.extend({}, basePreset, tags, preset, attributes);
-	    filename = (_ref = attributes.blob) != null ? _ref.name : void 0;
-	    dispatch(_createObjStart(additionId, filename));
-	    return scrivito.create_obj(attributes).then(function(obj) {
-	      var isLastAddedVisible;
-	      isLastAddedVisible = getState().objSource.activeSource === LAST_ADDED;
-	      return dispatch(_createObjFinish(additionId, obj.id, isLastAddedVisible));
-	    }).fail(function(error) {
-	      return dispatch(_createObjFailed(additionId, error != null ? error.message : void 0));
+	    var filename = void 0;
+	    if (extendedAtrributes.blob) {
+	      filename = extendedAtrributes.blob.name;
+	    }
+	    dispatch(createObjStart(additionId, filename));
+
+	    return scrivito.create_obj(extendedAtrributes).then(function (obj) {
+	      var isLastAddedVisible = getState().objSource.activeSource === _obj_source.LAST_ADDED;
+	      dispatch(createObjFinish(additionId, obj.id, isLastAddedVisible));
+	    }).fail(function (error) {
+	      var message = void 0;
+	      if (error) {
+	        message = error.message;
+	      }
+	      dispatch(createObjFailed(additionId, message));
 	    });
 	  };
-	};
-
-	module.exports = {
-	  CREATE_OBJ_START: CREATE_OBJ_START,
-	  CREATE_OBJ_FINISH: CREATE_OBJ_FINISH,
-	  CREATE_OBJ_FAILED: CREATE_OBJ_FAILED,
-	  DELETE_OBJ_FINISH: DELETE_OBJ_FINISH,
-	  _createObjStart: _createObjStart,
-	  _createObjFinish: _createObjFinish,
-	  _createObjFailed: _createObjFailed,
-	  createObj: createObj,
-	  objDeleted: objDeleted
-	};
-
+	}
 
 /***/ },
 /* 113 */
@@ -6469,7 +6778,7 @@
 
 	thunkMiddleware = __webpack_require__(115);
 
-	_ref = __webpack_require__(34), createStore = _ref.createStore, applyMiddleware = _ref.applyMiddleware;
+	_ref = __webpack_require__(33), createStore = _ref.createStore, applyMiddleware = _ref.applyMiddleware;
 
 	combinedReducer = __webpack_require__(116);
 
@@ -6507,7 +6816,7 @@
 
 	var Redux, TagsReducer, combinedReducer, inspectorReducer, lastAddedReducer, objDisplayReducer, objLoadReducer, objSource, selectionReducer, sortCriteria;
 
-	Redux = __webpack_require__(34);
+	Redux = __webpack_require__(33);
 
 	inspectorReducer = __webpack_require__(117);
 
@@ -6653,7 +6962,7 @@
 /* 119 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var invariant = __webpack_require__(55);
+	var invariant = __webpack_require__(54);
 
 	var hasOwnProperty = Object.prototype.hasOwnProperty;
 	var splice = Array.prototype.splice;
@@ -6850,19 +7159,16 @@
 	});
 	exports.default = objDisplayReducer;
 
-	var _obj_display = __webpack_require__(22);
+	var _obj_display = __webpack_require__(21);
 
 	function objDisplayReducer(state, action) {
-	  if (!state) {
-	    state = { viewMode: _obj_display.THUMBNAIL_VIEW };
-	  }
 	  switch (action.type) {
 	    case _obj_display.SET_VIEW_MODE:
 	      return { viewMode: action.viewMode };
 	    default:
-	      return state;
+	      return state || { viewMode: _obj_display.THUMBNAIL_VIEW };
 	  }
-	};
+	}
 
 /***/ },
 /* 121 */
@@ -6870,7 +7176,7 @@
 
 	var DEFAULT_NUMBER_TO_LOAD, FILTER, LOAD_MORE_OBJS, SET_OBJ_SOURCE, objLoadReducer, _ref, _ref1;
 
-	_ref = __webpack_require__(105), LOAD_MORE_OBJS = _ref.LOAD_MORE_OBJS, DEFAULT_NUMBER_TO_LOAD = _ref.DEFAULT_NUMBER_TO_LOAD;
+	_ref = __webpack_require__(106), LOAD_MORE_OBJS = _ref.LOAD_MORE_OBJS, DEFAULT_NUMBER_TO_LOAD = _ref.DEFAULT_NUMBER_TO_LOAD;
 
 	_ref1 = __webpack_require__(72), FILTER = _ref1.FILTER, SET_OBJ_SOURCE = _ref1.SET_OBJ_SOURCE;
 
@@ -6908,7 +7214,7 @@
 
 	var CHANGE_SORT_ORDER, DESC_SORT_ORDER, sortCriteriaReducer, _ref;
 
-	_ref = __webpack_require__(16), CHANGE_SORT_ORDER = _ref.CHANGE_SORT_ORDER, DESC_SORT_ORDER = _ref.DESC_SORT_ORDER;
+	_ref = __webpack_require__(55), CHANGE_SORT_ORDER = _ref.CHANGE_SORT_ORDER, DESC_SORT_ORDER = _ref.DESC_SORT_ORDER;
 
 	sortCriteriaReducer = function(state, action) {
 	  if (state == null) {
@@ -6937,7 +7243,7 @@
 
 	var EXPAND_TOGGLE, TOGGLE_TAG, TagsReducer, defaultState, getActiveTags, _ref;
 
-	_ref = __webpack_require__(104), EXPAND_TOGGLE = _ref.EXPAND_TOGGLE, TOGGLE_TAG = _ref.TOGGLE_TAG;
+	_ref = __webpack_require__(105), EXPAND_TOGGLE = _ref.EXPAND_TOGGLE, TOGGLE_TAG = _ref.TOGGLE_TAG;
 
 	getActiveTags = function(currentActiveTags, actionTag) {
 	  var activeTags;