js将网页中的table转换成表格下载

(function webpackUniversalModuleDefinition(root, factory) {
   if(typeof exports === 'object' && typeof module === 'object')
       module.exports = factory();
   else if(typeof define === 'function' && define.amd)
       define([], factory);
   else if(typeof exports === 'object')
       exports["json2csv"] = factory();
   else
       root["json2csv"] = factory();
})(this, function() {
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] = {
/******/            exports: {},
/******/            id: moduleId,
/******/            loaded: false
/******/        };

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

/******/ // Flag the module as loaded
/******/ module.loaded = 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__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports, __webpack_require__) {

   /* WEBPACK VAR INJECTION */(function(process) {/**
   * Module dependencies.
   */
   var os = __webpack_require__(2);
   var lodashGet = __webpack_require__(3);
   var lodashFlatten = __webpack_require__(4);
   var lodashUniq = __webpack_require__(5);
   var lodashSet = __webpack_require__(6);
   var lodashCloneDeep = __webpack_require__(7);
   var flatten = __webpack_require__(9);

   /**
   * @name Json2CsvParams
   * @typedef {Object}
   * @property {Array} data - array of JSON objects
   * @property {Array} [fields] - see documentation for details
   * @property {String[]} [fieldNames] - names for fields at the same indexes. Must be same length as fields array
   * (Optional. Maintained for backwards compatibility. Use fields config object for more features)
   * @property {String} [del=","] - delimiter of columns
   * @property {String} [defaultValue="<empty>"] - default value to use when missing data
   * @property {String} [quotes='"'] - quotes around cell values and column names
   * @property {String} [doubleQuotes='""'] - the value to replace double quotes in strings
   * @property {Boolean} [hasCSVColumnTitle=true] - determines whether or not CSV file will contain a title column
   * @property {String} [eol=''] - it gets added to each row of data
   * @property {String} [newLine] - overrides the default OS line ending (\n on Unix \r\n on Windows)
   * @property {Boolean} [flatten=false] - flattens nested JSON using flat (https://www.npmjs.com/package/flat)
   * @property {String[]} [unwindPath] - similar to MongoDB's $unwind, Deconstructs an array field from the input JSON to output a row for each element
   * @property {Boolean} [excelStrings] - converts string data into normalized Excel style data
   * @property {Boolean} [includeEmptyRows=false] - includes empty rows
   * @property {Boolean} [withBOM=false] - includes BOM character at the beginning of the csv
   */

   /**
   * Main function that converts json to csv.
   *
   * @param {Json2CsvParams} params Function parameters containing data, fields,
   * delimiter (default is ','), hasCSVColumnTitle (default is true)
   * and default value (default is '')
   * @param {Function} [callback] Callback function
   * if error, returning error in call back.
   * if csv is created successfully, returning csv output to callback.
   */
   module.exports = function (params, callback) {
   var hasCallback = typeof callback === 'function';
   var err;

   try {
   checkParams(params);
   } catch (err) {
   if (hasCallback) {
   return process.nextTick(function () {
   callback(err);
   });
   } else {
   throw err;
   }
   }

var titles = createColumnTitles(params);
var csv = createColumnContent(params, titles);

   if (hasCallback) {
   return process.nextTick(function () {
   callback(null, csv);
   });
   } else {
   return csv;
   }
   };

   /**
   * Check passing params.
   *
   * Note that this modifies params.
   *
   * @param {Json2CsvParams} params Function parameters containing data, fields,
   * delimiter, default value, mark quotes and hasCSVColumnTitle
   */
   function checkParams(params) {
   params.data = params.data || [];

   // if data is an Object, not in array [{}], then just create 1 item array.
   // So from now all data in array of object format.
   if (!Array.isArray(params.data)) {
   params.data = [params.data];
   }

   if (params.flatten) {
   params.data = params.data.map(flatten);
   }

   // Set params.fields default to first data element's keys
   if (!params.fields && (params.data.length === 0 || typeof params.data[0] !== 'object')) {
   throw new Error('params should include "fields" and/or non-empty "data" array of objects');
   }

   if (!params.fields) {
   var dataFields = params.data.map(function (item) {
   return Object.keys(item);
   });

   dataFields = lodashFlatten(dataFields);
   params.fields = lodashUniq(dataFields);
   }

   //#check fieldNames
   if (params.fieldNames && params.fieldNames.length !== params.fields.length) {
   throw new Error('fieldNames and fields should be of the same length, if fieldNames is provided.');
   }

   // Get fieldNames from fields
   params.fieldNames = params.fields.map(function (field, i) {
   if (params.fieldNames && typeof field === 'string') {
   return params.fieldNames[i];
   }
   return (typeof field === 'string') ? field : (field.label || field.value);
   });

//#check delimiter
params.del = params.del || ',';

//#check end of line character
params.eol = params.eol || '';

//#check quotation mark
params.quotes = typeof params.quotes === 'string' ? params.quotes : '"';

//#check double quotes
params.doubleQuotes = typeof params.doubleQuotes === 'string' ? params.doubleQuotes : Array(3).join(params.quotes);

//#check default value
params.defaultValue = params.defaultValue;

//#check hasCSVColumnTitle, if it is not explicitly set to false then true.
params.hasCSVColumnTitle = params.hasCSVColumnTitle !== false;

//#check include empty rows, defaults to false
params.includeEmptyRows = params.includeEmptyRows || false;

//#check with BOM, defaults to false
params.withBOM = params.withBOM || false;

//#check unwindPath, defaults to empty array
params.unwindPath = params.unwindPath || [];

   // if unwindPath is not in array [{}], then just create 1 item array.
   if (!Array.isArray(params.unwindPath)) {
   params.unwindPath = [params.unwindPath];
   }
   }

   /**
   * Create the title row with all the provided fields as column headings
   *
   * @param {Json2CsvParams} params Function parameters containing data, fields and delimiter
   * @returns {String} titles as a string
   */
   function createColumnTitles(params) {
   var str = '';

   //if CSV has column title, then create it
   if (params.hasCSVColumnTitle) {
   params.fieldNames.forEach(function (element) {
   if (str !== '') {
   str += params.del;
   }
   str += JSON.stringify(element).replace(/\"/g, params.quotes);
   });
   }

return str;
}

   /**
   * Replace the quotation marks of the field element if needed (can be a not string-like item)
   *
   * @param {string} stringifiedElement The field element after JSON.stringify()
   * @param {string} quotes The params.quotes value. At this point we know that is not equal to double (")
   */
   function replaceQuotationMarks(stringifiedElement, quotes) {
   var lastCharIndex = stringifiedElement.length - 1;

   //check if it's an string-like element
   if (stringifiedElement[0] === '"' && stringifiedElement[lastCharIndex] === '"') {
   //split the stringified field element because Strings are immutable
   var splitElement = stringifiedElement.split('');

   //replace the quotation marks
   splitElement[0] = quotes;
   splitElement[lastCharIndex] = quotes;

   //join again
   stringifiedElement = splitElement.join('');
   }

return stringifiedElement;
}

   /**
   * Create the content column by column and row by row below the title
   *
   * @param {Object} params Function parameters containing data, fields and delimiter
   * @param {String} str Title row as a string
   * @returns {String} csv string
   */
   function createColumnContent(params, str) {
   createDataRows(params.data, params.unwindPath).forEach(function (dataElement) {
   //if null do nothing, if empty object without includeEmptyRows do nothing
   if (dataElement && (Object.getOwnPropertyNames(dataElement).length > 0 || params.includeEmptyRows)) {
   var line = '';
   var eol = params.newLine || os.EOL || '\n';

   params.fields.forEach(function (fieldElement) {
   var val;
   var defaultValue = params.defaultValue;
   var stringify = true;
   if (typeof fieldElement === 'object' && 'default' in fieldElement) {
   defaultValue = fieldElement.default;
   }

   if (fieldElement && (typeof fieldElement === 'string' || typeof fieldElement.value === 'string')) {
   var path = (typeof fieldElement === 'string') ? fieldElement : fieldElement.value;
   val = lodashGet(dataElement, path, defaultValue);
   } else if (fieldElement && typeof fieldElement.value === 'function') {
   var field = {
   label: fieldElement.label,
   default: fieldElement.default
   };
   val = fieldElement.value(dataElement, field, params.data);
   if (fieldElement.stringify !== undefined) {
   stringify = fieldElement.stringify;
   }
   }

   if (val === null || val === undefined){
   val = defaultValue;
   }

   if (val !== undefined) {
   if (params.preserveNewLinesInValues && typeof val === 'string') {
   val = val
   .replace(/\n/g, '\u2028')
   .replace(/\r/g, '\u2029');
   }

   var stringifiedElement = val;
   if (stringify) {
   stringifiedElement = JSON.stringify(val);
   }

   if (params.preserveNewLinesInValues && typeof val === 'string') {
   stringifiedElement = stringifiedElement
   .replace(/\u2028/g, '\n')
   .replace(/\u2029/g, '\r');
   }

   if (typeof val === 'object') {
   // In some cases (e.g. val is a Date), stringifiedElement is already a quoted string.
   // Strip the leading and trailing quotes if so, so we don't end up double-quoting it
   stringifiedElement = replaceQuotationMarks(stringifiedElement, '');

   // If val is a normal object, we want to escape its JSON so any commas etc
   // don't get interpreted as field separators
   stringifiedElement = JSON.stringify(stringifiedElement);
   }

   if (params.quotes !== '"') {
   stringifiedElement = replaceQuotationMarks(stringifiedElement, params.quotes);
   }

   //JSON.stringify('\\') results in a string with two backslash
   //characters in it. I.e. '\\\\'.
   stringifiedElement = stringifiedElement.replace(/\\\\/g, '\\');

   if (params.excelStrings && typeof val === 'string') {
   stringifiedElement = '"="' + stringifiedElement + '""';
   }

   //Replace single quotes with double quotes. Single quotes are preceeded by
   //a backslash, and it's not at the end of the stringifiedElement.
   stringifiedElement = stringifiedElement.replace(/(\\")(?=.)/g, params.doubleQuotes);

line += stringifiedElement;
}

line += params.del;
});

//remove last delimeter by its length
line = line.substring(0, line.length - params.del.length);

//Remove the final excess backslashes from the stringified value.
line = line.replace(/\\\\/g,'\\');

   //If header exists, add it, otherwise, print only content
   if (str !== '') {
   str += eol + line + params.eol;
   } else {
   str = line + params.eol;
   }
   }
   });
   // Add BOM character if required
   if (params.withBOM) {
   str = '\ufeff' + str;
   }

return str;
}

   /**
   * Performs the unwind recursively in specified sequence
   *
   * @param {Array} originalData The params.data value. Original array of JSON objects
   * @param {String[]} unwindPaths The params.unwindPath value. Unwind strings to be used to deconstruct array
   * @returns {Array} Array of objects containing all rows after unwind of chosen paths
   */
   function createDataRows(originalData, unwindPaths) {
   var dataRows = [];
   if (unwindPaths.length) {
   originalData.forEach(function(dataElement) {
   var dataRow = [dataElement];

   unwindPaths.forEach(function(unwindPath) {
   dataRow = unwindRows(dataRow, unwindPath);
   });

   Array.prototype.push.apply(dataRows, dataRow);
   });
   } else {
   dataRows = originalData;
   }

return dataRows;
}

   /**
   * Performs the unwind logic if necessary to convert single JSON document into multiple rows
   *
   * @param {Array} inputRows Array contaning single or multiple rows to unwind
   * @param {String} unwindPath Single path to do unwind
   * @returns {Array} Array of rows processed
   */
   function unwindRows(inputRows, unwindPath) {
   var outputRows = [];
   inputRows.forEach(function(dataEl) {
   var unwindArray = lodashGet(dataEl, unwindPath);
   var isArr = Array.isArray(unwindArray);

   if (isArr && unwindArray.length) {
   unwindArray.forEach(function(unwindEl) {
   var dataCopy = lodashCloneDeep(dataEl);
   lodashSet(dataCopy, unwindPath, unwindEl);
   outputRows.push(dataCopy);
   });
   } else if (isArr && !unwindArray.length) {
   var dataCopy = lodashCloneDeep(dataEl);
   lodashSet(dataCopy, unwindPath, undefined);
   outputRows.push(dataCopy);
   } else {
   outputRows.push(dataEl);
   }
   });
   return outputRows;
   }

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))

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

// shim for using process in browser
var process = module.exports = {};

   // cached from whatever global is present so that test runners that stub it
   // don't break things. But we need to wrap it in a try catch in case it is
   // wrapped in strict mode code which doesn't define any globals. It's inside a
   // function because try/catches deoptimize in certain engines.

var cachedSetTimeout;
var cachedClearTimeout;

   }
   function runClearTimeout(marker) {
   if (cachedClearTimeout === clearTimeout) {
   //normal enviroments in sane situations
   return clearTimeout(marker);
   }
   // if clearTimeout wasn't available but was latter defined
   if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
   cachedClearTimeout = clearTimeout;
   return clearTimeout(marker);
   }
   try {
   // when when somebody has screwed with setTimeout but no I.E. maddness
   return cachedClearTimeout(marker);
   } catch (e){
   try {
   // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
   return cachedClearTimeout.call(null, marker);
   } catch (e){
   // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
   // Some versions of I.E. have different rules for clearTimeout vs setTimeout
   return cachedClearTimeout.call(this, marker);
   }
   }

   }
   var queue = [];
   var draining = false;
   var currentQueue;
   var queueIndex = -1;

   function drainQueue() {
   if (draining) {
   return;
   }
   var timeout = runTimeout(cleanUpNextTick);
   draining = true;

   process.nextTick = function (fun) {
   var args = new Array(arguments.length - 1);
   if (arguments.length > 1) {
   for (var i = 1; i < arguments.length; i++) {
   args[i - 1] = arguments[i];
   }
   }
   queue.push(new Item(fun, args));
   if (queue.length === 1 && !draining) {
   runTimeout(drainQueue);
   }
   };

   // v8 likes predictible objects
   function Item(fun, array) {
   this.fun = fun;
   this.array = array;
   }
   Item.prototype.run = function () {
   this.fun.apply(null, this.array);
   };
   process.title = 'browser';
   process.browser = true;
   process.env = {};
   process.argv = [];
   process.version = ''; // empty string to avoid regexp issues
   process.versions = {};

function noop() {}

   process.on = noop;
   process.addListener = noop;
   process.once = noop;
   process.off = noop;
   process.removeListener = noop;
   process.removeAllListeners = noop;
   process.emit = noop;
   process.prependListener = noop;
   process.prependOnceListener = noop;

process.listeners = function (name) { return [] }

   process.binding = function (name) {
   throw new Error('process.binding is not supported');
   };

   process.cwd = function () { return '/' };
   process.chdir = function (dir) {
   throw new Error('process.chdir is not supported');
   };
   process.umask = function() { return 0; };

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

exports.endianness = function () { return 'LE' };

   exports.hostname = function () {
   if (typeof location !== 'undefined') {
   return location.hostname
   }
   else return '';
   };

exports.loadavg = function () { return [] };

exports.uptime = function () { return 0 };

   exports.freemem = function () {
   return Number.MAX_VALUE;
   };

   exports.totalmem = function () {
   return Number.MAX_VALUE;
   };

exports.cpus = function () { return [] };

exports.type = function () { return 'Browser' };

   exports.release = function () {
   if (typeof navigator !== 'undefined') {
   return navigator.appVersion;
   }
   return '';
   };

   exports.networkInterfaces
   = exports.getNetworkInterfaces
   = function () { return {} };

exports.arch = function () { return 'javascript' };

exports.platform = function () { return 'browser' };

   exports.tmpdir = exports.tmpDir = function () {
   return '/tmp';
   };

exports.EOL = '\n';

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

   /* WEBPACK VAR INJECTION */(function(global) {/**
   * lodash (Custom Build) <https://lodash.com/>
   * Build: `lodash modularize exports="npm" -o ./`
   * Copyright jQuery Foundation and other contributors <https://jquery.org/>
   * Released under MIT license <https://lodash.com/license>
   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
   */

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

   /** `Object#toString` result references. */
   var funcTag = '[object Function]',
   genTag = '[object GeneratorFunction]',
   symbolTag = '[object Symbol]';

   /** Used to match property names within property paths. */
   var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
   reIsPlainProp = /^\w*$/,
   reLeadingDot = /^\./,
   rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;

   /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\$\$?/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

   /**
   * Gets the value at `key` of `object`.
   *
   * @private
   * @param {Object} [object] The object to query.
   * @param {string} key The key of the property to get.
   * @returns {*} Returns the property value.
   */
   function getValue(object, key) {
   return object == null ? undefined : object[key];
   }

   /**
   * Checks if `value` is a host object in IE < 9.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
   */
   function isHostObject(value) {
   // Many host objects are `Object` objects that can coerce to strings
   // despite having improperly defined `toString` methods.
   var result = false;
   if (value != null && typeof value.toString != 'function') {
   try {
   result = !!(value + '');
   } catch (e) {}
   }
   return result;
   }

   /** Used for built-in method references. */
   var arrayProto = Array.prototype,
   funcProto = Function.prototype,
   objectProto = Object.prototype;

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

   /** Used to detect methods masquerading as native. */
   var maskSrcKey = (function() {
   var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
   return uid ? ('Symbol(src)_1.' + uid) : '';
   }());

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

   /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
   var objectToString = objectProto.toString;

   /** Used to detect if a method is native. */
   var reIsNative = RegExp('^' +
   funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
   .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
   );

   /** Built-in value references. */
   var Symbol = root.Symbol,
   splice = arrayProto.splice;

   /* Built-in method references that are verified to be native. */
   var Map = getNative(root, 'Map'),
   nativeCreate = getNative(Object, 'create');

   /** Used to convert symbols to primitives and strings. */
   var symbolProto = Symbol ? Symbol.prototype : undefined,
   symbolToString = symbolProto ? symbolProto.toString : undefined;

   /**
   * Creates a hash object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
   function Hash(entries) {
   var index = -1,
   length = entries ? entries.length : 0;

   this.clear();
   while (++index < length) {
   var entry = entries[index];
   this.set(entry[0], entry[1]);
   }
   }

   /**
   * Removes all key-value entries from the hash.
   *
   * @private
   * @name clear
   * @memberOf Hash
   */
   function hashClear() {
   this.__data__ = nativeCreate ? nativeCreate(null) : {};
   }

   /**
   * Removes `key` and its value from the hash.
   *
   * @private
   * @name delete
   * @memberOf Hash
   * @param {Object} hash The hash to modify.
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
   function hashDelete(key) {
   return this.has(key) && delete this.__data__[key];
   }

   /**
   * Gets the hash value for `key`.
   *
   * @private
   * @name get
   * @memberOf Hash
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
   function hashGet(key) {
   var data = this.__data__;
   if (nativeCreate) {
   var result = data[key];
   return result === HASH_UNDEFINED ? undefined : result;
   }
   return hasOwnProperty.call(data, key) ? data[key] : undefined;
   }

   /**
   * Checks if a hash value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf Hash
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
   function hashHas(key) {
   var data = this.__data__;
   return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
   }

   /**
   * Sets the hash `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf Hash
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the hash instance.
   */
   function hashSet(key, value) {
   var data = this.__data__;
   data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
   return this;
   }

   // Add methods to `Hash`.
   Hash.prototype.clear = hashClear;
   Hash.prototype['delete'] = hashDelete;
   Hash.prototype.get = hashGet;
   Hash.prototype.has = hashHas;
   Hash.prototype.set = hashSet;

   /**
   * Creates an list cache object.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
   function ListCache(entries) {
   var index = -1,
   length = entries ? entries.length : 0;

   this.clear();
   while (++index < length) {
   var entry = entries[index];
   this.set(entry[0], entry[1]);
   }
   }

   /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
   function listCacheClear() {
   this.__data__ = [];
   }

   /**
   * Removes `key` and its value from the list cache.
   *
   * @private
   * @name delete
   * @memberOf ListCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
   function listCacheDelete(key) {
   var data = this.__data__,
   index = assocIndexOf(data, key);

   if (index < 0) {
   return false;
   }
   var lastIndex = data.length - 1;
   if (index == lastIndex) {
   data.pop();
   } else {
   splice.call(data, index, 1);
   }
   return true;
   }

   /**
   * Gets the list cache value for `key`.
   *
   * @private
   * @name get
   * @memberOf ListCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
   function listCacheGet(key) {
   var data = this.__data__,
   index = assocIndexOf(data, key);

return index < 0 ? undefined : data[index][1];
}

   /**
   * Checks if a list cache value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf ListCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
   function listCacheHas(key) {
   return assocIndexOf(this.__data__, key) > -1;
   }

   /**
   * Sets the list cache `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf ListCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the list cache instance.
   */
   function listCacheSet(key, value) {
   var data = this.__data__,
   index = assocIndexOf(data, key);

   if (index < 0) {
   data.push([key, value]);
   } else {
   data[index][1] = value;
   }
   return this;
   }

   // Add methods to `ListCache`.
   ListCache.prototype.clear = listCacheClear;
   ListCache.prototype['delete'] = listCacheDelete;
   ListCache.prototype.get = listCacheGet;
   ListCache.prototype.has = listCacheHas;
   ListCache.prototype.set = listCacheSet;

   /**
   * Creates a map cache object to store key-value pairs.
   *
   * @private
   * @constructor
   * @param {Array} [entries] The key-value pairs to cache.
   */
   function MapCache(entries) {
   var index = -1,
   length = entries ? entries.length : 0;

   this.clear();
   while (++index < length) {
   var entry = entries[index];
   this.set(entry[0], entry[1]);
   }
   }

   /**
   * Removes all key-value entries from the map.
   *
   * @private
   * @name clear
   * @memberOf MapCache
   */
   function mapCacheClear() {
   this.__data__ = {
   'hash': new Hash,
   'map': new (Map || ListCache),
   'string': new Hash
   };
   }

   /**
   * Removes `key` and its value from the map.
   *
   * @private
   * @name delete
   * @memberOf MapCache
   * @param {string} key The key of the value to remove.
   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
   */
   function mapCacheDelete(key) {
   return getMapData(this, key)['delete'](key);
   }

   /**
   * Gets the map value for `key`.
   *
   * @private
   * @name get
   * @memberOf MapCache
   * @param {string} key The key of the value to get.
   * @returns {*} Returns the entry value.
   */
   function mapCacheGet(key) {
   return getMapData(this, key).get(key);
   }

   /**
   * Checks if a map value for `key` exists.
   *
   * @private
   * @name has
   * @memberOf MapCache
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
   function mapCacheHas(key) {
   return getMapData(this, key).has(key);
   }

   /**
   * Sets the map `key` to `value`.
   *
   * @private
   * @name set
   * @memberOf MapCache
   * @param {string} key The key of the value to set.
   * @param {*} value The value to set.
   * @returns {Object} Returns the map cache instance.
   */
   function mapCacheSet(key, value) {
   getMapData(this, key).set(key, value);
   return this;
   }

   // Add methods to `MapCache`.
   MapCache.prototype.clear = mapCacheClear;
   MapCache.prototype['delete'] = mapCacheDelete;
   MapCache.prototype.get = mapCacheGet;
   MapCache.prototype.has = mapCacheHas;
   MapCache.prototype.set = mapCacheSet;

   /**
   * Gets the index at which the `key` is found in `array` of key-value pairs.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} key The key to search for.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
   function assocIndexOf(array, key) {
   var length = array.length;
   while (length--) {
   if (eq(array[length][0], key)) {
   return length;
   }
   }
   return -1;
   }

   /**
   * The base implementation of `_.get` without support for default values.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @returns {*} Returns the resolved value.
   */
   function baseGet(object, path) {
   path = isKey(path, object) ? [path] : castPath(path);

var index = 0,
length = path.length;

   while (object != null && index < length) {
   object = object[toKey(path[index++])];
   }
   return (index && index == length) ? object : undefined;
   }

   /**
   * The base implementation of `_.isNative` without bad shim checks.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a native function,
   * else `false`.
   */
   function baseIsNative(value) {
   if (!isObject(value) || isMasked(value)) {
   return false;
   }
   var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
   return pattern.test(toSource(value));
   }

   /**
   * The base implementation of `_.toString` which doesn't convert nullish
   * values to empty strings.
   *
   * @private
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   */
   function baseToString(value) {
   // Exit early for strings to avoid a performance hit in some environments.
   if (typeof value == 'string') {
   return value;
   }
   if (isSymbol(value)) {
   return symbolToString ? symbolToString.call(value) : '';
   }
   var result = (value + '');
   return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
   }

   /**
   * Casts `value` to a path array if it's not one.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {Array} Returns the cast property path array.
   */
   function castPath(value) {
   return isArray(value) ? value : stringToPath(value);
   }

   /**
   * Gets the data for `map`.
   *
   * @private
   * @param {Object} map The map to query.
   * @param {string} key The reference key.
   * @returns {*} Returns the map data.
   */
   function getMapData(map, key) {
   var data = map.__data__;
   return isKeyable(key)
   ? data[typeof key == 'string' ? 'string' : 'hash']
   : data.map;
   }

   /**
   * Gets the native function at `key` of `object`.
   *
   * @private
   * @param {Object} object The object to query.
   * @param {string} key The key of the method to get.
   * @returns {*} Returns the function if it's native, else `undefined`.
   */
   function getNative(object, key) {
   var value = getValue(object, key);
   return baseIsNative(value) ? value : undefined;
   }

   /**
   * Checks if `value` is a property name and not a property path.
   *
   * @private
   * @param {*} value The value to check.
   * @param {Object} [object] The object to query keys on.
   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
   */
   function isKey(value, object) {
   if (isArray(value)) {
   return false;
   }
   var type = typeof value;
   if (type == 'number' || type == 'symbol' || type == 'boolean' ||
   value == null || isSymbol(value)) {
   return true;
   }
   return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
   (object != null && value in Object(object));
   }

   /**
   * Checks if `value` is suitable for use as unique object key.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
   */
   function isKeyable(value) {
   var type = typeof value;
   return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
   ? (value !== '__proto__')
   : (value === null);
   }

   /**
   * Checks if `func` has its source masked.
   *
   * @private
   * @param {Function} func The function to check.
   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
   */
   function isMasked(func) {
   return !!maskSrcKey && (maskSrcKey in func);
   }

   /**
   * Converts `string` to a property path array.
   *
   * @private
   * @param {string} string The string to convert.
   * @returns {Array} Returns the property path array.
   */
   var stringToPath = memoize(function(string) {
   string = toString(string);

   var result = [];
   if (reLeadingDot.test(string)) {
   result.push('');
   }
   string.replace(rePropName, function(match, number, quote, string) {
   result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));
   });
   return result;
   });

   /**
   * Converts `value` to a string key if it's not a string or symbol.
   *
   * @private
   * @param {*} value The value to inspect.
   * @returns {string|symbol} Returns the key.
   */
   function toKey(value) {
   if (typeof value == 'string' || isSymbol(value)) {
   return value;
   }
   var result = (value + '');
   return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
   }

   /**
   * Converts `func` to its source code.
   *
   * @private
   * @param {Function} func The function to process.
   * @returns {string} Returns the source code.
   */
   function toSource(func) {
   if (func != null) {
   try {
   return funcToString.call(func);
   } catch (e) {}
   try {
   return (func + '');
   } catch (e) {}
   }
   return '';
   }

   /**
   * Creates a function that memoizes the result of `func`. If `resolver` is
   * provided, it determines the cache key for storing the result based on the
   * arguments provided to the memoized function. By default, the first argument
   * provided to the memoized function is used as the map cache key. The `func`
   * is invoked with the `this` binding of the memoized function.
   *
   * **Note:** The cache is exposed as the `cache` property on the memoized
   * function. Its creation may be customized by replacing the `_.memoize.Cache`
   * constructor with one whose instances implement the
   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
   * method interface of `delete`, `get`, `has`, and `set`.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Function
   * @param {Function} func The function to have its output memoized.
   * @param {Function} [resolver] The function to resolve the cache key.
   * @returns {Function} Returns the new memoized function.
   * @example
   *
   * var object = { 'a': 1, 'b': 2 };
   * var other = { 'c': 3, 'd': 4 };
   *
   * var values = _.memoize(_.values);
   * values(object);
   * // => [1, 2]
   *
   * values(other);
   * // => [3, 4]
   *
   * object.a = 2;
   * values(object);
   * // => [1, 2]
   *
   * // Modify the result cache.
   * values.cache.set(object, ['a', 'b']);
   * values(object);
   * // => ['a', 'b']
   *
   * // Replace `_.memoize.Cache`.
   * _.memoize.Cache = WeakMap;
   */
   function memoize(func, resolver) {
   if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
   throw new TypeError(FUNC_ERROR_TEXT);
   }
   var memoized = function() {
   var args = arguments,
   key = resolver ? resolver.apply(this, args) : args[0],
   cache = memoized.cache;

   if (cache.has(key)) {
   return cache.get(key);
   }
   var result = func.apply(this, args);
   memoized.cache = cache.set(key, result);
   return result;
   };
   memoized.cache = new (memoize.Cache || MapCache);
   return memoized;
   }

// Assign cache to `_.memoize`.
memoize.Cache = MapCache;

   /**
   * Performs a
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * comparison between two values to determine if they are equivalent.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to compare.
   * @param {*} other The other value to compare.
   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
   * @example
   *
   * var object = { 'a': 1 };
   * var other = { 'a': 1 };
   *
   * _.eq(object, object);
   * // => true
   *
   * _.eq(object, other);
   * // => false
   *
   * _.eq('a', 'a');
   * // => true
   *
   * _.eq('a', Object('a'));
   * // => false
   *
   * _.eq(NaN, NaN);
   * // => true
   */
   function eq(value, other) {
   return value === other || (value !== value && other !== other);
   }

   /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
   var isArray = Array.isArray;

   /**
   * Checks if `value` is classified as a `Function` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
   * @example
   *
   * _.isFunction(_);
   * // => true
   *
   * _.isFunction(/abc/);
   * // => false
   */
   function isFunction(value) {
   // The use of `Object#toString` avoids issues with the `typeof` operator
   // in Safari 8-9 which returns 'object' for typed array and other constructors.
   var tag = isObject(value) ? objectToString.call(value) : '';
   return tag == funcTag || tag == genTag;
   }

   /**
   * Checks if `value` is the
   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
   * @example
   *
   * _.isObject({});
   * // => true
   *
   * _.isObject([1, 2, 3]);
   * // => true
   *
   * _.isObject(_.noop);
   * // => true
   *
   * _.isObject(null);
   * // => false
   */
   function isObject(value) {
   var type = typeof value;
   return !!value && (type == 'object' || type == 'function');
   }

   /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
   function isObjectLike(value) {
   return !!value && typeof value == 'object';
   }

   /**
   * Checks if `value` is classified as a `Symbol` primitive or object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
   * @example
   *
   * _.isSymbol(Symbol.iterator);
   * // => true
   *
   * _.isSymbol('abc');
   * // => false
   */
   function isSymbol(value) {
   return typeof value == 'symbol' ||
   (isObjectLike(value) && objectToString.call(value) == symbolTag);
   }

   /**
   * Converts `value` to a string. An empty string is returned for `null`
   * and `undefined` values. The sign of `-0` is preserved.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to process.
   * @returns {string} Returns the string.
   * @example
   *
   * _.toString(null);
   * // => ''
   *
   * _.toString(-0);
   * // => '-0'
   *
   * _.toString([1, 2, 3]);
   * // => '1,2,3'
   */
   function toString(value) {
   return value == null ? '' : baseToString(value);
   }

   /**
   * Gets the value at `path` of `object`. If the resolved value is
   * `undefined`, the `defaultValue` is returned in its place.
   *
   * @static
   * @memberOf _
   * @since 3.7.0
   * @category Object
   * @param {Object} object The object to query.
   * @param {Array|string} path The path of the property to get.
   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
   * @returns {*} Returns the resolved value.
   * @example
   *
   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
   *
   * _.get(object, 'a[0].b.c');
   * // => 3
   *
   * _.get(object, ['a', '0', 'b', 'c']);
   * // => 3
   *
   * _.get(object, 'a.b.c', 'default');
   * // => 'default'
   */
   function get(object, path, defaultValue) {
   var result = object == null ? undefined : baseGet(object, path);
   return result === undefined ? defaultValue : result;
   }

module.exports = get;

/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

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

/** Used as references for various `Number` constants. */
var MAX_SAFE_INTEGER = 9007199254740991;

   /** `Object#toString` result references. */
   var argsTag = '[object Arguments]',
   funcTag = '[object Function]',
   genTag = '[object GeneratorFunction]';

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

   /**
   * Appends the elements of `values` to `array`.
   *
   * @private
   * @param {Array} array The array to modify.
   * @param {Array} values The values to append.
   * @returns {Array} Returns `array`.
   */
   function arrayPush(array, values) {
   var index = -1,
   length = values.length,
   offset = array.length;

   while (++index < length) {
   array[offset + index] = values[index];
   }
   return array;
   }

/** Used for built-in method references. */
var objectProto = Object.prototype;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

   /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
   var objectToString = objectProto.toString;

   /** Built-in value references. */
   var Symbol = root.Symbol,
   propertyIsEnumerable = objectProto.propertyIsEnumerable,
   spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;

   /**
   * The base implementation of `_.flatten` with support for restricting flattening.
   *
   * @private
   * @param {Array} array The array to flatten.
   * @param {number} depth The maximum recursion depth.
   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
   * @param {Array} [result=[]] The initial result value.
   * @returns {Array} Returns the new flattened array.
   */
   function baseFlatten(array, depth, predicate, isStrict, result) {
   var index = -1,
   length = array.length;

predicate || (predicate = isFlattenable);
result || (result = []);

   while (++index < length) {
   var value = array[index];
   if (depth > 0 && predicate(value)) {
   if (depth > 1) {
   // Recursively flatten arrays (susceptible to call stack limits).
   baseFlatten(value, depth - 1, predicate, isStrict, result);
   } else {
   arrayPush(result, value);
   }
   } else if (!isStrict) {
   result[result.length] = value;
   }
   }
   return result;
   }

   /**
   * Checks if `value` is a flattenable `arguments` object or array.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
   */
   function isFlattenable(value) {
   return isArray(value) || isArguments(value) ||
   !!(spreadableSymbol && value && value[spreadableSymbol]);
   }

   /**
   * Flattens `array` a single level deep.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to flatten.
   * @returns {Array} Returns the new flattened array.
   * @example
   *
   * _.flatten([1, [2, [3, [4]], 5]]);
   * // => [1, 2, [3, [4]], 5]
   */
   function flatten(array) {
   var length = array ? array.length : 0;
   return length ? baseFlatten(array, 1) : [];
   }

   /**
   * Checks if `value` is likely an `arguments` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
   * else `false`.
   * @example
   *
   * _.isArguments(function() { return arguments; }());
   * // => true
   *
   * _.isArguments([1, 2, 3]);
   * // => false
   */
   function isArguments(value) {
   // Safari 8.1 makes `arguments.callee` enumerable in strict mode.
   return isArrayLikeObject(value) && hasOwnProperty.call(value, 'callee') &&
   (!propertyIsEnumerable.call(value, 'callee') || objectToString.call(value) == argsTag);
   }

   /**
   * Checks if `value` is array-like. A value is considered array-like if it's
   * not a function and has a `value.length` that's an integer greater than or
   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
   * @example
   *
   * _.isArrayLike([1, 2, 3]);
   * // => true
   *
   * _.isArrayLike(document.body.children);
   * // => true
   *
   * _.isArrayLike('abc');
   * // => true
   *
   * _.isArrayLike(_.noop);
   * // => false
   */
   function isArrayLike(value) {
   return value != null && isLength(value.length) && !isFunction(value);
   }

   /**
   * This method is like `_.isArrayLike` except that it also checks if `value`
   * is an object.
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array-like object,
   * else `false`.
   * @example
   *
   * _.isArrayLikeObject([1, 2, 3]);
   * // => true
   *
   * _.isArrayLikeObject(document.body.children);
   * // => true
   *
   * _.isArrayLikeObject('abc');
   * // => false
   *
   * _.isArrayLikeObject(_.noop);
   * // => false
   */
   function isArrayLikeObject(value) {
   return isObjectLike(value) && isArrayLike(value);
   }

   /**
   * Checks if `value` is a valid array-like length.
   *
   * **Note:** This method is loosely based on
   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
   * @example
   *
   * _.isLength(3);
   * // => true
   *
   * _.isLength(Number.MIN_VALUE);
   * // => false
   *
   * _.isLength(Infinity);
   * // => false
   *
   * _.isLength('3');
   * // => false
   */
   function isLength(value) {
   return typeof value == 'number' &&
   value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
   }

module.exports = flatten;

/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

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

/** Used as the size to enable large array optimizations. */
var LARGE_ARRAY_SIZE = 200;

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

/** Used as references for various `Number` constants. */
var INFINITY = 1 / 0;

   /** `Object#toString` result references. */
   var funcTag = '[object Function]',
   genTag = '[object GeneratorFunction]';

   /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Detect free variable `global` from Node.js. */
var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;

/** Detect free variable `self`. */
var freeSelf = typeof self == 'object' && self && self.Object === Object && self;

/** Used as a reference to the global object. */
var root = freeGlobal || freeSelf || Function('return this')();

   /**
   * A specialized version of `_.includes` for arrays without support for
   * specifying an index to search from.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
   function arrayIncludes(array, value) {
   var length = array ? array.length : 0;
   return !!length && baseIndexOf(array, value, 0) > -1;
   }

   /**
   * This function is like `arrayIncludes` except that it accepts a comparator.
   *
   * @private
   * @param {Array} [array] The array to inspect.
   * @param {*} target The value to search for.
   * @param {Function} comparator The comparator invoked per element.
   * @returns {boolean} Returns `true` if `target` is found, else `false`.
   */
   function arrayIncludesWith(array, value, comparator) {
   var index = -1,
   length = array ? array.length : 0;

   while (++index < length) {
   if (comparator(value, array[index])) {
   return true;
   }
   }
   return false;
   }

   /**
   * The base implementation of `_.findIndex` and `_.findLastIndex` without
   * support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} predicate The function invoked per iteration.
   * @param {number} fromIndex The index to search from.
   * @param {boolean} [fromRight] Specify iterating from right to left.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
   function baseFindIndex(array, predicate, fromIndex, fromRight) {
   var length = array.length,
   index = fromIndex + (fromRight ? 1 : -1);

   while ((fromRight ? index-- : ++index < length)) {
   if (predicate(array[index], index, array)) {
   return index;
   }
   }
   return -1;
   }

   /**
   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {*} value The value to search for.
   * @param {number} fromIndex The index to search from.
   * @returns {number} Returns the index of the matched value, else `-1`.
   */
   function baseIndexOf(array, value, fromIndex) {
   if (value !== value) {
   return baseFindIndex(array, baseIsNaN, fromIndex);
   }
   var index = fromIndex - 1,
   length = array.length;

   while (++index < length) {
   if (array[index] === value) {
   return index;
   }
   }
   return -1;
   }

   /**
   * The base implementation of `_.isNaN` without support for number objects.
   *
   * @private
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
   */
   function baseIsNaN(value) {
   return value !== value;
   }

   /**
   * Checks if a cache value for `key` exists.
   *
   * @private
   * @param {Object} cache The cache to query.
   * @param {string} key The key of the entry to check.
   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
   */
   function cacheHas(cache, key) {
   return cache.has(key);
   }

   /**
   * Converts `set` to an array of its values.
   *
   * @private
   * @param {Object} set The set to convert.
   * @returns {Array} Returns the values.
   */
   function setToArray(set) {
   var index = -1,
   result = Array(set.size);

   set.forEach(function(value) {
   result[++index] = value;
   });
   return result;
   }

   /** Used for built-in method references. */
   var arrayProto = Array.prototype,
   funcProto = Function.prototype,
   objectProto = Object.prototype;

/** Used to detect overreaching core-js shims. */
var coreJsData = root['__core-js_shared__'];

/** Used to resolve the decompiled source of functions. */
var funcToString = funcProto.toString;

/** Used to check objects for own properties. */
var hasOwnProperty = objectProto.hasOwnProperty;

   /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
   var objectToString = objectProto.toString;

/** Built-in value references. */
var splice = arrayProto.splice;

   /* Built-in method references that are verified to be native. */
   var Map = getNative(root, 'Map'),
   Set = getNative(root, 'Set'),
   nativeCreate = getNative(Object, 'create');

   this.clear();
   while (++index < length) {
   var entry = entries[index];
   this.set(entry[0], entry[1]);
   }
   }

   /**
   * Removes all key-value entries from the list cache.
   *
   * @private
   * @name clear
   * @memberOf ListCache
   */
   function listCacheClear() {
   this.__data__ = [];
   }

   if (index < 0) {
   return false;
   }
   var lastIndex = data.length - 1;
   if (index == lastIndex) {
   data.pop();
   } else {
   splice.call(data, index, 1);
   }
   return true;
   }

return index < 0 ? undefined : data[index][1];
}

   if (index < 0) {
   data.push([key, value]);
   } else {
   data[index][1] = value;
   }
   return this;
   }

   this.clear();
   while (++index < length) {
   var entry = entries[index];
   this.set(entry[0], entry[1]);
   }
   }

   /**
   *
   * Creates an array cache object to store unique values.
   *
   * @private
   * @constructor
   * @param {Array} [values] The values to cache.
   */
   function SetCache(values) {
   var index = -1,
   length = values ? values.length : 0;

   this.__data__ = new MapCache;
   while (++index < length) {
   this.add(values[index]);
   }
   }

   /**
   * Adds `value` to the array cache.
   *
   * @private
   * @name add
   * @memberOf SetCache
   * @alias push
   * @param {*} value The value to cache.
   * @returns {Object} Returns the cache instance.
   */
   function setCacheAdd(value) {
   this.__data__.set(value, HASH_UNDEFINED);
   return this;
   }

   /**
   * Checks if `value` is in the array cache.
   *
   * @private
   * @name has
   * @memberOf SetCache
   * @param {*} value The value to search for.
   * @returns {number} Returns `true` if `value` is found, else `false`.
   */
   function setCacheHas(value) {
   return this.__data__.has(value);
   }

   // Add methods to `SetCache`.
   SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
   SetCache.prototype.has = setCacheHas;

   /**
   * The base implementation of `_.uniqBy` without support for iteratee shorthands.
   *
   * @private
   * @param {Array} array The array to inspect.
   * @param {Function} [iteratee] The iteratee invoked per element.
   * @param {Function} [comparator] The comparator invoked per element.
   * @returns {Array} Returns the new duplicate free array.
   */
   function baseUniq(array, iteratee, comparator) {
   var index = -1,
   includes = arrayIncludes,
   length = array.length,
   isCommon = true,
   result = [],
   seen = result;

   if (comparator) {
   isCommon = false;
   includes = arrayIncludesWith;
   }
   else if (length >= LARGE_ARRAY_SIZE) {
   var set = iteratee ? null : createSet(array);
   if (set) {
   return setToArray(set);
   }
   isCommon = false;
   includes = cacheHas;
   seen = new SetCache;
   }
   else {
   seen = iteratee ? [] : result;
   }
   outer:
   while (++index < length) {
   var value = array[index],
   computed = iteratee ? iteratee(value) : value;

   value = (comparator || value !== 0) ? value : 0;
   if (isCommon && computed === computed) {
   var seenIndex = seen.length;
   while (seenIndex--) {
   if (seen[seenIndex] === computed) {
   continue outer;
   }
   }
   if (iteratee) {
   seen.push(computed);
   }
   result.push(value);
   }
   else if (!includes(seen, computed, comparator)) {
   if (seen !== result) {
   seen.push(computed);
   }
   result.push(value);
   }
   }
   return result;
   }

   /**
   * Creates a set object of `values`.
   *
   * @private
   * @param {Array} values The values to add to the set.
   * @returns {Object} Returns the new set.
   */
   var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {
   return new Set(values);
   };

   /**
   * Creates a duplicate-free version of an array, using
   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
   * for equality comparisons, in which only the first occurrence of each
   * element is kept.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Array
   * @param {Array} array The array to inspect.
   * @returns {Array} Returns the new duplicate free array.
   * @example
   *
   * _.uniq([2, 1, 2]);
   * // => [2, 1]
   */
   function uniq(array) {
   return (array && array.length)
   ? baseUniq(array)
   : [];
   }

   /**
   * This method returns `undefined`.
   *
   * @static
   * @memberOf _
   * @since 2.3.0
   * @category Util
   * @example
   *
   * _.times(2, _.noop);
   * // => [undefined, undefined]
   */
   function noop() {
   // No operation performed.
   }

module.exports = uniq;

/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

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

/** Used as the `TypeError` message for "Functions" methods. */
var FUNC_ERROR_TEXT = 'Expected a function';

/** Used to stand-in for `undefined` hash values. */
var HASH_UNDEFINED = '__lodash_hash_undefined__';

   /** Used as references for various `Number` constants. */
   var INFINITY = 1 / 0,
   MAX_SAFE_INTEGER = 9007199254740991;

   /** `Object#toString` result references. */
   var funcTag = '[object Function]',
   genTag = '[object GeneratorFunction]',
   symbolTag = '[object Symbol]';

   /**
   * Used to match `RegExp`
   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
   */
   var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;

/** Used to match backslashes in property paths. */
var reEscapeChar = /\$\$?/g;

/** Used to detect host constructors (Safari). */
var reIsHostCtor = /^\[object .+?Constructor\]$/;

/** Used to detect unsigned integer values. */
var reIsUint = /^(?:0|[1-9]\d*)$/;