@r/api-client/apiClient.js

node and browser reddit api library

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("lodash/object"), require("superagent"), require("lodash/lang"), require("lodash/array"), require("lodash/collection"));
	else if(typeof define === 'function' && define.amd)
		define(["lodash/object", "superagent", "lodash/lang", "lodash/array", "lodash/collection"], factory);
	else if(typeof exports === 'object')
		exports["apiClient.js"] = factory(require("lodash/object"), require("superagent"), require("lodash/lang"), require("lodash/array"), require("lodash/collection"));
	else
		root["apiClient.js"] = factory(root["lodash/object"], root["superagent"], root["lodash/lang"], root["lodash/array"], root["lodash/collection"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_25__, __WEBPACK_EXTERNAL_MODULE_72__, __WEBPACK_EXTERNAL_MODULE_78__, __WEBPACK_EXTERNAL_MODULE_180__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.l = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 54);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	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"); } }

	var THING_ID_REGEX = new RegExp('^t\\d_[0-9a-z]+', 'i');

	var Base = function () {
	  function Base() {
	    var props = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

	    _classCallCheck(this, Base);

	    this._type = 'Base';

	    this.props = {};

	    for (var p in props) {
	      this.props[p] = props[p];
	    }
	  }

	  _createClass(Base, [{
	    key: 'validators',
	    value: function validators() {
	      return;
	    }
	  }, {
	    key: 'get',
	    value: function get(name) {
	      return this.props[name];
	    }
	  }, {
	    key: 'set',
	    value: function set(name, value) {
	      if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
	        Object.assign(this.props, name);
	      } else {
	        this.props[name] = value;
	      }
	    }
	  }, {
	    key: 'validate',
	    value: function validate(keys) {
	      var validators = this.validators();

	      if (!validators) {
	        return true;
	      }

	      var invalid = [];
	      var p = void 0;

	      for (p in this.props) {
	        // Optionally, send in an array of keys to validate
	        if (!keys || keys.includes(p)) {
	          if (validators[p] && !validators[p](this.props[p])) {
	            invalid.push(p);
	          }
	        }
	      }

	      if (invalid.length === 0) {
	        return true;
	      }

	      return invalid;
	    }
	  }, {
	    key: 'uuid',
	    value: function uuid(props) {
	      if (Base.validators.thingId(props.name)) {
	        return props.name;
	      } else if (Base.validators.thingId(props.id)) {
	        return props.id;
	      }
	    }
	  }, {
	    key: 'toJSON',
	    value: function toJSON() {
	      var formatter = arguments.length <= 0 || arguments[0] === undefined ? this.noopFormat : arguments[0];

	      var props = this.props;
	      props._type = this._type;
	      props.uuid = this.uuid(props);

	      if (formatter && typeof formatter === 'function') {
	        return formatter(props);
	      }

	      return props;
	    }
	  }]);

	  return Base;
	}();

	Base.validators = {
	  integer: function integer(i) {
	    return i === parseInt(i);
	  },

	  string: function string(s) {
	    return s === s.toString();
	  },

	  min: function min(i, _min) {
	    return i >= _min;
	  },

	  max: function max(i, _max) {
	    return i <= _max;
	  },

	  maxLength: function maxLength(s, l) {
	    return Base.validators.max(s.length, l);
	  },

	  minLength: function minLength(s, l) {
	    return Base.validators.min(s.length, l);
	  },

	  regex: function regex(s, expr) {
	    return expr.test(s);
	  },

	  thingId: function thingId(id) {
	    return id == null || Base.validators.regex(id, THING_ID_REGEX);
	  }
	};
	/* harmony default export */ exports["a"] = Base;

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_superagent__ = __webpack_require__(25);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_superagent___default = __WEBPACK_IMPORTED_MODULE_0_superagent__ && __WEBPACK_IMPORTED_MODULE_0_superagent__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_superagent__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_superagent__; }
	/* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_superagent___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_superagent___default });
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__models2_thingTypes__ = __webpack_require__(5);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__errors_validationError__ = __webpack_require__(8);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__errors_noModelError__ = __webpack_require__(7);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__errors_notImplementedError__ = __webpack_require__(15);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_5__APIResponse__ = __webpack_require__(53);
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

	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"); } }








	var EVENTS = {
	  request: 'request',
	  response: 'response',
	  error: 'error',
	  result: 'result'
	};

	var BaseAPI = function () {
	  function BaseAPI(base) {
	    var _this = this;

	    _classCallCheck(this, BaseAPI);

	    this.runQuery = function (method, rawQuery) {
	      var originalMethod = method;
	      var query = _this.formatQuery(_extends({}, rawQuery), method);
	      query.app = _this.appParameter;

	      var handle = _this.handle;
	      var path = _this.fullPath(method, _extends({}, rawQuery));

	      var fakeReq = { url: path, method: method, query: query };
	      _this.event.emit(EVENTS.request, fakeReq);

	      method = query._method || method;
	      delete query._method;

	      return new Promise(function (resolve, reject) {
	        var s = /* harmony import */__WEBPACK_IMPORTED_MODULE_0_superagent___default.a[method](path).timeout(_this.config.timeout || 5000);

	        if (s.redirects) {
	          s.redirects(0);
	        }

	        s.query(query);

	        s.set(_this.buildAuthHeader());
	        s.set(_this.buildHeaders());

	        if (query.id && !Array.isArray(query.id)) {
	          delete query.id;
	        }

	        s.end(function (err, res) {
	          if (err && err.timeout) {
	            err.status = 504;
	          }

	          var origin = _this.origin;
	          var path = _this.path(method, rawQuery);

	          var fakeReq = { origin: origin, path: path, method: method, query: query };
	          var req = res ? res.request : fakeReq;

	          handle(resolve, reject)(err, res, req, rawQuery, originalMethod);
	        });
	      });
	    };

	    this.handle = function (resolve, reject) {
	      return function (err, res, req, query, method) {
	        // lol handle the twelve ways superagent sends request back
	        if (res && !req) {
	          req = res.request || res.req;
	        }

	        if (err || res && !res.ok) {
	          //this.event.emit(EVENTS.error, err, req);

	          if (_this.config.defaultErrorHandler) {
	            return _this.config.defaultErrorHandler(err || 500);
	          } else {
	            return reject(err || 500);
	          }
	        }

	        _this.event.emit(EVENTS.response, req, res);

	        var meta = void 0;
	        var body = void 0;
	        var apiResponse = void 0;

	        try {
	          meta = _this.formatMeta(res, req, method);
	          var start = Date.now();
	          apiResponse = new /* harmony import */__WEBPACK_IMPORTED_MODULE_5__APIResponse__["a"](meta, query);
	          try {
	            _this.parseBody(res, apiResponse, req, method);
	            _this.parseTime = Date.now() - start;
	          } catch (e) {
	            _this.event.emit(EVENTS.error, e, req);
	            console.trace(e);
	          }

	          if (_this.formatBody) {
	            // shim for older apis or ones were we haven't figured out normalization yet
	            body = _this.formatBody(res, req, method);
	          }
	        } catch (e) {
	          if ({"NODE_ENV":"production"}.DEBUG_API_CLIENT_BASE) {
	            console.trace(e);
	          }

	          return reject(e);
	        }

	        _this.event.emit(EVENTS.result, body || apiResponse);

	        resolve(body || apiResponse);
	      };
	    };

	    this.config = base.config;
	    this.event = base.event;

	    if (base.config) {
	      this.origin = base.config.origin;

	      if (base.config.origins) {
	        var name = this.constructor.name.toLowerCase();

	        this.origin = base.config.origins[name] || this.config.origin;
	      }
	    }

	    ['path', 'head', 'get', 'post', 'patch', 'put', 'del', 'move', 'copy'].forEach(function (method) {
	      _this[method] = _this[method].bind(_this);
	    });
	  }

	  // Used to format/unformat for caching; `links` or `comments`, for example.
	  // Should match the constructor name.


	  _createClass(BaseAPI, [{
	    key: 'path',
	    value: function path(method) {
	      var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      var basePath = this.api;

	      if (['string', 'number'].contains(_typeof(query.id))) {
	        basePath += '/' + query.id;
	      }

	      return basePath;
	    }
	  }, {
	    key: 'fullPath',
	    value: function fullPath(method) {
	      var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      return this.origin + '/' + this.path(method, query);
	    }
	  }, {
	    key: 'formatMeta',
	    value: function formatMeta(res) {
	      return res.headers;
	    }
	  }, {
	    key: 'buildQueryParams',
	    value: function buildQueryParams(method, data) {
	      return [data, method, data];
	    }
	  }, {
	    key: 'buildAuthHeader',
	    value: function buildAuthHeader() {
	      var token = this.config.token;

	      if (token) {
	        return { Authorization: 'Bearer ' + token };
	      }

	      return {};
	    }
	  }, {
	    key: 'buildHeaders',
	    value: function buildHeaders() {
	      return this.config.defaultHeaders || {};
	    }
	  }, {
	    key: 'formatQuery',
	    value: function formatQuery(query) {
	      return query;
	    }
	  }, {
	    key: 'parseBody',
	    value: function parseBody(res, apiResponse /*, req, method*/) {
	      apiResponse.addResult(res.body);
	      return;
	    }
	  }, {
	    key: 'formatData',
	    value: function formatData(data) {
	      return data;
	    }
	  }, {
	    key: 'rawSend',
	    value: function rawSend(method, path, data, cb) {
	      var origin = this.origin;

	      var s = /* harmony import */__WEBPACK_IMPORTED_MODULE_0_superagent___default.a[method](origin + '/' + path);
	      s.type('form');

	      if (this.config.token) {
	        s.set('Authorization', 'bearer ' + this.config.token);
	      }

	      s.send(data).end(function (err, res) {
	        var fakeReq = {
	          origin: origin,
	          path: path,
	          method: method,
	          query: data
	        };

	        var req = res ? res.request : fakeReq;
	        cb(err, res, req);
	      });
	    }
	  }, {
	    key: 'save',
	    value: function save(method) {
	      var _this2 = this;

	      var data = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      return new Promise(function (resolve, reject) {
	        if (!data) {
	          return reject(new /* harmony import */__WEBPACK_IMPORTED_MODULE_3__errors_noModelError__["a"](_this2.api));
	        }

	        data = _this2.formatQuery(data, method);
	        data.app = _this2.appParameter;

	        if (_this2.model) {
	          var model = new _this2.model(data);

	          var keys = void 0;

	          // Only validate keys being sent in, if this is a patch
	          if (method === 'patch') {
	            keys = Object.keys(data);
	          }

	          var valid = model.validate(keys);

	          if (valid !== true) {
	            return reject(new /* harmony import */__WEBPACK_IMPORTED_MODULE_2__errors_validationError__["a"](_this2.api, model));
	          }

	          if (method !== 'patch') {
	            data = model.toJSON();
	          }
	        }

	        var path = _this2.path(method, data);
	        var _method = method;

	        method = data._method || method;

	        data = _this2.formatData(data, _method);

	        _this2.rawSend(method, path, data, function (err, res, req) {
	          _this2.handle(resolve, reject)(err, res, req, data, method);
	        });
	      });
	    }
	  }, {
	    key: 'head',
	    value: function head() {
	      var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

	      return this.runQuery('head', query);
	    }
	  }, {
	    key: 'get',
	    value: function get(query) {
	      query = _extends({
	        raw_json: 1
	      }, query || {});

	      return this.runQuery('get', query);
	    }
	  }, {
	    key: 'del',
	    value: function del() {
	      var query = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

	      return this.runQuery('del', query);
	    }
	  }, {
	    key: 'post',
	    value: function post(data) {
	      return this.save('post', data);
	    }
	  }, {
	    key: 'put',
	    value: function put(data) {
	      return this.save('put', data);
	    }
	  }, {
	    key: 'patch',
	    value: function patch(data) {
	      return this.save('patch', data);
	    }

	    // Get the source, then save it, modified by data.

	  }, {
	    key: 'copy',
	    value: function copy(fromId, data) {
	      var _this3 = this;

	      return new Promise(function (resolve, reject) {
	        _this3.get(fromId).then(function (oldData) {
	          _this3.save('copy', _extends({}, oldData, {
	            _method: data.id ? 'put' : 'post'
	          }, data)).then(resolve, reject);
	        });
	      });
	    }

	    // Get the old one, save the new one, then delete the old one if save succeeded

	  }, {
	    key: 'move',
	    value: function move(fromId, toId, data) {
	      var _this4 = this;

	      return new Promise(function (resolve, reject) {
	        _this4.get(fromId).then(function (oldData) {
	          _this4.save('move', _extends({
	            _method: 'put'
	          }, oldData, {
	            id: toId
	          }, data)).then(function (data) {
	            _this4.del({ id: fromId }).then(function () {
	              resolve(data);
	            }, reject);
	          }, reject);
	        });
	      });
	    }
	  }, {
	    key: 'notImplemented',
	    value: function notImplemented(method) {
	      return function () {
	        throw new /* harmony import */__WEBPACK_IMPORTED_MODULE_4__errors_notImplementedError__["a"](method, this.api);
	      };
	    }
	  }, {
	    key: 'buildResponse',
	    value: function buildResponse(body, meta) {
	      var results = body.results;
	      var errors = body.errors;
	      var users = body.users;
	      var links = body.links;
	      var comments = body.comments;
	      var messages = body.messages;
	      var subreddits = body.subreddits;

	      if (errors) {
	        return { errors: errors, meta: meta };
	      }

	      var response = { results: results, meta: meta };
	      if (users) {
	        response.users = users;
	      }
	      if (links) {
	        response.links = links;
	      }
	      if (comments) {
	        response.comments = comments;
	      }
	      if (messages) {
	        response.messages = messages;
	      }
	      if (subreddits) {
	        response.subreddits = subreddits;
	      }
	      return response;
	    }
	  }, {
	    key: 'dataType',
	    get: function get() {
	      return this.constructor.name.toLowerCase();
	    }
	  }, {
	    key: 'api',
	    get: function get() {
	      return this.constructor.name.toLowerCase();
	    }
	  }, {
	    key: 'appParameter',
	    get: function get() {
	      return this.config.appName + '-' + this.config.env;
	    }
	  }], [{
	    key: 'thingType',
	    value: function thingType(id) {
	      return /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models2_thingTypes__["g"].bind()(id);
	    }
	  }]);

	  return BaseAPI;
	}();

	BaseAPI.EVENTS = EVENTS;
	/* harmony default export */ exports["a"] = BaseAPI;

/***/ },
/* 2 */,
/* 3 */
/***/ function(module, exports) {

	module.exports = require("lodash/object");

/***/ },
/* 4 */,
/* 5 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony export */ exports["g"] = thingType;var COMMENT = 'comment';
	/* harmony export */ Object.defineProperty(exports, "a", {configurable: false, enumerable: true, get: function() { return COMMENT; }});
	var COMMENT_TYPE = 't1';/* unused harmony export COMMENT_TYPE */
	var COMMENT_LOAD_MORE = 'comment_load_more';
	/* harmony export */ Object.defineProperty(exports, "h", {configurable: false, enumerable: true, get: function() { return COMMENT_LOAD_MORE; }});

	var USER = 'user';
	/* harmony export */ Object.defineProperty(exports, "c", {configurable: false, enumerable: true, get: function() { return USER; }});
	var USER_TYPE = 't2';
	/* harmony export */ Object.defineProperty(exports, "j", {configurable: false, enumerable: true, get: function() { return USER_TYPE; }});

	var LINK = 'link';
	/* harmony export */ Object.defineProperty(exports, "b", {configurable: false, enumerable: true, get: function() { return LINK; }});
	var LINK_TYPE = 't3';
	/* harmony export */ Object.defineProperty(exports, "i", {configurable: false, enumerable: true, get: function() { return LINK_TYPE; }});

	var MESSAGE = 'message';
	/* harmony export */ Object.defineProperty(exports, "d", {configurable: false, enumerable: true, get: function() { return MESSAGE; }});
	var MESSAGE_TYPE = 't4';/* unused harmony export MESSAGE_TYPE */

	var SUBREDDIT = 'subreddit';
	/* harmony export */ Object.defineProperty(exports, "e", {configurable: false, enumerable: true, get: function() { return SUBREDDIT; }});
	var SUBREDDIT_TYPE = 't5';/* unused harmony export SUBREDDIT_TYPE */

	var TROPHIE = 'trophie';/* unused harmony export TROPHIE */
	var TROPHIE_TYPE = 't6';/* unused harmony export TROPHIE_TYPE */

	var PROMOCAMPAIGN = 'promocampaign';/* unused harmony export PROMOCAMPAIGN */
	var PROMOCAMPAIGN_TYPE = 't8';/* unused harmony export PROMOCAMPAIGN_TYPE */

	var type_pairs = [[COMMENT, COMMENT_TYPE], [USER, USER_TYPE], [LINK, LINK_TYPE], [MESSAGE, MESSAGE_TYPE], [SUBREDDIT, SUBREDDIT_TYPE], [TROPHIE, TROPHIE_TYPE], [PROMOCAMPAIGN, PROMOCAMPAIGN_TYPE]];

	var TYPES = type_pairs.reduce(function (table, pair) {
	  table[pair[1]] = pair[0];
	  return table;
	}, {});
	/* harmony export */ Object.defineProperty(exports, "f", {configurable: false, enumerable: true, get: function() { return TYPES; }});

	var TYPE_TO_THING_TYPE = type_pairs.reduce(function (table, pair) {
	  table[pair[0]] = pair[1];
	  return table;
	}, {});/* unused harmony export TYPE_TO_THING_TYPE */

	function thingType(id) {
	  return TYPES[id.substring(0, 2)];
	}

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_object__ = __webpack_require__(3);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_lodash_object___default = __WEBPACK_IMPORTED_MODULE_0_lodash_object__ && __WEBPACK_IMPORTED_MODULE_0_lodash_object__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_object__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_0_lodash_object__; }
	/* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_0_lodash_object___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_0_lodash_object___default });
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__base__ = __webpack_require__(1);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__errors_noModelError__ = __webpack_require__(7);
	var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

	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"); } }

	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 MOD_ACTION_MAP = {
	  approved: function approved(t, data) {
	    return [t ? 'api/approve' : 'api/remove', /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_object__["pick"].bind()(data, ['id', 'spam'])];
	  },
	  removed: function removed(t, data) {
	    return [t ? 'api/remove' : 'api/approve', /* harmony import */__WEBPACK_IMPORTED_MODULE_0_lodash_object__["pick"].bind()(data, ['id', 'spam'])];
	  },
	  distinguished: function distinguished(_, data) {
	    return ['api/distinguish', {
	      id: data.id,
	      how: data.distinguished
	    }];
	  },
	  ignoreReports: function ignoreReports(_, data) {
	    return ['api/ignore_reports', {
	      id: data.id,
	      spam: data.isSpam
	    }];
	  }
	};

	var BaseContent = function (_BaseAPI) {
	  _inherits(BaseContent, _BaseAPI);

	  function BaseContent() {
	    var _Object$getPrototypeO;

	    var _temp, _this, _ret;

	    _classCallCheck(this, BaseContent);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(BaseContent)).call.apply(_Object$getPrototypeO, [this].concat(args))), _this), _this.move = _this.notImplemented('move'), _this.copy = _this.notImplemented('copy'), _this.put = _this.notImplemented('put'), _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(BaseContent, [{
	    key: 'formatQuery',
	    value: function formatQuery(query, method) {
	      if (method !== 'patch') {
	        query.feature = 'link_preview';
	        query.sr_detail = 'true';
	      }

	      if (method === 'del') {
	        query._method = 'post';
	      }

	      return query;
	    }
	  }, {
	    key: 'path',
	    value: function path(method) {
	      var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      if (method === 'get') {
	        return this.getPath(query);
	      } else if (method === 'post') {
	        return this.postPath(query);
	      } else if (method === 'patch') {
	        return this.patchPath(query);
	      } else if (method === 'del') {
	        return this.deletePath(query);
	      }
	    }
	  }, {
	    key: 'patchPath',
	    value: function patchPath() {
	      return 'api/editusertext';
	    }
	  }, {
	    key: 'deletePath',
	    value: function deletePath() {
	      return 'api/del';
	    }
	  }, {
	    key: 'patch',
	    value: function patch(data) {
	      var _this2 = this;

	      if (!data) {
	        throw new /* harmony import */__WEBPACK_IMPORTED_MODULE_2__errors_noModelError__["a"]('/api/editusertext');
	      }

	      var promises = [];

	      Object.keys(data).map(function (k) {
	        var prop = MOD_ACTION_MAP[k];
	        var val = data[k];

	        if (prop) {
	          (function () {
	            var _prop = prop(val, data);

	            var _prop2 = _slicedToArray(_prop, 2);

	            var api = _prop2[0];
	            var json = _prop2[1];

	            promises.push(new Promise(function (r, x) {
	              _this2.rawSend('post', api, json, function (err, res, req) {
	                if (err || !res.ok) {
	                  x(err || res);
	                }

	                r(res, req);
	              });
	            }));
	          })();
	        }
	      });

	      if (data.text) {
	        var json = {
	          api_type: 'json',
	          thing_id: data.id,
	          text: data.text,
	          _method: 'post'
	        };

	        promises.push(this.save('patch', json));
	      }

	      return Promise.all(promises);
	    }
	  }]);

	  return BaseContent;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_1__base__["a"]);

	/* harmony default export */ exports["a"] = BaseContent;

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__error__ = __webpack_require__(11);
	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 NoModelError = function (_FakeError) {
	  _inherits(NoModelError, _FakeError);

	  function NoModelError(endpoint) {
	    _classCallCheck(this, NoModelError);

	    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(NoModelError).call(this, endpoint));

	    _this.name = 'NoModelError';
	    _this.message = 'No model given for api endpoint ' + endpoint;
	    _this.status = 400;
	    return _this;
	  }

	  return NoModelError;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__error__["a"]);

	/* harmony default export */ exports["a"] = NoModelError;

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__error__ = __webpack_require__(11);
	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 ValidationError = function (_FakeError) {
	  _inherits(ValidationError, _FakeError);

	  function ValidationError(name, model, errors) {
	    _classCallCheck(this, ValidationError);

	    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(ValidationError).call(this, name));

	    _this.name = 'NoModelError';

	    _this.message = name + ' had errors in: ' + errors.join(',') + ' with properties ' + JSON.stringify(model.toJSON());

	    _this.status = 422;
	    return _this;
	  }

	  return ValidationError;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__error__["a"]);

	/* harmony default export */ exports["a"] = ValidationError;

/***/ },
/* 9 */,
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__error__ = __webpack_require__(11);
	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"); } }

	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 DisconnectedError = function (_FakeError) {
	  _inherits(DisconnectedError, _FakeError);

	  function DisconnectedError(error, url) {
	    _classCallCheck(this, DisconnectedError);

	    var _this = _possibleConstructorReturn(this, Object.getPrototypeOf(DisconnectedError).call(this, error));

	    Object.assign(_this, error);
	    _this.message = 'URL ' + url + ' not reachable. You are probably disconnected from the internet.';
	    return _this;
	  }

	  return DisconnectedError;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__error__["a"]);
	/* harmony export */ Object.defineProperty(exports, "b", {configurable: false, enumerable: true, get: function() { return DisconnectedError; }});

	var codeMap = {
	  ECONNREFUSED: DisconnectedError,
	  ENOTFOUND: DisconnectedError
	};

	var ResponseError = function (_FakeError2) {
	  _inherits(ResponseError, _FakeError2);

	  function ResponseError(error, url) {
	    _classCallCheck(this, ResponseError);

	    // Make sure an error and url were actually passed in
	    if (!error) {
	      throw new Error('No error passed to ResponseError');
	    }
	    if (!url) {
	      throw new Error('No url passed to ResponseError');
	    }

	    // Check if it's a disconnection error or something else weird
	    if (error.code && error.syscall) {
	      var _ret;

	      return _ret = ResponseError.getSystemLevelError(error, url), _possibleConstructorReturn(_this2, _ret);
	    }

	    var _this2 = _possibleConstructorReturn(this, Object.getPrototypeOf(ResponseError).call(this, error));

	    Object.assign(_this2, error);

	    _this2.name = 'ResponseError';
	    _this2.message = 'Status ' + error.status + ' returned from API request to ' + url;
	    return _this2;
	  }

	  _createClass(ResponseError, null, [{
	    key: 'getSystemLevelError',
	    value: function getSystemLevelError(error, url) {
	      var E = codeMap[error.code] || Error;
	      return new E(error, url);
	    }
	  }]);

	  return ResponseError;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__error__["a"]);

	/* harmony default export */ exports["a"] = ResponseError;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

	var ErrorClass = function ErrorClass(message) {
	  _classCallCheck(this, ErrorClass);

	  if (Error.hasOwnProperty('captureStackTrace')) {
	    Error.captureStackTrace(this, this.constructor);
	  } else {
	    Object.defineProperty(this, 'stack', {
	      value: new Error().stack
	    });

	    Object.defineProperty(this, 'message', {
	      value: message
	    });
	  }
	};

	/* harmony default export */ exports["a"] = ErrorClass;

/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony export */ exports["a"] = process;function process(text) {
	  if (!text) return text;

	  text = text.replace(/<a/g, '<a target="_blank"');

	  return text;
	}

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__base__ = __webpack_require__(1);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__models_multi__ = __webpack_require__(26);
	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"); } }

	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 ID_REGEX = /^user\/[^\/]+\/m\/[^\/]+$/;

	var Multis = function (_BaseAPI) {
	  _inherits(Multis, _BaseAPI);

	  function Multis() {
	    var _Object$getPrototypeO;

	    var _temp, _this, _ret;

	    _classCallCheck(this, Multis);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(Multis)).call.apply(_Object$getPrototypeO, [this].concat(args))), _this), _this.model = /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models_multi__["a"], _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(Multis, [{
	    key: 'path',
	    value: function path(method) {
	      var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      var id = Multis.buildId(query);

	      switch (method) {
	        case 'get':
	          if (query.username) {
	            if (query.username === 'me') {
	              return 'api/multi/mine';
	            } else if (id) {
	              return 'api/multi/' + id;
	            }

	            return 'api/multi/user/' + query.username;
	          }

	          return 'api/multi';
	        case 'put':
	        case 'patch':
	        case 'post':
	        case 'del':
	          return 'api/multi/' + id;
	        case 'copy':
	          return 'api/multi/copy';
	        case 'move':
	          return 'api/multi/rename';
	      }
	    }
	  }, {
	    key: 'formatQuery',
	    value: function formatQuery(query, method) {
	      if (method === 'get') {
	        if (query.user) {
	          query.username = query.user;
	          delete query.user;
	        }
	      }

	      return query;
	    }
	  }, {
	    key: 'formatBody',
	    value: function formatBody(res) {
	      var body = res.body;


	      if (body && Array.isArray(body)) {
	        return body.map(function (m) {
	          var multi = m.data;

	          multi.subreddits = Multis.mapSubreddits(multi.subreddits);
	          return new /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models_multi__["a"](multi).toJSON();
	        });
	      } else if (body) {
	        var multi = body.data;
	        multi.subreddits = Multis.mapSubreddits(multi.subreddits);
	        return new /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models_multi__["a"](multi);
	      }
	    }
	  }, {
	    key: 'formatData',
	    value: function formatData(data) {
	      return Multis.formatData(data);
	    }
	  }, {
	    key: 'copy',
	    value: function copy(fromId, data) {
	      if (!ID_REGEX.exec(fromId)) {
	        throw new Error('ID did not match `user/{username}/m/{multiname}` format.');
	      }

	      data = {
	        from: fromId,
	        to: data.id,
	        _method: 'post'
	      };

	      if (data && data.displayName) {
	        data.display_name = data.displayName;
	      }

	      return this.save('copy', data);
	    }
	  }, {
	    key: 'move',
	    value: function move(fromId, toId, data) {
	      if (!ID_REGEX.exec(fromId) || !ID_REGEX.exec(toId)) {
	        throw new Error('ID did not match `user/{username}/m/{multiname}` format.');
	      }

	      var moveData = {
	        _method: 'post',
	        from: fromId,
	        to: toId
	      };

	      if (data && data.displayName) {
	        moveData.display_name = data.displayName;
	      }

	      return this.save('move', moveData);
	    }
	  }, {
	    key: 'formatBody',
	    value: function formatBody(res) {
	      var body = res.body;

	      if (body) {
	        return new /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models_multi__["a"](body.data || body).toJSON();
	      }
	    }
	  }, {
	    key: 'requestCacheRules',
	    get: function get() {
	      return undefined;
	    }
	  }], [{
	    key: 'mapSubreddits',
	    value: function mapSubreddits(subs) {
	      return subs.map(function (s) {
	        return s.name;
	      });
	    }
	  }, {
	    key: 'formatData',
	    value: function formatData() {
	      var data = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
	      var method = arguments[1];

	      if (method === 'post' || method === 'put') {
	        return {
	          model: JSON.stringify({
	            description_md: data.description,
	            display_name: data.displayName,
	            icon_name: data.iconName,
	            key_color: data.keyColor,
	            visibility: data.visibility,
	            weighting_scheme: data.weightingScheme,
	            subreddits: data.subreddits ? data.subreddits.map(function (s) {
	              return { name: s };
	            }) : undefined
	          }),
	          name: data.name
	        };
	      }
	      return data;
	    }
	  }, {
	    key: 'buildId',
	    value: function buildId(_ref) {
	      var username = _ref.username;
	      var name = _ref.name;
	      var id = _ref.id;

	      if (username && name) {
	        return 'user/' + username + '/m/' + name;
	      }

	      if (id) {
	        return id;
	      }
	    }
	  }]);

	  return Multis;
	}(/* harmony import */__WEBPACK_IMPORTED_MODULE_0__base__["a"]);

	Multis.dataCacheConfig = undefined;


	/* harmony default export */ exports["a"] = Multis;

/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__base__ = __webpack_require__(1);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__models_save__ = __webpack_require__(27);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_object__ = __webpack_require__(3);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_lodash_object___default = __WEBPACK_IMPORTED_MODULE_2_lodash_object__ && __WEBPACK_IMPORTED_MODULE_2_lodash_object__.__esModule ? function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_object__['default'] } : function() { return __WEBPACK_IMPORTED_MODULE_2_lodash_object__; }
	/* harmony import */ Object.defineProperty(__WEBPACK_IMPORTED_MODULE_2_lodash_object___default, 'a', { get: __WEBPACK_IMPORTED_MODULE_2_lodash_object___default });
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__models2_Comment__ = __webpack_require__(74);
	/* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__models2_Link__ = __webpack_require__(61);
	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 _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

	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 CONSTRUCTORS = {
	  t1: /* harmony import */__WEBPACK_IMPORTED_MODULE_3__models2_Comment__["a"],
	  t3: /* harmony import */__WEBPACK_IMPORTED_MODULE_4__models2_Link__["a"]
	};

	var Saved = function (_BaseAPI) {
	  _inherits(Saved, _BaseAPI);

	  function Saved() {
	    var _Object$getPrototypeO;

	    var _temp, _this, _ret;

	    _classCallCheck(this, Saved);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_Object$getPrototypeO = Object.getPrototypeOf(Saved)).call.apply(_Object$getPrototypeO, [this].concat(args))), _this), _this.model = /* harmony import */__WEBPACK_IMPORTED_MODULE_1__models_save__["a"], _this.move = _this.notImplemented('move'), _this.copy = _this.notImplemented('copy'), _this.put = _this.notImplemented('put'), _this.patch = _this.notImplemented('patch'), _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(Saved, [{
	    key: 'path',
	    value: function path(method) {
	      var query = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	      switch (method) {
	        case 'get':
	          return 'user/' + query.user + '/saved.json';
	        case 'post':
	          return 'api/save';
	        case 'del':
	          return 'api/unsave';
	      }
	    }
	  }, {
	    key: 'formatQuery',
	    value: function formatQuery(query) {
	      delete query.user;
	      return query;
	    }
	  }, {
	    key: 'post',
	    value: function post(data) {
	      var postData = {
	        id: data.id,
	        category: data.category
	      };

	      return _get(Object.getPrototypeOf(Saved.prototype), 'post', this).call(this, postData);
	    }
	  }, {
	    key: 'del',
	    value: function del(data) {
	      var postData = {
	        id: data.id,
	        category: data.category,
	        _method: 'post'
	      };

	      return _get(Object.getPrototypeOf(Saved.prototype), 'del', this).call(this, postData);
	    }
	  }, {
	    key: 'parseBody',
	    value: function parseBody(res, apiResponse) {
	      var body = res.body;

	      if (!/* harmony import */__WEBPACK_IMPORTED_MODULE_2_lodash_object__["has"].bind()(body, 'data.children')) {
	        return [];
	      }

	      var things = body.data.children;

	      things.forEach(function (t) {
	        var constructor = CONSTRUCTORS[t.kind];
	        try {
	          apiResponse.addResult(CONSTRUCTORS[t.kind].fromJSON(t.data));
	        } catch (e) {
	          console.log(constructor);
	          console.log(t);
	          console.trace(e);
	        }
	      });
	    }
	  }]);

	  return Saved;
	}(/* harmony import */__WEBPAC