		@@ -1,1498 +0,8 @@
		import flatMap from 'lodash.flatmap';
		import flatmap from 'lodash.flatmap';
		import omit from 'lodash.omit';

		var commonjsGlobal = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

		/**
		* 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 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,
		MAX_SAFE_INTEGER = 9007199254740991;

		/** `Object#toString` result references. */
		var argsTag = '[object Arguments]',
		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 detect host constructors (Safari). */
		var reIsHostCtor = /^\[object .+?Constructor\]$/;

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

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

		/** 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 faster alternative to `Function#apply`, this function invokes `func`
		* with the `this` binding of `thisArg` and the arguments of `args`.
		*
		* @private
		* @param {Function} func The function to invoke.
		* @param {*} thisArg The `this` binding of `func`.
		* @param {Array} args The arguments to invoke `func` with.
		* @returns {*} Returns the result of `func`.
		*/
		function apply(func, thisArg, args) {
		switch (args.length) {
		case 0: return func.call(thisArg);
		case 1: return func.call(thisArg, args[0]);
		case 2: return func.call(thisArg, args[0], args[1]);
		case 3: return func.call(thisArg, args[0], args[1], args[2]);
		}
		return func.apply(thisArg, args);
		}

		/**
		* 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;
		}

		/**
		* A specialized version of `_.map` for arrays without support for iteratee
		* shorthands.
		*
		* @private
		* @param {Array} [array] The array to iterate over.
		* @param {Function} iteratee The function invoked per iteration.
		* @returns {Array} Returns the new mapped array.
		*/
		function arrayMap(array, iteratee) {
		var index = -1,
		length = array ? array.length : 0,
		result = Array(length);

		while (++index < length) {
		result[index] = iteratee(array[index], index, array);
		}
		return result;
		}

		/**
		* 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;
		}

		/**
		* 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;
		}

		/**
		* The base implementation of `_.times` without support for iteratee shorthands
		* or max array length checks.
		*
		* @private
		* @param {number} n The number of times to invoke `iteratee`.
		* @param {Function} iteratee The function invoked per iteration.
		* @returns {Array} Returns the array of results.
		*/
		function baseTimes(n, iteratee) {
		var index = -1,
		result = Array(n);

		while (++index < n) {
		result[index] = iteratee(index);
		}
		return result;
		}

		/**
		* The base implementation of `_.unary` without support for storing metadata.
		*
		* @private
		* @param {Function} func The function to cap arguments for.
		* @returns {Function} Returns the new capped function.
		*/
		function baseUnary(func) {
		return function(value) {
		return func(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);
		}

		/**
		* 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;
		}

		/**
		* Creates a unary function that invokes `func` with its argument transformed.
		*
		* @private
		* @param {Function} func The function to wrap.
		* @param {Function} transform The argument transform.
		* @returns {Function} Returns the new function.
		*/
		function overArg(func, transform) {
		return function(arg) {
		return func(transform(arg));
		};
		}

		/** 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$1 = root.Symbol,
		getPrototype = overArg(Object.getPrototypeOf, Object),
		propertyIsEnumerable = objectProto.propertyIsEnumerable,
		splice = arrayProto.splice,
		spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : undefined;

		/* Built-in method references for those with the same name as other `lodash` methods. */
		var nativeGetSymbols = Object.getOwnPropertySymbols,
		nativeMax = Math.max;

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

		/**
		* 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;

		/**
		*
		* 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;

		/**
		* Creates an array of the enumerable property names of the array-like `value`.
		*
		* @private
		* @param {*} value The value to query.
		* @param {boolean} inherited Specify returning inherited property names.
		* @returns {Array} Returns the array of property names.
		*/
		function arrayLikeKeys(value, inherited) {
		// Safari 8.1 makes `arguments.callee` enumerable in strict mode.
		// Safari 9 makes `arguments.length` enumerable in strict mode.
		var result = (isArray(value) \|\| isArguments(value))
		? baseTimes(value.length, String)
		: [];

		var length = result.length,
		skipIndexes = !!length;

		for (var key in value) {
		if ((inherited \|\| hasOwnProperty.call(value, key)) &&
		!(skipIndexes && (key == 'length' \|\| isIndex(key, length)))) {
		result.push(key);
		}
		}
		return result;
		}

		/**
		* 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 methods like `_.difference` without support
		* for excluding multiple arrays or iteratee shorthands.
		*
		* @private
		* @param {Array} array The array to inspect.
		* @param {Array} values The values to exclude.
		* @param {Function} [iteratee] The iteratee invoked per element.
		* @param {Function} [comparator] The comparator invoked per element.
		* @returns {Array} Returns the new array of filtered values.
		*/
		function baseDifference(array, values, iteratee, comparator) {
		var index = -1,
		includes = arrayIncludes,
		isCommon = true,
		length = array.length,
		result = [],
		valuesLength = values.length;

		if (!length) {
		return result;
		}
		if (iteratee) {
		values = arrayMap(values, baseUnary(iteratee));
		}
		if (comparator) {
		includes = arrayIncludesWith;
		isCommon = false;
		}
		else if (values.length >= LARGE_ARRAY_SIZE) {
		includes = cacheHas;
		isCommon = false;
		values = new SetCache(values);
		}
		outer:
		while (++index < length) {
		var value = array[index],
		computed = iteratee ? iteratee(value) : value;

		value = (comparator \|\| value !== 0) ? value : 0;
		if (isCommon && computed === computed) {
		var valuesIndex = valuesLength;
		while (valuesIndex--) {
		if (values[valuesIndex] === computed) {
		continue outer;
		}
		}
		result.push(value);
		}
		else if (!includes(values, computed, comparator)) {
		result.push(value);
		}
		}
		return result;
		}

		/**
		* 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;
		}

		/**
		* The base implementation of `getAllKeys` and `getAllKeysIn` which uses
		* `keysFunc` and `symbolsFunc` to get the enumerable property names and
		* symbols of `object`.
		*
		* @private
		* @param {Object} object The object to query.
		* @param {Function} keysFunc The function to get the keys of `object`.
		* @param {Function} symbolsFunc The function to get the symbols of `object`.
		* @returns {Array} Returns the array of property names and symbols.
		*/
		function baseGetAllKeys(object, keysFunc, symbolsFunc) {
		var result = keysFunc(object);
		return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
		}

		/**
		* 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 `_.keysIn` which doesn't treat sparse arrays as dense.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of property names.
		*/
		function baseKeysIn(object) {
		if (!isObject(object)) {
		return nativeKeysIn(object);
		}
		var isProto = isPrototype(object),
		result = [];

		for (var key in object) {
		if (!(key == 'constructor' && (isProto \|\| !hasOwnProperty.call(object, key)))) {
		result.push(key);
		}
		}
		return result;
		}

		/**
		* The base implementation of `_.pick` without support for individual
		* property identifiers.
		*
		* @private
		* @param {Object} object The source object.
		* @param {string[]} props The property identifiers to pick.
		* @returns {Object} Returns the new object.
		*/
		function basePick(object, props) {
		object = Object(object);
		return basePickBy(object, props, function(value, key) {
		return key in object;
		});
		}

		/**
		* The base implementation of `_.pickBy` without support for iteratee shorthands.
		*
		* @private
		* @param {Object} object The source object.
		* @param {string[]} props The property identifiers to pick from.
		* @param {Function} predicate The function invoked per property.
		* @returns {Object} Returns the new object.
		*/
		function basePickBy(object, props, predicate) {
		var index = -1,
		length = props.length,
		result = {};

		while (++index < length) {
		var key = props[index],
		value = object[key];

		if (predicate(value, key)) {
		result[key] = value;
		}
		}
		return result;
		}

		/**
		* The base implementation of `_.rest` which doesn't validate or coerce arguments.
		*
		* @private
		* @param {Function} func The function to apply a rest parameter to.
		* @param {number} [start=func.length-1] The start position of the rest parameter.
		* @returns {Function} Returns the new function.
		*/
		function baseRest(func, start) {
		start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
		return function() {
		var args = arguments,
		index = -1,
		length = nativeMax(args.length - start, 0),
		array = Array(length);

		while (++index < length) {
		array[index] = args[start + index];
		}
		index = -1;
		var otherArgs = Array(start + 1);
		while (++index < start) {
		otherArgs[index] = args[index];
		}
		otherArgs[start] = array;
		return apply(func, this, otherArgs);
		};
		}

		/**
		* Creates an array of own and inherited enumerable property names and
		* symbols of `object`.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of property names and symbols.
		*/
		function getAllKeysIn(object) {
		return baseGetAllKeys(object, keysIn, getSymbolsIn);
		}

		/**
		* 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;
		}

		/**
		* Creates an array of the own enumerable symbol properties of `object`.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of symbols.
		*/
		var getSymbols = nativeGetSymbols ? overArg(nativeGetSymbols, Object) : stubArray;

		/**
		* Creates an array of the own and inherited enumerable symbol properties
		* of `object`.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of symbols.
		*/
		var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
		var result = [];
		while (object) {
		arrayPush(result, getSymbols(object));
		object = getPrototype(object);
		}
		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]);
		}

		/**
		* Checks if `value` is a valid array-like index.
		*
		* @private
		* @param {*} value The value to check.
		* @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
		* @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
		*/
		function isIndex(value, length) {
		length = length == null ? MAX_SAFE_INTEGER : length;
		return !!length &&
		(typeof value == 'number' \|\| reIsUint.test(value)) &&
		(value > -1 && value % 1 == 0 && value < length);
		}

		/**
		* 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);
		}

		/**
		* Checks if `value` is likely a prototype object.
		*
		* @private
		* @param {*} value The value to check.
		* @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
		*/
		function isPrototype(value) {
		var Ctor = value && value.constructor,
		proto = (typeof Ctor == 'function' && Ctor.prototype) \|\| objectProto;

		return value === proto;
		}

		/**
		* This function is like
		* [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
		* except that it includes inherited enumerable properties.
		*
		* @private
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of property names.
		*/
		function nativeKeysIn(object) {
		var result = [];
		if (object != null) {
		for (var key in Object(object)) {
		result.push(key);
		}
		}
		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 '';
		}

		/**
		* 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 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 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 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 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 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;
		}

		/**
		* 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);
		}

		/**
		* Creates an array of the own and inherited enumerable property names of `object`.
		*
		* Note: Non-object values are coerced to objects.
		*
		* @static
		* @memberOf _
		* @since 3.0.0
		* @category Object
		* @param {Object} object The object to query.
		* @returns {Array} Returns the array of property names.
		* @example
		*
		* function Foo() {
		* this.a = 1;
		* this.b = 2;
		* }
		*
		* Foo.prototype.c = 3;
		*
		* _.keysIn(new Foo);
		* // => ['a', 'b', 'c'] (iteration order is not guaranteed)
		*/
		function keysIn(object) {
		return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
		}

		/**
		* The opposite of `_.pick`; this method creates an object composed of the
		* own and inherited enumerable string keyed properties of `object` that are
		* not omitted.
		*
		* @static
		* @since 0.1.0
		* @memberOf _
		* @category Object
		* @param {Object} object The source object.
		* @param {...(string\|string[])} [props] The property identifiers to omit.
		* @returns {Object} Returns the new object.
		* @example
		*
		* var object = { 'a': 1, 'b': '2', 'c': 3 };
		*
		* _.omit(object, ['a', 'c']);
		* // => { 'b': '2' }
		*/
		var omit = baseRest(function(object, props) {
		if (object == null) {
		return {};
		}
		props = arrayMap(baseFlatten(props, 1), toKey);
		return basePick(object, baseDifference(getAllKeysIn(object), props));
		});

		/**
		* This method returns a new empty array.
		*
		* @static
		* @memberOf _
		* @since 4.13.0
		* @category Util
		* @returns {Array} Returns the new empty array.
		* @example
		*
		* var arrays = _.times(2, _.stubArray);
		*
		* console.log(arrays);
		* // => [[], []]
		*
		* console.log(arrays[0] === arrays[1]);
		* // => false
		*/
		function stubArray() {
		return [];
		}

		var lodash_omit = omit;

		function toSlatejsDocument(ctfDocument) {
		return {
		object: 'document',
		nodes: flatMap(ctfDocument.content, function (node) { return convertNode(node); }),
		nodes: flatmap(ctfDocument.content, function (node) { return convertNode(node); }),
		};
		@@ -1506,4 +16,4 @@ }
		var contentfulBlock = node;
		var childNodes = flatMap(contentfulBlock.content, convertNode);
		var data = lodash_omit(contentfulBlock, ['category', 'type', 'content']);
		var childNodes = flatmap(contentfulBlock.content, convertNode);
		var data = omit(contentfulBlock, ['category', 'type', 'content']);
		var slateBlock = {
		@@ -1521,3 +31,3 @@ object: contentfulBlock.category,
		var _a = node, marks = _a.marks, value = _a.value;
		var textData = lodash_omit(node, ['category', 'type', 'value', 'marks']);
		var textData = omit(node, ['category', 'type', 'value', 'marks']);
		var slateText = {
		@@ -1577,3 +87,3 @@ object: 'text',
		category: 'document',
		content: flatMap(slateDocument.nodes, convertNode$1),
		content: flatmap(slateDocument.nodes, convertNode$1),
		};
		@@ -1587,3 +97,3 @@ }
		var slateBlock = node;
		var content = flatMap(slateBlock.nodes, convertNode$1);
		var content = flatmap(slateBlock.nodes, convertNode$1);
		var contentfulBlock = __assign({ category: slateBlock.object, type: slateBlock.type, content: content }, slateBlock.data);
		@@ -1590,0 +100,0 @@ nodes.push(contentfulBlock);

+1

-1

package.json

		{
		"name": "@contentful/contentful-slatejs-adapter",
		"version": "1.1.0",
		"version": "1.1.1",
		"description": "",
		@@ -5,0 +5,0 @@ "keywords": [],

dist/contentful-slatejs-adapter.es5.js.map

Sorry, the diff of this file is too big to display

@contentful/contentful-slatejs-adapter - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics