@pie-element/multiple-choice 5.11.0-print.7 → 5.11.0-ps.11

package/module/controller.js

@@ -1,4 +1,7 @@
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
 /** Used for built-in method references. */
+
 var objectProto$c = Object.prototype;
 
 /**
@@ -8,14 +11,14 @@ var objectProto$c = Object.prototype;
  * @param {*} value The value to check.
  * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
  */
-function isPrototype(value) {
+function isPrototype$2(value) {
   var Ctor = value && value.constructor,
       proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$c;
 
   return value === proto;
 }
 
-var _isPrototype = isPrototype;
+var _isPrototype = isPrototype$2;
 
 /**
  * Creates a unary function that invokes `func` with its argument transformed.
@@ -25,18 +28,24 @@ var _isPrototype = isPrototype;
  * @param {Function} transform The argument transform.
  * @returns {Function} Returns the new function.
  */
-function overArg(func, transform) {
+
+function overArg$1(func, transform) {
   return function(arg) {
     return func(transform(arg));
   };
 }
 
-var _overArg = overArg;
+var _overArg = overArg$1;
+
+var overArg = _overArg;
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
-var nativeKeys = _overArg(Object.keys, Object);
+var nativeKeys$1 = overArg(Object.keys, Object);
 
-var _nativeKeys = nativeKeys;
+var _nativeKeys = nativeKeys$1;
+
+var isPrototype$1 = _isPrototype,
+    nativeKeys = _nativeKeys;
 
 /** Used for built-in method references. */
 var objectProto$b = Object.prototype;
@@ -51,9 +60,9 @@ var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of property names.
  */
-function baseKeys(object) {
-  if (!_isPrototype(object)) {
-    return _nativeKeys(object);
+function baseKeys$2(object) {
+  if (!isPrototype$1(object)) {
+    return nativeKeys(object);
   }
   var result = [];
   for (var key in Object(object)) {
@@ -64,31 +73,32 @@ function baseKeys(object) {
   return result;
 }
 
-var _baseKeys = baseKeys;
+var _baseKeys = baseKeys$2;
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+/** Detect free variable `global` from Node.js. */
 
-function createCommonjsModule(fn, module) {
-	return module = { exports: {} }, fn(module, module.exports), module.exports;
-}
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
 
-/** Detect free variable `global` from Node.js. */
-var freeGlobal = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
 
-var _freeGlobal = freeGlobal;
+var freeGlobal = _freeGlobal;
 
 /** 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')();
+var root$8 = freeGlobal || freeSelf || Function('return this')();
+
+var _root = root$8;
 
-var _root = root;
+var root$7 = _root;
 
 /** Built-in value references. */
-var Symbol = _root.Symbol;
+var Symbol$4 = root$7.Symbol;
 
-var _Symbol = Symbol;
+var _Symbol = Symbol$4;
+
+var Symbol$3 = _Symbol;
 
 /** Used for built-in method references. */
 var objectProto$a = Object.prototype;
@@ -104,7 +114,7 @@ var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
 var nativeObjectToString$1 = objectProto$a.toString;
 
 /** Built-in value references. */
-var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;
+var symToStringTag$1 = Symbol$3 ? Symbol$3.toStringTag : undefined;
 
 /**
  * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
@@ -113,7 +123,7 @@ var symToStringTag$1 = _Symbol ? _Symbol.toStringTag : undefined;
  * @param {*} value The value to query.
  * @returns {string} Returns the raw `toStringTag`.
  */
-function getRawTag(value) {
+function getRawTag$1(value) {
   var isOwn = hasOwnProperty$8.call(value, symToStringTag$1),
       tag = value[symToStringTag$1];
 
@@ -133,9 +143,10 @@ function getRawTag(value) {
   return result;
 }
 
-var _getRawTag = getRawTag;
+var _getRawTag = getRawTag$1;
 
 /** Used for built-in method references. */
+
 var objectProto$9 = Object.prototype;
 
 /**
@@ -152,18 +163,22 @@ var nativeObjectToString = objectProto$9.toString;
  * @param {*} value The value to convert.
  * @returns {string} Returns the converted string.
  */
-function objectToString(value) {
+function objectToString$1(value) {
   return nativeObjectToString.call(value);
 }
 
-var _objectToString = objectToString;
+var _objectToString = objectToString$1;
+
+var Symbol$2 = _Symbol,
+    getRawTag = _getRawTag,
+    objectToString = _objectToString;
 
 /** `Object#toString` result references. */
 var nullTag = '[object Null]',
     undefinedTag = '[object Undefined]';
 
 /** Built-in value references. */
-var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined;
 
 /**
  * The base implementation of `getTag` without fallbacks for buggy environments.
@@ -172,16 +187,16 @@ var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
  * @param {*} value The value to query.
  * @returns {string} Returns the `toStringTag`.
  */
-function baseGetTag(value) {
+function baseGetTag$5(value) {
   if (value == null) {
     return value === undefined ? undefinedTag : nullTag;
   }
   return (symToStringTag && symToStringTag in Object(value))
-    ? _getRawTag(value)
-    : _objectToString(value);
+    ? getRawTag(value)
+    : objectToString(value);
 }
 
-var _baseGetTag = baseGetTag;
+var _baseGetTag = baseGetTag$5;
 
 /**
  * Checks if `value` is the
@@ -208,12 +223,16 @@ var _baseGetTag = baseGetTag;
  * _.isObject(null);
  * // => false
  */
-function isObject(value) {
+
+function isObject$2(value) {
   var type = typeof value;
   return value != null && (type == 'object' || type == 'function');
 }
 
-var isObject_1 = isObject;
+var isObject_1 = isObject$2;
+
+var baseGetTag$4 = _baseGetTag,
+    isObject$1 = isObject_1;
 
 /** `Object#toString` result references. */
 var asyncTag = '[object AsyncFunction]',
@@ -238,26 +257,30 @@ var asyncTag = '[object AsyncFunction]',
  * _.isFunction(/abc/);
  * // => false
  */
-function isFunction(value) {
-  if (!isObject_1(value)) {
+function isFunction$2(value) {
+  if (!isObject$1(value)) {
     return false;
   }
   // The use of `Object#toString` avoids issues with the `typeof` operator
   // in Safari 9 which returns 'object' for typed arrays and other constructors.
-  var tag = _baseGetTag(value);
+  var tag = baseGetTag$4(value);
   return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
 }
 
-var isFunction_1 = isFunction;
+var isFunction_1 = isFunction$2;
+
+var root$6 = _root;
 
 /** Used to detect overreaching core-js shims. */
-var coreJsData = _root['__core-js_shared__'];
+var coreJsData$1 = root$6['__core-js_shared__'];
 
-var _coreJsData = coreJsData;
+var _coreJsData = coreJsData$1;
+
+var coreJsData = _coreJsData;
 
 /** Used to detect methods masquerading as native. */
 var maskSrcKey = (function() {
-  var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
   return uid ? ('Symbol(src)_1.' + uid) : '';
 }());
 
@@ -268,13 +291,14 @@ var maskSrcKey = (function() {
  * @param {Function} func The function to check.
  * @returns {boolean} Returns `true` if `func` is masked, else `false`.
  */
-function isMasked(func) {
+function isMasked$1(func) {
   return !!maskSrcKey && (maskSrcKey in func);
 }
 
-var _isMasked = isMasked;
+var _isMasked = isMasked$1;
 
 /** Used for built-in method references. */
+
 var funcProto$1 = Function.prototype;
 
 /** Used to resolve the decompiled source of functions. */
@@ -287,7 +311,7 @@ var funcToString$1 = funcProto$1.toString;
  * @param {Function} func The function to convert.
  * @returns {string} Returns the source code.
  */
-function toSource(func) {
+function toSource$2(func) {
   if (func != null) {
     try {
       return funcToString$1.call(func);
@@ -299,7 +323,12 @@ function toSource(func) {
   return '';
 }
 
-var _toSource = toSource;
+var _toSource = toSource$2;
+
+var isFunction$1 = isFunction_1,
+    isMasked = _isMasked,
+    isObject = isObject_1,
+    toSource$1 = _toSource;
 
 /**
  * Used to match `RegExp`
@@ -334,15 +363,15 @@ var reIsNative = RegExp('^' +
  * @returns {boolean} Returns `true` if `value` is a native function,
  *  else `false`.
  */
-function baseIsNative(value) {
-  if (!isObject_1(value) || _isMasked(value)) {
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value)) {
     return false;
   }
-  var pattern = isFunction_1(value) ? reIsNative : reIsHostCtor;
-  return pattern.test(_toSource(value));
+  var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
 }
 
-var _baseIsNative = baseIsNative;
+var _baseIsNative = baseIsNative$1;
 
 /**
  * Gets the value at `key` of `object`.
@@ -352,11 +381,15 @@ var _baseIsNative = baseIsNative;
  * @param {string} key The key of the property to get.
  * @returns {*} Returns the property value.
  */
-function getValue(object, key) {
+
+function getValue$1(object, key) {
   return object == null ? undefined : object[key];
 }
 
-var _getValue = getValue;
+var _getValue = getValue$1;
+
+var baseIsNative = _baseIsNative,
+    getValue = _getValue;
 
 /**
  * Gets the native function at `key` of `object`.
@@ -366,37 +399,60 @@ var _getValue = getValue;
  * @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;
+function getNative$6(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
 }
 
-var _getNative = getNative;
+var _getNative = getNative$6;
+
+var getNative$5 = _getNative,
+    root$5 = _root;
 
 /* Built-in method references that are verified to be native. */
-var DataView = _getNative(_root, 'DataView');
+var DataView$1 = getNative$5(root$5, 'DataView');
+
+var _DataView = DataView$1;
 
-var _DataView = DataView;
+var getNative$4 = _getNative,
+    root$4 = _root;
 
 /* Built-in method references that are verified to be native. */
-var Map = _getNative(_root, 'Map');
+var Map$3 = getNative$4(root$4, 'Map');
 
-var _Map = Map;
+var _Map = Map$3;
+
+var getNative$3 = _getNative,
+    root$3 = _root;
 
 /* Built-in method references that are verified to be native. */
-var Promise$1 = _getNative(_root, 'Promise');
+var Promise$2 = getNative$3(root$3, 'Promise');
+
+var _Promise = Promise$2;
 
-var _Promise = Promise$1;
+var getNative$2 = _getNative,
+    root$2 = _root;
 
 /* Built-in method references that are verified to be native. */
-var Set = _getNative(_root, 'Set');
+var Set$1 = getNative$2(root$2, 'Set');
 
-var _Set = Set;
+var _Set = Set$1;
+
+var getNative$1 = _getNative,
+    root$1 = _root;
 
 /* Built-in method references that are verified to be native. */
-var WeakMap = _getNative(_root, 'WeakMap');
+var WeakMap$1 = getNative$1(root$1, 'WeakMap');
+
+var _WeakMap = WeakMap$1;
 
-var _WeakMap = WeakMap;
+var DataView = _DataView,
+    Map$2 = _Map,
+    Promise$1 = _Promise,
+    Set = _Set,
+    WeakMap = _WeakMap,
+    baseGetTag$3 = _baseGetTag,
+    toSource = _toSource;
 
 /** `Object#toString` result references. */
 var mapTag$3 = '[object Map]',
@@ -408,11 +464,11 @@ var mapTag$3 = '[object Map]',
 var dataViewTag$2 = '[object DataView]';
 
 /** Used to detect maps, sets, and weakmaps. */
-var dataViewCtorString = _toSource(_DataView),
-    mapCtorString = _toSource(_Map),
-    promiseCtorString = _toSource(_Promise),
-    setCtorString = _toSource(_Set),
-    weakMapCtorString = _toSource(_WeakMap);
+var dataViewCtorString = toSource(DataView),
+    mapCtorString = toSource(Map$2),
+    promiseCtorString = toSource(Promise$1),
+    setCtorString = toSource(Set),
+    weakMapCtorString = toSource(WeakMap);
 
 /**
  * Gets the `toStringTag` of `value`.
@@ -421,18 +477,18 @@ var dataViewCtorString = _toSource(_DataView),
  * @param {*} value The value to query.
  * @returns {string} Returns the `toStringTag`.
  */
-var getTag = _baseGetTag;
+var getTag$2 = baseGetTag$3;
 
 // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
-if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != dataViewTag$2) ||
-    (_Map && getTag(new _Map) != mapTag$3) ||
-    (_Promise && getTag(_Promise.resolve()) != promiseTag) ||
-    (_Set && getTag(new _Set) != setTag$3) ||
-    (_WeakMap && getTag(new _WeakMap) != weakMapTag$1)) {
-  getTag = function(value) {
-    var result = _baseGetTag(value),
+if ((DataView && getTag$2(new DataView(new ArrayBuffer(1))) != dataViewTag$2) ||
+    (Map$2 && getTag$2(new Map$2) != mapTag$3) ||
+    (Promise$1 && getTag$2(Promise$1.resolve()) != promiseTag) ||
+    (Set && getTag$2(new Set) != setTag$3) ||
+    (WeakMap && getTag$2(new WeakMap) != weakMapTag$1)) {
+  getTag$2 = function(value) {
+    var result = baseGetTag$3(value),
         Ctor = result == objectTag$2 ? value.constructor : undefined,
-        ctorString = Ctor ? _toSource(Ctor) : '';
+        ctorString = Ctor ? toSource(Ctor) : '';
 
     if (ctorString) {
       switch (ctorString) {
@@ -447,7 +503,7 @@ if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != dataViewTag$2) ||
   };
 }
 
-var _getTag = getTag;
+var _getTag = getTag$2;
 
 /**
  * Checks if `value` is object-like. A value is object-like if it's not `null`
@@ -473,11 +529,15 @@ var _getTag = getTag;
  * _.isObjectLike(null);
  * // => false
  */
-function isObjectLike(value) {
+
+function isObjectLike$5(value) {
   return value != null && typeof value == 'object';
 }
 
-var isObjectLike_1 = isObjectLike;
+var isObjectLike_1 = isObjectLike$5;
+
+var baseGetTag$2 = _baseGetTag,
+    isObjectLike$4 = isObjectLike_1;
 
 /** `Object#toString` result references. */
 var argsTag$2 = '[object Arguments]';
@@ -489,11 +549,14 @@ var argsTag$2 = '[object Arguments]';
  * @param {*} value The value to check.
  * @returns {boolean} Returns `true` if `value` is an `arguments` object,
  */
-function baseIsArguments(value) {
-  return isObjectLike_1(value) && _baseGetTag(value) == argsTag$2;
+function baseIsArguments$1(value) {
+  return isObjectLike$4(value) && baseGetTag$2(value) == argsTag$2;
 }
 
-var _baseIsArguments = baseIsArguments;
+var _baseIsArguments = baseIsArguments$1;
+
+var baseIsArguments = _baseIsArguments,
+    isObjectLike$3 = isObjectLike_1;
 
 /** Used for built-in method references. */
 var objectProto$7 = Object.prototype;
@@ -522,12 +585,12 @@ var propertyIsEnumerable$1 = objectProto$7.propertyIsEnumerable;
  * _.isArguments([1, 2, 3]);
  * // => false
  */
-var isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {
-  return isObjectLike_1(value) && hasOwnProperty$6.call(value, 'callee') &&
+var isArguments$2 = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+  return isObjectLike$3(value) && hasOwnProperty$6.call(value, 'callee') &&
     !propertyIsEnumerable$1.call(value, 'callee');
 };
 
-var isArguments_1 = isArguments;
+var isArguments_1 = isArguments$2;
 
 /**
  * Checks if `value` is classified as an `Array` object.
@@ -552,11 +615,13 @@ var isArguments_1 = isArguments;
  * _.isArray(_.noop);
  * // => false
  */
-var isArray = Array.isArray;
 
-var isArray_1 = isArray;
+var isArray$8 = Array.isArray;
+
+var isArray_1 = isArray$8;
 
 /** Used as references for various `Number` constants. */
+
 var MAX_SAFE_INTEGER$1 = 9007199254740991;
 
 /**
@@ -585,12 +650,15 @@ var MAX_SAFE_INTEGER$1 = 9007199254740991;
  * _.isLength('3');
  * // => false
  */
-function isLength(value) {
+function isLength$2(value) {
   return typeof value == 'number' &&
     value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1;
 }
 
-var isLength_1 = isLength;
+var isLength_1 = isLength$2;
+
+var isFunction = isFunction_1,
+    isLength$1 = isLength_1;
 
 /**
  * Checks if `value` is array-like. A value is considered array-like if it's
@@ -617,11 +685,13 @@ var isLength_1 = isLength;
  * _.isArrayLike(_.noop);
  * // => false
  */
-function isArrayLike(value) {
-  return value != null && isLength_1(value.length) && !isFunction_1(value);
+function isArrayLike$2(value) {
+  return value != null && isLength$1(value.length) && !isFunction(value);
 }
 
-var isArrayLike_1 = isArrayLike;
+var isArrayLike_1 = isArrayLike$2;
+
+var isBuffer$3 = {exports: {}};
 
 /**
  * This method returns `false`.
@@ -636,13 +706,17 @@ var isArrayLike_1 = isArrayLike;
  * _.times(2, _.stubFalse);
  * // => [false, false]
  */
+
 function stubFalse() {
   return false;
 }
 
 var stubFalse_1 = stubFalse;
 
-var isBuffer_1 = createCommonjsModule(function (module, exports) {
+(function (module, exports) {
+var root = _root,
+    stubFalse = stubFalse_1;
+
 /** Detect free variable `exports`. */
 var freeExports = exports && !exports.nodeType && exports;
 
@@ -653,7 +727,7 @@ var freeModule = freeExports && 'object' == 'object' && module && !module.nodeTy
 var moduleExports = freeModule && freeModule.exports === freeExports;
 
 /** Built-in value references. */
-var Buffer = moduleExports ? _root.Buffer : undefined;
+var Buffer = moduleExports ? root.Buffer : undefined;
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
 var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
@@ -675,10 +749,14 @@ var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
  * _.isBuffer(new Uint8Array(2));
  * // => false
  */
-var isBuffer = nativeIsBuffer || stubFalse_1;
+var isBuffer = nativeIsBuffer || stubFalse;
 
 module.exports = isBuffer;
-});
+}(isBuffer$3, isBuffer$3.exports));
+
+var baseGetTag$1 = _baseGetTag,
+    isLength = isLength_1,
+    isObjectLike$2 = isObjectLike_1;
 
 /** `Object#toString` result references. */
 var argsTag$1 = '[object Arguments]',
@@ -730,12 +808,12 @@ typedArrayTags[weakMapTag] = false;
  * @param {*} value The value to check.
  * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
  */
-function baseIsTypedArray(value) {
-  return isObjectLike_1(value) &&
-    isLength_1(value.length) && !!typedArrayTags[_baseGetTag(value)];
+function baseIsTypedArray$1(value) {
+  return isObjectLike$2(value) &&
+    isLength(value.length) && !!typedArrayTags[baseGetTag$1(value)];
 }
 
-var _baseIsTypedArray = baseIsTypedArray;
+var _baseIsTypedArray = baseIsTypedArray$1;
 
 /**
  * The base implementation of `_.unary` without support for storing metadata.
@@ -744,15 +822,20 @@ var _baseIsTypedArray = baseIsTypedArray;
  * @param {Function} func The function to cap arguments for.
  * @returns {Function} Returns the new capped function.
  */
-function baseUnary(func) {
+
+function baseUnary$1(func) {
   return function(value) {
     return func(value);
   };
 }
 
-var _baseUnary = baseUnary;
+var _baseUnary = baseUnary$1;
+
+var _nodeUtil = {exports: {}};
+
+(function (module, exports) {
+var freeGlobal = _freeGlobal;
 
-var _nodeUtil = createCommonjsModule(function (module, exports) {
 /** Detect free variable `exports`. */
 var freeExports = exports && !exports.nodeType && exports;
 
@@ -763,7 +846,7 @@ var freeModule = freeExports && 'object' == 'object' && module && !module.nodeTy
 var moduleExports = freeModule && freeModule.exports === freeExports;
 
 /** Detect free variable `process` from Node.js. */
-var freeProcess = moduleExports && _freeGlobal.process;
+var freeProcess = moduleExports && freeGlobal.process;
 
 /** Used to access faster Node.js helpers. */
 var nodeUtil = (function() {
@@ -781,10 +864,14 @@ var nodeUtil = (function() {
 }());
 
 module.exports = nodeUtil;
-});
+}(_nodeUtil, _nodeUtil.exports));
+
+var baseIsTypedArray = _baseIsTypedArray,
+    baseUnary = _baseUnary,
+    nodeUtil = _nodeUtil.exports;
 
 /* Node.js helper references. */
-var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
 
 /**
  * Checks if `value` is classified as a typed array.
@@ -803,9 +890,18 @@ var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
  * _.isTypedArray([]);
  * // => false
  */
-var isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;
+var isTypedArray$3 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+var isTypedArray_1 = isTypedArray$3;
 
-var isTypedArray_1 = isTypedArray;
+var baseKeys$1 = _baseKeys,
+    getTag$1 = _getTag,
+    isArguments$1 = isArguments_1,
+    isArray$7 = isArray_1,
+    isArrayLike$1 = isArrayLike_1,
+    isBuffer$2 = isBuffer$3.exports,
+    isPrototype = _isPrototype,
+    isTypedArray$2 = isTypedArray_1;
 
 /** `Object#toString` result references. */
 var mapTag$1 = '[object Map]',
@@ -854,17 +950,17 @@ function isEmpty(value) {
   if (value == null) {
     return true;
   }
-  if (isArrayLike_1(value) &&
-      (isArray_1(value) || typeof value == 'string' || typeof value.splice == 'function' ||
-        isBuffer_1(value) || isTypedArray_1(value) || isArguments_1(value))) {
+  if (isArrayLike$1(value) &&
+      (isArray$7(value) || typeof value == 'string' || typeof value.splice == 'function' ||
+        isBuffer$2(value) || isTypedArray$2(value) || isArguments$1(value))) {
     return !value.length;
   }
-  var tag = _getTag(value);
+  var tag = getTag$1(value);
   if (tag == mapTag$1 || tag == setTag$1) {
     return !value.size;
   }
-  if (_isPrototype(value)) {
-    return !_baseKeys(value).length;
+  if (isPrototype(value)) {
+    return !baseKeys$1(value).length;
   }
   for (var key in value) {
     if (hasOwnProperty$5.call(value, key)) {
@@ -883,12 +979,13 @@ var isEmpty_1 = isEmpty;
  * @name clear
  * @memberOf ListCache
  */
-function listCacheClear() {
+
+function listCacheClear$1() {
   this.__data__ = [];
   this.size = 0;
 }
 
-var _listCacheClear = listCacheClear;
+var _listCacheClear = listCacheClear$1;
 
 /**
  * Performs a
@@ -922,11 +1019,14 @@ var _listCacheClear = listCacheClear;
  * _.eq(NaN, NaN);
  * // => true
  */
-function eq(value, other) {
+
+function eq$2(value, other) {
   return value === other || (value !== value && other !== other);
 }
 
-var eq_1 = eq;
+var eq_1 = eq$2;
+
+var eq$1 = eq_1;
 
 /**
  * Gets the index at which the `key` is found in `array` of key-value pairs.
@@ -936,17 +1036,19 @@ var eq_1 = eq;
  * @param {*} key The key to search for.
  * @returns {number} Returns the index of the matched value, else `-1`.
  */
-function assocIndexOf(array, key) {
+function assocIndexOf$4(array, key) {
   var length = array.length;
   while (length--) {
-    if (eq_1(array[length][0], key)) {
+    if (eq$1(array[length][0], key)) {
       return length;
     }
   }
   return -1;
 }
 
-var _assocIndexOf = assocIndexOf;
+var _assocIndexOf = assocIndexOf$4;
+
+var assocIndexOf$3 = _assocIndexOf;
 
 /** Used for built-in method references. */
 var arrayProto = Array.prototype;
@@ -963,9 +1065,9 @@ var splice = arrayProto.splice;
  * @param {string} key The key of the value to remove.
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
-function listCacheDelete(key) {
+function listCacheDelete$1(key) {
   var data = this.__data__,
-      index = _assocIndexOf(data, key);
+      index = assocIndexOf$3(data, key);
 
   if (index < 0) {
     return false;
@@ -980,7 +1082,9 @@ function listCacheDelete(key) {
   return true;
 }
 
-var _listCacheDelete = listCacheDelete;
+var _listCacheDelete = listCacheDelete$1;
+
+var assocIndexOf$2 = _assocIndexOf;
 
 /**
  * Gets the list cache value for `key`.
@@ -991,14 +1095,16 @@ var _listCacheDelete = listCacheDelete;
  * @param {string} key The key of the value to get.
  * @returns {*} Returns the entry value.
  */
-function listCacheGet(key) {
+function listCacheGet$1(key) {
   var data = this.__data__,
-      index = _assocIndexOf(data, key);
+      index = assocIndexOf$2(data, key);
 
   return index < 0 ? undefined : data[index][1];
 }
 
-var _listCacheGet = listCacheGet;
+var _listCacheGet = listCacheGet$1;
+
+var assocIndexOf$1 = _assocIndexOf;
 
 /**
  * Checks if a list cache value for `key` exists.
@@ -1009,11 +1115,13 @@ var _listCacheGet = listCacheGet;
  * @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;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
 }
 
-var _listCacheHas = listCacheHas;
+var _listCacheHas = listCacheHas$1;
+
+var assocIndexOf = _assocIndexOf;
 
 /**
  * Sets the list cache `key` to `value`.
@@ -1025,9 +1133,9 @@ var _listCacheHas = listCacheHas;
  * @param {*} value The value to set.
  * @returns {Object} Returns the list cache instance.
  */
-function listCacheSet(key, value) {
+function listCacheSet$1(key, value) {
   var data = this.__data__,
-      index = _assocIndexOf(data, key);
+      index = assocIndexOf(data, key);
 
   if (index < 0) {
     ++this.size;
@@ -1038,7 +1146,13 @@ function listCacheSet(key, value) {
   return this;
 }
 
-var _listCacheSet = listCacheSet;
+var _listCacheSet = listCacheSet$1;
+
+var listCacheClear = _listCacheClear,
+    listCacheDelete = _listCacheDelete,
+    listCacheGet = _listCacheGet,
+    listCacheHas = _listCacheHas,
+    listCacheSet = _listCacheSet;
 
 /**
  * Creates an list cache object.
@@ -1047,7 +1161,7 @@ var _listCacheSet = listCacheSet;
  * @constructor
  * @param {Array} [entries] The key-value pairs to cache.
  */
-function ListCache(entries) {
+function ListCache$4(entries) {
   var index = -1,
       length = entries == null ? 0 : entries.length;
 
@@ -1059,13 +1173,15 @@ function ListCache(entries) {
 }
 
 // Add methods to `ListCache`.
-ListCache.prototype.clear = _listCacheClear;
-ListCache.prototype['delete'] = _listCacheDelete;
-ListCache.prototype.get = _listCacheGet;
-ListCache.prototype.has = _listCacheHas;
-ListCache.prototype.set = _listCacheSet;
+ListCache$4.prototype.clear = listCacheClear;
+ListCache$4.prototype['delete'] = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
 
-var _ListCache = ListCache;
+var _ListCache = ListCache$4;
+
+var ListCache$3 = _ListCache;
 
 /**
  * Removes all key-value entries from the stack.
@@ -1074,12 +1190,12 @@ var _ListCache = ListCache;
  * @name clear
  * @memberOf Stack
  */
-function stackClear() {
-  this.__data__ = new _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$3;
   this.size = 0;
 }
 
-var _stackClear = stackClear;
+var _stackClear = stackClear$1;
 
 /**
  * Removes `key` and its value from the stack.
@@ -1090,7 +1206,8 @@ var _stackClear = stackClear;
  * @param {string} key The key of the value to remove.
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
-function stackDelete(key) {
+
+function stackDelete$1(key) {
   var data = this.__data__,
       result = data['delete'](key);
 
@@ -1098,7 +1215,7 @@ function stackDelete(key) {
   return result;
 }
 
-var _stackDelete = stackDelete;
+var _stackDelete = stackDelete$1;
 
 /**
  * Gets the stack value for `key`.
@@ -1109,11 +1226,12 @@ var _stackDelete = stackDelete;
  * @param {string} key The key of the value to get.
  * @returns {*} Returns the entry value.
  */
-function stackGet(key) {
+
+function stackGet$1(key) {
   return this.__data__.get(key);
 }
 
-var _stackGet = stackGet;
+var _stackGet = stackGet$1;
 
 /**
  * Checks if a stack value for `key` exists.
@@ -1124,16 +1242,21 @@ var _stackGet = stackGet;
  * @param {string} key The key of the entry to check.
  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  */
-function stackHas(key) {
+
+function stackHas$1(key) {
   return this.__data__.has(key);
 }
 
-var _stackHas = stackHas;
+var _stackHas = stackHas$1;
+
+var getNative = _getNative;
 
 /* Built-in method references that are verified to be native. */
-var nativeCreate = _getNative(Object, 'create');
+var nativeCreate$4 = getNative(Object, 'create');
+
+var _nativeCreate = nativeCreate$4;
 
-var _nativeCreate = nativeCreate;
+var nativeCreate$3 = _nativeCreate;
 
 /**
  * Removes all key-value entries from the hash.
@@ -1142,12 +1265,12 @@ var _nativeCreate = nativeCreate;
  * @name clear
  * @memberOf Hash
  */
-function hashClear() {
-  this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
   this.size = 0;
 }
 
-var _hashClear = hashClear;
+var _hashClear = hashClear$1;
 
 /**
  * Removes `key` and its value from the hash.
@@ -1159,13 +1282,16 @@ var _hashClear = hashClear;
  * @param {string} key The key of the value to remove.
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
-function hashDelete(key) {
+
+function hashDelete$1(key) {
   var result = this.has(key) && delete this.__data__[key];
   this.size -= result ? 1 : 0;
   return result;
 }
 
-var _hashDelete = hashDelete;
+var _hashDelete = hashDelete$1;
+
+var nativeCreate$2 = _nativeCreate;
 
 /** Used to stand-in for `undefined` hash values. */
 var HASH_UNDEFINED$2 = '__lodash_hash_undefined__';
@@ -1185,16 +1311,18 @@ var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
  * @param {string} key The key of the value to get.
  * @returns {*} Returns the entry value.
  */
-function hashGet(key) {
+function hashGet$1(key) {
   var data = this.__data__;
-  if (_nativeCreate) {
+  if (nativeCreate$2) {
     var result = data[key];
     return result === HASH_UNDEFINED$2 ? undefined : result;
   }
   return hasOwnProperty$4.call(data, key) ? data[key] : undefined;
 }
 
-var _hashGet = hashGet;
+var _hashGet = hashGet$1;
+
+var nativeCreate$1 = _nativeCreate;
 
 /** Used for built-in method references. */
 var objectProto$4 = Object.prototype;
@@ -1211,12 +1339,14 @@ var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
  * @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) {
+function hashHas$1(key) {
   var data = this.__data__;
-  return _nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);
+  return nativeCreate$1 ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);
 }
 
-var _hashHas = hashHas;
+var _hashHas = hashHas$1;
+
+var nativeCreate = _nativeCreate;
 
 /** Used to stand-in for `undefined` hash values. */
 var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
@@ -1231,14 +1361,20 @@ var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
  * @param {*} value The value to set.
  * @returns {Object} Returns the hash instance.
  */
-function hashSet(key, value) {
+function hashSet$1(key, value) {
   var data = this.__data__;
   this.size += this.has(key) ? 0 : 1;
-  data[key] = (_nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED$1 : value;
   return this;
 }
 
-var _hashSet = hashSet;
+var _hashSet = hashSet$1;
+
+var hashClear = _hashClear,
+    hashDelete = _hashDelete,
+    hashGet = _hashGet,
+    hashHas = _hashHas,
+    hashSet = _hashSet;
 
 /**
  * Creates a hash object.
@@ -1247,7 +1383,7 @@ var _hashSet = hashSet;
  * @constructor
  * @param {Array} [entries] The key-value pairs to cache.
  */
-function Hash(entries) {
+function Hash$1(entries) {
   var index = -1,
       length = entries == null ? 0 : entries.length;
 
@@ -1259,13 +1395,17 @@ function Hash(entries) {
 }
 
 // Add methods to `Hash`.
-Hash.prototype.clear = _hashClear;
-Hash.prototype['delete'] = _hashDelete;
-Hash.prototype.get = _hashGet;
-Hash.prototype.has = _hashHas;
-Hash.prototype.set = _hashSet;
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype['delete'] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+
+var _Hash = Hash$1;
 
-var _Hash = Hash;
+var Hash = _Hash,
+    ListCache$2 = _ListCache,
+    Map$1 = _Map;
 
 /**
  * Removes all key-value entries from the map.
@@ -1274,16 +1414,16 @@ var _Hash = Hash;
  * @name clear
  * @memberOf MapCache
  */
-function mapCacheClear() {
+function mapCacheClear$1() {
   this.size = 0;
   this.__data__ = {
-    'hash': new _Hash,
-    'map': new (_Map || _ListCache),
-    'string': new _Hash
+    'hash': new Hash,
+    'map': new (Map$1 || ListCache$2),
+    'string': new Hash
   };
 }
 
-var _mapCacheClear = mapCacheClear;
+var _mapCacheClear = mapCacheClear$1;
 
 /**
  * Checks if `value` is suitable for use as unique object key.
@@ -1292,14 +1432,17 @@ var _mapCacheClear = mapCacheClear;
  * @param {*} value The value to check.
  * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
  */
-function isKeyable(value) {
+
+function isKeyable$1(value) {
   var type = typeof value;
   return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
     ? (value !== '__proto__')
     : (value === null);
 }
 
-var _isKeyable = isKeyable;
+var _isKeyable = isKeyable$1;
+
+var isKeyable = _isKeyable;
 
 /**
  * Gets the data for `map`.
@@ -1309,14 +1452,16 @@ var _isKeyable = isKeyable;
  * @param {string} key The reference key.
  * @returns {*} Returns the map data.
  */
-function getMapData(map, key) {
+function getMapData$4(map, key) {
   var data = map.__data__;
-  return _isKeyable(key)
+  return isKeyable(key)
     ? data[typeof key == 'string' ? 'string' : 'hash']
     : data.map;
 }
 
-var _getMapData = getMapData;
+var _getMapData = getMapData$4;
+
+var getMapData$3 = _getMapData;
 
 /**
  * Removes `key` and its value from the map.
@@ -1327,13 +1472,15 @@ var _getMapData = getMapData;
  * @param {string} key The key of the value to remove.
  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  */
-function mapCacheDelete(key) {
-  var result = _getMapData(this, key)['delete'](key);
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)['delete'](key);
   this.size -= result ? 1 : 0;
   return result;
 }
 
-var _mapCacheDelete = mapCacheDelete;
+var _mapCacheDelete = mapCacheDelete$1;
+
+var getMapData$2 = _getMapData;
 
 /**
  * Gets the map value for `key`.
@@ -1344,11 +1491,13 @@ var _mapCacheDelete = mapCacheDelete;
  * @param {string} key The key of the value to get.
  * @returns {*} Returns the entry value.
  */
-function mapCacheGet(key) {
-  return _getMapData(this, key).get(key);
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
 }
 
-var _mapCacheGet = mapCacheGet;
+var _mapCacheGet = mapCacheGet$1;
+
+var getMapData$1 = _getMapData;
 
 /**
  * Checks if a map value for `key` exists.
@@ -1359,11 +1508,13 @@ var _mapCacheGet = mapCacheGet;
  * @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);
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
 }
 
-var _mapCacheHas = mapCacheHas;
+var _mapCacheHas = mapCacheHas$1;
+
+var getMapData = _getMapData;
 
 /**
  * Sets the map `key` to `value`.
@@ -1375,8 +1526,8 @@ var _mapCacheHas = mapCacheHas;
  * @param {*} value The value to set.
  * @returns {Object} Returns the map cache instance.
  */
-function mapCacheSet(key, value) {
-  var data = _getMapData(this, key),
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key),
       size = data.size;
 
   data.set(key, value);
@@ -1384,7 +1535,13 @@ function mapCacheSet(key, value) {
   return this;
 }
 
-var _mapCacheSet = mapCacheSet;
+var _mapCacheSet = mapCacheSet$1;
+
+var mapCacheClear = _mapCacheClear,
+    mapCacheDelete = _mapCacheDelete,
+    mapCacheGet = _mapCacheGet,
+    mapCacheHas = _mapCacheHas,
+    mapCacheSet = _mapCacheSet;
 
 /**
  * Creates a map cache object to store key-value pairs.
@@ -1393,7 +1550,7 @@ var _mapCacheSet = mapCacheSet;
  * @constructor
  * @param {Array} [entries] The key-value pairs to cache.
  */
-function MapCache(entries) {
+function MapCache$3(entries) {
   var index = -1,
       length = entries == null ? 0 : entries.length;
 
@@ -1405,13 +1562,17 @@ function MapCache(entries) {
 }
 
 // Add methods to `MapCache`.
-MapCache.prototype.clear = _mapCacheClear;
-MapCache.prototype['delete'] = _mapCacheDelete;
-MapCache.prototype.get = _mapCacheGet;
-MapCache.prototype.has = _mapCacheHas;
-MapCache.prototype.set = _mapCacheSet;
+MapCache$3.prototype.clear = mapCacheClear;
+MapCache$3.prototype['delete'] = mapCacheDelete;
+MapCache$3.prototype.get = mapCacheGet;
+MapCache$3.prototype.has = mapCacheHas;
+MapCache$3.prototype.set = mapCacheSet;
 
-var _MapCache = MapCache;
+var _MapCache = MapCache$3;
+
+var ListCache$1 = _ListCache,
+    Map = _Map,
+    MapCache$2 = _MapCache;
 
 /** Used as the size to enable large array optimizations. */
 var LARGE_ARRAY_SIZE = 200;
@@ -1426,23 +1587,30 @@ var LARGE_ARRAY_SIZE = 200;
  * @param {*} value The value to set.
  * @returns {Object} Returns the stack cache instance.
  */
-function stackSet(key, value) {
+function stackSet$1(key, value) {
   var data = this.__data__;
-  if (data instanceof _ListCache) {
+  if (data instanceof ListCache$1) {
     var pairs = data.__data__;
-    if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
       pairs.push([key, value]);
       this.size = ++data.size;
       return this;
     }
-    data = this.__data__ = new _MapCache(pairs);
+    data = this.__data__ = new MapCache$2(pairs);
   }
   data.set(key, value);
   this.size = data.size;
   return this;
 }
 
-var _stackSet = stackSet;
+var _stackSet = stackSet$1;
+
+var ListCache = _ListCache,
+    stackClear = _stackClear,
+    stackDelete = _stackDelete,
+    stackGet = _stackGet,
+    stackHas = _stackHas,
+    stackSet = _stackSet;
 
 /**
  * Creates a stack cache object to store key-value pairs.
@@ -1451,21 +1619,22 @@ var _stackSet = stackSet;
  * @constructor
  * @param {Array} [entries] The key-value pairs to cache.
  */
-function Stack(entries) {
-  var data = this.__data__ = new _ListCache(entries);
+function Stack$1(entries) {
+  var data = this.__data__ = new ListCache(entries);
   this.size = data.size;
 }
 
 // Add methods to `Stack`.
-Stack.prototype.clear = _stackClear;
-Stack.prototype['delete'] = _stackDelete;
-Stack.prototype.get = _stackGet;
-Stack.prototype.has = _stackHas;
-Stack.prototype.set = _stackSet;
+Stack$1.prototype.clear = stackClear;
+Stack$1.prototype['delete'] = stackDelete;
+Stack$1.prototype.get = stackGet;
+Stack$1.prototype.has = stackHas;
+Stack$1.prototype.set = stackSet;
 
-var _Stack = Stack;
+var _Stack = Stack$1;
 
 /** Used to stand-in for `undefined` hash values. */
+
 var HASH_UNDEFINED = '__lodash_hash_undefined__';
 
 /**
@@ -1478,12 +1647,12 @@ var HASH_UNDEFINED = '__lodash_hash_undefined__';
  * @param {*} value The value to cache.
  * @returns {Object} Returns the cache instance.
  */
-function setCacheAdd(value) {
+function setCacheAdd$1(value) {
   this.__data__.set(value, HASH_UNDEFINED);
   return this;
 }
 
-var _setCacheAdd = setCacheAdd;
+var _setCacheAdd = setCacheAdd$1;
 
 /**
  * Checks if `value` is in the array cache.
@@ -1494,11 +1663,16 @@ var _setCacheAdd = setCacheAdd;
  * @param {*} value The value to search for.
  * @returns {number} Returns `true` if `value` is found, else `false`.
  */
-function setCacheHas(value) {
+
+function setCacheHas$1(value) {
   return this.__data__.has(value);
 }
 
-var _setCacheHas = setCacheHas;
+var _setCacheHas = setCacheHas$1;
+
+var MapCache$1 = _MapCache,
+    setCacheAdd = _setCacheAdd,
+    setCacheHas = _setCacheHas;
 
 /**
  *
@@ -1508,21 +1682,21 @@ var _setCacheHas = setCacheHas;
  * @constructor
  * @param {Array} [values] The values to cache.
  */
-function SetCache(values) {
+function SetCache$1(values) {
   var index = -1,
       length = values == null ? 0 : values.length;
 
-  this.__data__ = new _MapCache;
+  this.__data__ = new MapCache$1;
   while (++index < length) {
     this.add(values[index]);
   }
 }
 
 // Add methods to `SetCache`.
-SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
-SetCache.prototype.has = _setCacheHas;
+SetCache$1.prototype.add = SetCache$1.prototype.push = setCacheAdd;
+SetCache$1.prototype.has = setCacheHas;
 
-var _SetCache = SetCache;
+var _SetCache = SetCache$1;
 
 /**
  * A specialized version of `_.some` for arrays without support for iteratee
@@ -1534,7 +1708,8 @@ var _SetCache = SetCache;
  * @returns {boolean} Returns `true` if any element passes the predicate check,
  *  else `false`.
  */
-function arraySome(array, predicate) {
+
+function arraySome$1(array, predicate) {
   var index = -1,
       length = array == null ? 0 : array.length;
 
@@ -1546,7 +1721,7 @@ function arraySome(array, predicate) {
   return false;
 }
 
-var _arraySome = arraySome;
+var _arraySome = arraySome$1;
 
 /**
  * Checks if a `cache` value for `key` exists.
@@ -1556,11 +1731,16 @@ var _arraySome = arraySome;
  * @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) {
+
+function cacheHas$1(cache, key) {
   return cache.has(key);
 }
 
-var _cacheHas = cacheHas;
+var _cacheHas = cacheHas$1;
+
+var SetCache = _SetCache,
+    arraySome = _arraySome,
+    cacheHas = _cacheHas;
 
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG$3 = 1,
@@ -1579,7 +1759,7 @@ var COMPARE_PARTIAL_FLAG$3 = 1,
  * @param {Object} stack Tracks traversed `array` and `other` objects.
  * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
  */
-function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
   var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3,
       arrLength = array.length,
       othLength = other.length;
@@ -1595,7 +1775,7 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
   }
   var index = -1,
       result = true,
-      seen = (bitmask & COMPARE_UNORDERED_FLAG$1) ? new _SetCache : undefined;
+      seen = (bitmask & COMPARE_UNORDERED_FLAG$1) ? new SetCache : undefined;
 
   stack.set(array, other);
   stack.set(other, array);
@@ -1619,8 +1799,8 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
     }
     // Recursively compare arrays (susceptible to call stack limits).
     if (seen) {
-      if (!_arraySome(other, function(othValue, othIndex) {
-            if (!_cacheHas(seen, othIndex) &&
+      if (!arraySome(other, function(othValue, othIndex) {
+            if (!cacheHas(seen, othIndex) &&
                 (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
               return seen.push(othIndex);
             }
@@ -1641,12 +1821,14 @@ function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
   return result;
 }
 
-var _equalArrays = equalArrays;
+var _equalArrays = equalArrays$2;
+
+var root = _root;
 
 /** Built-in value references. */
-var Uint8Array = _root.Uint8Array;
+var Uint8Array$1 = root.Uint8Array;
 
-var _Uint8Array = Uint8Array;
+var _Uint8Array = Uint8Array$1;
 
 /**
  * Converts `map` to its key-value pairs.
@@ -1655,7 +1837,8 @@ var _Uint8Array = Uint8Array;
  * @param {Object} map The map to convert.
  * @returns {Array} Returns the key-value pairs.
  */
-function mapToArray(map) {
+
+function mapToArray$1(map) {
   var index = -1,
       result = Array(map.size);
 
@@ -1665,7 +1848,7 @@ function mapToArray(map) {
   return result;
 }
 
-var _mapToArray = mapToArray;
+var _mapToArray = mapToArray$1;
 
 /**
  * Converts `set` to an array of its values.
@@ -1674,7 +1857,8 @@ var _mapToArray = mapToArray;
  * @param {Object} set The set to convert.
  * @returns {Array} Returns the values.
  */
-function setToArray(set) {
+
+function setToArray$1(set) {
   var index = -1,
       result = Array(set.size);
 
@@ -1684,7 +1868,14 @@ function setToArray(set) {
   return result;
 }
 
-var _setToArray = setToArray;
+var _setToArray = setToArray$1;
+
+var Symbol$1 = _Symbol,
+    Uint8Array = _Uint8Array,
+    eq = eq_1,
+    equalArrays$1 = _equalArrays,
+    mapToArray = _mapToArray,
+    setToArray = _setToArray;
 
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG$2 = 1,
@@ -1705,7 +1896,7 @@ var arrayBufferTag = '[object ArrayBuffer]',
     dataViewTag = '[object DataView]';
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto$1 = _Symbol ? _Symbol.prototype : undefined,
+var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : undefined,
     symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : undefined;
 
 /**
@@ -1725,7 +1916,7 @@ var symbolProto$1 = _Symbol ? _Symbol.prototype : undefined,
  * @param {Object} stack Tracks traversed `object` and `other` objects.
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
-function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
   switch (tag) {
     case dataViewTag:
       if ((object.byteLength != other.byteLength) ||
@@ -1737,7 +1928,7 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
 
     case arrayBufferTag:
       if ((object.byteLength != other.byteLength) ||
-          !equalFunc(new _Uint8Array(object), new _Uint8Array(other))) {
+          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
         return false;
       }
       return true;
@@ -1747,7 +1938,7 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
     case numberTag:
       // Coerce booleans to `1` or `0` and dates to milliseconds.
       // Invalid dates are coerced to `NaN`.
-      return eq_1(+object, +other);
+      return eq(+object, +other);
 
     case errorTag:
       return object.name == other.name && object.message == other.message;
@@ -1760,11 +1951,11 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
       return object == (other + '');
 
     case mapTag:
-      var convert = _mapToArray;
+      var convert = mapToArray;
 
     case setTag:
       var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
-      convert || (convert = _setToArray);
+      convert || (convert = setToArray);
 
       if (object.size != other.size && !isPartial) {
         return false;
@@ -1778,7 +1969,7 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
 
       // Recursively compare objects (susceptible to call stack limits).
       stack.set(object, other);
-      var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
       stack['delete'](object);
       return result;
 
@@ -1790,7 +1981,7 @@ function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
   return false;
 }
 
-var _equalByTag = equalByTag;
+var _equalByTag = equalByTag$1;
 
 /**
  * Appends the elements of `values` to `array`.
@@ -1800,7 +1991,8 @@ var _equalByTag = equalByTag;
  * @param {Array} values The values to append.
  * @returns {Array} Returns `array`.
  */
-function arrayPush(array, values) {
+
+function arrayPush$1(array, values) {
   var index = -1,
       length = values.length,
       offset = array.length;
@@ -1811,7 +2003,10 @@ function arrayPush(array, values) {
   return array;
 }
 
-var _arrayPush = arrayPush;
+var _arrayPush = arrayPush$1;
+
+var arrayPush = _arrayPush,
+    isArray$6 = isArray_1;
 
 /**
  * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
@@ -1824,12 +2019,12 @@ var _arrayPush = arrayPush;
  * @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) {
+function baseGetAllKeys$1(object, keysFunc, symbolsFunc) {
   var result = keysFunc(object);
-  return isArray_1(object) ? result : _arrayPush(result, symbolsFunc(object));
+  return isArray$6(object) ? result : arrayPush(result, symbolsFunc(object));
 }
 
-var _baseGetAllKeys = baseGetAllKeys;
+var _baseGetAllKeys = baseGetAllKeys$1;
 
 /**
  * A specialized version of `_.filter` for arrays without support for
@@ -1840,7 +2035,8 @@ var _baseGetAllKeys = baseGetAllKeys;
  * @param {Function} predicate The function invoked per iteration.
  * @returns {Array} Returns the new filtered array.
  */
-function arrayFilter(array, predicate) {
+
+function arrayFilter$1(array, predicate) {
   var index = -1,
       length = array == null ? 0 : array.length,
       resIndex = 0,
@@ -1855,7 +2051,7 @@ function arrayFilter(array, predicate) {
   return result;
 }
 
-var _arrayFilter = arrayFilter;
+var _arrayFilter = arrayFilter$1;
 
 /**
  * This method returns a new empty array.
@@ -1875,11 +2071,15 @@ var _arrayFilter = arrayFilter;
  * console.log(arrays[0] === arrays[1]);
  * // => false
  */
-function stubArray() {
+
+function stubArray$1() {
   return [];
 }
 
-var stubArray_1 = stubArray;
+var stubArray_1 = stubArray$1;
+
+var arrayFilter = _arrayFilter,
+    stubArray = stubArray_1;
 
 /** Used for built-in method references. */
 var objectProto$3 = Object.prototype;
@@ -1897,17 +2097,17 @@ var nativeGetSymbols = Object.getOwnPropertySymbols;
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of symbols.
  */
-var getSymbols = !nativeGetSymbols ? stubArray_1 : function(object) {
+var getSymbols$1 = !nativeGetSymbols ? stubArray : function(object) {
   if (object == null) {
     return [];
   }
   object = Object(object);
-  return _arrayFilter(nativeGetSymbols(object), function(symbol) {
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
     return propertyIsEnumerable.call(object, symbol);
   });
 };
 
-var _getSymbols = getSymbols;
+var _getSymbols = getSymbols$1;
 
 /**
  * The base implementation of `_.times` without support for iteratee shorthands
@@ -1918,7 +2118,8 @@ var _getSymbols = getSymbols;
  * @param {Function} iteratee The function invoked per iteration.
  * @returns {Array} Returns the array of results.
  */
-function baseTimes(n, iteratee) {
+
+function baseTimes$1(n, iteratee) {
   var index = -1,
       result = Array(n);
 
@@ -1928,9 +2129,10 @@ function baseTimes(n, iteratee) {
   return result;
 }
 
-var _baseTimes = baseTimes;
+var _baseTimes = baseTimes$1;
 
 /** Used as references for various `Number` constants. */
+
 var MAX_SAFE_INTEGER = 9007199254740991;
 
 /** Used to detect unsigned integer values. */
@@ -1944,7 +2146,7 @@ var reIsUint = /^(?:0|[1-9]\d*)$/;
  * @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) {
+function isIndex$1(value, length) {
   var type = typeof value;
   length = length == null ? MAX_SAFE_INTEGER : length;
 
@@ -1954,7 +2156,14 @@ function isIndex(value, length) {
         (value > -1 && value % 1 == 0 && value < length);
 }
 
-var _isIndex = isIndex;
+var _isIndex = isIndex$1;
+
+var baseTimes = _baseTimes,
+    isArguments = isArguments_1,
+    isArray$5 = isArray_1,
+    isBuffer$1 = isBuffer$3.exports,
+    isIndex = _isIndex,
+    isTypedArray$1 = isTypedArray_1;
 
 /** Used for built-in method references. */
 var objectProto$2 = Object.prototype;
@@ -1970,13 +2179,13 @@ var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
  * @param {boolean} inherited Specify returning inherited property names.
  * @returns {Array} Returns the array of property names.
  */
-function arrayLikeKeys(value, inherited) {
-  var isArr = isArray_1(value),
-      isArg = !isArr && isArguments_1(value),
-      isBuff = !isArr && !isArg && isBuffer_1(value),
-      isType = !isArr && !isArg && !isBuff && isTypedArray_1(value),
+function arrayLikeKeys$1(value, inherited) {
+  var isArr = isArray$5(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer$1(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray$1(value),
       skipIndexes = isArr || isArg || isBuff || isType,
-      result = skipIndexes ? _baseTimes(value.length, String) : [],
+      result = skipIndexes ? baseTimes(value.length, String) : [],
       length = result.length;
 
   for (var key in value) {
@@ -1989,7 +2198,7 @@ function arrayLikeKeys(value, inherited) {
            // PhantomJS 2 has enumerable non-index properties on typed arrays.
            (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
            // Skip index properties.
-           _isIndex(key, length)
+           isIndex(key, length)
         ))) {
       result.push(key);
     }
@@ -1997,7 +2206,11 @@ function arrayLikeKeys(value, inherited) {
   return result;
 }
 
-var _arrayLikeKeys = arrayLikeKeys;
+var _arrayLikeKeys = arrayLikeKeys$1;
+
+var arrayLikeKeys = _arrayLikeKeys,
+    baseKeys = _baseKeys,
+    isArrayLike = isArrayLike_1;
 
 /**
  * Creates an array of the own enumerable property names of `object`.
@@ -2027,11 +2240,15 @@ var _arrayLikeKeys = arrayLikeKeys;
  * _.keys('hi');
  * // => ['0', '1']
  */
-function keys(object) {
-  return isArrayLike_1(object) ? _arrayLikeKeys(object) : _baseKeys(object);
+function keys$2(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
 }
 
-var keys_1 = keys;
+var keys_1 = keys$2;
+
+var baseGetAllKeys = _baseGetAllKeys,
+    getSymbols = _getSymbols,
+    keys$1 = keys_1;
 
 /**
  * Creates an array of own enumerable property names and symbols of `object`.
@@ -2040,11 +2257,13 @@ var keys_1 = keys;
  * @param {Object} object The object to query.
  * @returns {Array} Returns the array of property names and symbols.
  */
-function getAllKeys(object) {
-  return _baseGetAllKeys(object, keys_1, _getSymbols);
+function getAllKeys$1(object) {
+  return baseGetAllKeys(object, keys$1, getSymbols);
 }
 
-var _getAllKeys = getAllKeys;
+var _getAllKeys = getAllKeys$1;
+
+var getAllKeys = _getAllKeys;
 
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG$1 = 1;
@@ -2068,11 +2287,11 @@ var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
  * @param {Object} stack Tracks traversed `object` and `other` objects.
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
-function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
   var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1,
-      objProps = _getAllKeys(object),
+      objProps = getAllKeys(object),
       objLength = objProps.length,
-      othProps = _getAllKeys(other),
+      othProps = getAllKeys(other),
       othLength = othProps.length;
 
   if (objLength != othLength && !isPartial) {
@@ -2133,7 +2352,16 @@ function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
   return result;
 }
 
-var _equalObjects = equalObjects;
+var _equalObjects = equalObjects$1;
+
+var Stack = _Stack,
+    equalArrays = _equalArrays,
+    equalByTag = _equalByTag,
+    equalObjects = _equalObjects,
+    getTag = _getTag,
+    isArray$4 = isArray_1,
+    isBuffer = isBuffer$3.exports,
+    isTypedArray = isTypedArray_1;
 
 /** Used to compose bitmasks for value comparisons. */
 var COMPARE_PARTIAL_FLAG = 1;
@@ -2163,11 +2391,11 @@ var hasOwnProperty = objectProto.hasOwnProperty;
  * @param {Object} [stack] Tracks traversed `object` and `other` objects.
  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  */
-function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
-  var objIsArr = isArray_1(object),
-      othIsArr = isArray_1(other),
-      objTag = objIsArr ? arrayTag : _getTag(object),
-      othTag = othIsArr ? arrayTag : _getTag(other);
+function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray$4(object),
+      othIsArr = isArray$4(other),
+      objTag = objIsArr ? arrayTag : getTag(object),
+      othTag = othIsArr ? arrayTag : getTag(other);
 
   objTag = objTag == argsTag ? objectTag : objTag;
   othTag = othTag == argsTag ? objectTag : othTag;
@@ -2176,18 +2404,18 @@ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
       othIsObj = othTag == objectTag,
       isSameTag = objTag == othTag;
 
-  if (isSameTag && isBuffer_1(object)) {
-    if (!isBuffer_1(other)) {
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
       return false;
     }
     objIsArr = true;
     objIsObj = false;
   }
   if (isSameTag && !objIsObj) {
-    stack || (stack = new _Stack);
-    return (objIsArr || isTypedArray_1(object))
-      ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack)
-      : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+    stack || (stack = new Stack);
+    return (objIsArr || isTypedArray(object))
+      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)
+      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
   }
   if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
     var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
@@ -2197,18 +2425,21 @@ function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
       var objUnwrapped = objIsWrapped ? object.value() : object,
           othUnwrapped = othIsWrapped ? other.value() : other;
 
-      stack || (stack = new _Stack);
+      stack || (stack = new Stack);
       return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
     }
   }
   if (!isSameTag) {
     return false;
   }
-  stack || (stack = new _Stack);
-  return _equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+  stack || (stack = new Stack);
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
 }
 
-var _baseIsEqualDeep = baseIsEqualDeep;
+var _baseIsEqualDeep = baseIsEqualDeep$1;
+
+var baseIsEqualDeep = _baseIsEqualDeep,
+    isObjectLike$1 = isObjectLike_1;
 
 /**
  * The base implementation of `_.isEqual` which supports partial comparisons
@@ -2224,17 +2455,19 @@ var _baseIsEqualDeep = baseIsEqualDeep;
  * @param {Object} [stack] Tracks traversed `value` and `other` objects.
  * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
  */
-function baseIsEqual(value, other, bitmask, customizer, stack) {
+function baseIsEqual$1(value, other, bitmask, customizer, stack) {
   if (value === other) {
     return true;
   }
-  if (value == null || other == null || (!isObjectLike_1(value) && !isObjectLike_1(other))) {
+  if (value == null || other == null || (!isObjectLike$1(value) && !isObjectLike$1(other))) {
     return value !== value && other !== other;
   }
-  return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual$1, stack);
 }
 
-var _baseIsEqual = baseIsEqual;
+var _baseIsEqual = baseIsEqual$1;
+
+var baseIsEqual = _baseIsEqual;
 
 /**
  * Performs a deep comparison between two values to determine if they are
@@ -2265,7 +2498,7 @@ var _baseIsEqual = baseIsEqual;
  * // => false
  */
 function isEqual(value, other) {
-  return _baseIsEqual(value, other);
+  return baseIsEqual(value, other);
 }
 
 var isEqual_1 = isEqual;
@@ -2297,7 +2530,18 @@ var defaults = {
   gridColumns: '2'
 };
 
-var lodash = createCommonjsModule(function (module, exports) {
+var lodash = {exports: {}};
+
+/**
+ * @license
+ * Lodash <https://lodash.com/>
+ * Copyright OpenJS Foundation and other contributors <https://openjsf.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
+ */
+
+(function (module, exports) {
 (function() {
 
   /** Used as a safe reference for `undefined` in pre-ES5 environments. */
@@ -19485,7 +19729,9 @@ var lodash = createCommonjsModule(function (module, exports) {
     root._ = _;
   }
 }.call(commonjsGlobal));
-});
+}(lodash, lodash.exports));
+
+var _ = lodash.exports;
 
 const enabled = (config, env, defaultValue) => {
   // if model.partialScoring = false
@@ -19504,9 +19750,12 @@ const enabled = (config, env, defaultValue) => {
     return false;
   }
 
-  return lodash.isBoolean(defaultValue) ? defaultValue : true;
+  return _.isBoolean(defaultValue) ? defaultValue : true;
 };
 
+var baseGetTag = _baseGetTag,
+    isObjectLike = isObjectLike_1;
+
 /** `Object#toString` result references. */
 var symbolTag = '[object Symbol]';
 
@@ -19527,12 +19776,15 @@ var symbolTag = '[object Symbol]';
  * _.isSymbol('abc');
  * // => false
  */
-function isSymbol(value) {
+function isSymbol$3(value) {
   return typeof value == 'symbol' ||
-    (isObjectLike_1(value) && _baseGetTag(value) == symbolTag);
+    (isObjectLike(value) && baseGetTag(value) == symbolTag);
 }
 
-var isSymbol_1 = isSymbol;
+var isSymbol_1 = isSymbol$3;
+
+var isArray$3 = isArray_1,
+    isSymbol$2 = isSymbol_1;
 
 /** Used to match property names within property paths. */
 var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
@@ -19546,20 +19798,22 @@ var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
  * @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_1(value)) {
+function isKey$1(value, object) {
+  if (isArray$3(value)) {
     return false;
   }
   var type = typeof value;
   if (type == 'number' || type == 'symbol' || type == 'boolean' ||
-      value == null || isSymbol_1(value)) {
+      value == null || isSymbol$2(value)) {
     return true;
   }
   return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
     (object != null && value in Object(object));
 }
 
-var _isKey = isKey;
+var _isKey = isKey$1;
+
+var MapCache = _MapCache;
 
 /** Error message constants. */
 var FUNC_ERROR_TEXT = 'Expected a function';
@@ -19608,7 +19862,7 @@ var FUNC_ERROR_TEXT = 'Expected a function';
  * // Replace `_.memoize.Cache`.
  * _.memoize.Cache = WeakMap;
  */
-function memoize(func, resolver) {
+function memoize$1(func, resolver) {
   if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
     throw new TypeError(FUNC_ERROR_TEXT);
   }
@@ -19624,14 +19878,16 @@ function memoize(func, resolver) {
     memoized.cache = cache.set(key, result) || cache;
     return result;
   };
-  memoized.cache = new (memoize.Cache || _MapCache);
+  memoized.cache = new (memoize$1.Cache || MapCache);
   return memoized;
 }
 
 // Expose `MapCache`.
-memoize.Cache = _MapCache;
+memoize$1.Cache = MapCache;
+
+var memoize_1 = memoize$1;
 
-var memoize_1 = memoize;
+var memoize = memoize_1;
 
 /** Used as the maximum memoize cache size. */
 var MAX_MEMOIZE_SIZE = 500;
@@ -19644,8 +19900,8 @@ var MAX_MEMOIZE_SIZE = 500;
  * @param {Function} func The function to have its output memoized.
  * @returns {Function} Returns the new memoized function.
  */
-function memoizeCapped(func) {
-  var result = memoize_1(func, function(key) {
+function memoizeCapped$1(func) {
+  var result = memoize(func, function(key) {
     if (cache.size === MAX_MEMOIZE_SIZE) {
       cache.clear();
     }
@@ -19656,7 +19912,9 @@ function memoizeCapped(func) {
   return result;
 }
 
-var _memoizeCapped = memoizeCapped;
+var _memoizeCapped = memoizeCapped$1;
+
+var memoizeCapped = _memoizeCapped;
 
 /** Used to match property names within property paths. */
 var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
@@ -19671,7 +19929,7 @@ var reEscapeChar = /\\(\\)?/g;
  * @param {string} string The string to convert.
  * @returns {Array} Returns the property path array.
  */
-var stringToPath = _memoizeCapped(function(string) {
+var stringToPath$1 = memoizeCapped(function(string) {
   var result = [];
   if (string.charCodeAt(0) === 46 /* . */) {
     result.push('');
@@ -19682,7 +19940,7 @@ var stringToPath = _memoizeCapped(function(string) {
   return result;
 });
 
-var _stringToPath = stringToPath;
+var _stringToPath = stringToPath$1;
 
 /**
  * A specialized version of `_.map` for arrays without support for iteratee
@@ -19693,7 +19951,8 @@ var _stringToPath = stringToPath;
  * @param {Function} iteratee The function invoked per iteration.
  * @returns {Array} Returns the new mapped array.
  */
-function arrayMap(array, iteratee) {
+
+function arrayMap$2(array, iteratee) {
   var index = -1,
       length = array == null ? 0 : array.length,
       result = Array(length);
@@ -19704,13 +19963,18 @@ function arrayMap(array, iteratee) {
   return result;
 }
 
-var _arrayMap = arrayMap;
+var _arrayMap = arrayMap$2;
+
+var Symbol = _Symbol,
+    arrayMap$1 = _arrayMap,
+    isArray$2 = isArray_1,
+    isSymbol$1 = isSymbol_1;
 
 /** Used as references for various `Number` constants. */
 var INFINITY$1 = 1 / 0;
 
 /** Used to convert symbols to primitives and strings. */
-var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+var symbolProto = Symbol ? Symbol.prototype : undefined,
     symbolToString = symbolProto ? symbolProto.toString : undefined;
 
 /**
@@ -19721,23 +19985,25 @@ var symbolProto = _Symbol ? _Symbol.prototype : undefined,
  * @param {*} value The value to process.
  * @returns {string} Returns the string.
  */
-function baseToString(value) {
+function baseToString$1(value) {
   // Exit early for strings to avoid a performance hit in some environments.
   if (typeof value == 'string') {
     return value;
   }
-  if (isArray_1(value)) {
+  if (isArray$2(value)) {
     // Recursively convert values (susceptible to call stack limits).
-    return _arrayMap(value, baseToString) + '';
+    return arrayMap$1(value, baseToString$1) + '';
   }
-  if (isSymbol_1(value)) {
+  if (isSymbol$1(value)) {
     return symbolToString ? symbolToString.call(value) : '';
   }
   var result = (value + '');
   return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result;
 }
 
-var _baseToString = baseToString;
+var _baseToString = baseToString$1;
+
+var baseToString = _baseToString;
 
 /**
  * Converts `value` to a string. An empty string is returned for `null`
@@ -19760,11 +20026,16 @@ var _baseToString = baseToString;
  * _.toString([1, 2, 3]);
  * // => '1,2,3'
  */
-function toString(value) {
-  return value == null ? '' : _baseToString(value);
+function toString$1(value) {
+  return value == null ? '' : baseToString(value);
 }
 
-var toString_1 = toString;
+var toString_1 = toString$1;
+
+var isArray$1 = isArray_1,
+    isKey = _isKey,
+    stringToPath = _stringToPath,
+    toString = toString_1;
 
 /**
  * Casts `value` to a path array if it's not one.
@@ -19774,14 +20045,16 @@ var toString_1 = toString;
  * @param {Object} [object] The object to query keys on.
  * @returns {Array} Returns the cast property path array.
  */
-function castPath(value, object) {
-  if (isArray_1(value)) {
+function castPath$1(value, object) {
+  if (isArray$1(value)) {
     return value;
   }
-  return _isKey(value, object) ? [value] : _stringToPath(toString_1(value));
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
 }
 
-var _castPath = castPath;
+var _castPath = castPath$1;
+
+var isSymbol = isSymbol_1;
 
 /** Used as references for various `Number` constants. */
 var INFINITY = 1 / 0;
@@ -19793,15 +20066,18 @@ var INFINITY = 1 / 0;
  * @param {*} value The value to inspect.
  * @returns {string|symbol} Returns the key.
  */
-function toKey(value) {
-  if (typeof value == 'string' || isSymbol_1(value)) {
+function toKey$1(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
     return value;
   }
   var result = (value + '');
   return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
 }
 
-var _toKey = toKey;
+var _toKey = toKey$1;
+
+var castPath = _castPath,
+    toKey = _toKey;
 
 /**
  * The base implementation of `_.get` without support for default values.
@@ -19811,19 +20087,21 @@ var _toKey = toKey;
  * @param {Array|string} path The path of the property to get.
  * @returns {*} Returns the resolved value.
  */
-function baseGet(object, path) {
-  path = _castPath(path, object);
+function baseGet$1(object, path) {
+  path = castPath(path, object);
 
   var index = 0,
       length = path.length;
 
   while (object != null && index < length) {
-    object = object[_toKey(path[index++])];
+    object = object[toKey(path[index++])];
   }
   return (index && index == length) ? object : undefined;
 }
 
-var _baseGet = baseGet;
+var _baseGet = baseGet$1;
+
+var baseGet = _baseGet;
 
 /**
  * Gets the value at `path` of `object`. If the resolved value is
@@ -19851,7 +20129,7 @@ var _baseGet = baseGet;
  * // => 'default'
  */
 function get(object, path, defaultValue) {
-  var result = object == null ? undefined : _baseGet(object, path);
+  var result = object == null ? undefined : baseGet(object, path);
   return result === undefined ? defaultValue : result;
 }
 
@@ -19865,7 +20143,8 @@ var get_1 = get;
  * @param {Array} [array=[]] The array to copy values to.
  * @returns {Array} Returns `array`.
  */
-function copyArray(source, array) {
+
+function copyArray$1(source, array) {
   var index = -1,
       length = source.length;
 
@@ -19876,9 +20155,10 @@ function copyArray(source, array) {
   return array;
 }
 
-var _copyArray = copyArray;
+var _copyArray = copyArray$1;
 
 /* Built-in method references for those with the same name as other `lodash` methods. */
+
 var nativeFloor = Math.floor,
     nativeRandom = Math.random;
 
@@ -19891,11 +20171,13 @@ var nativeFloor = Math.floor,
  * @param {number} upper The upper bound.
  * @returns {number} Returns the random number.
  */
-function baseRandom(lower, upper) {
+function baseRandom$1(lower, upper) {
   return lower + nativeFloor(nativeRandom() * (upper - lower + 1));
 }
 
-var _baseRandom = baseRandom;
+var _baseRandom = baseRandom$1;
+
+var baseRandom = _baseRandom;
 
 /**
  * A specialized version of `_.shuffle` which mutates and sets the size of `array`.
@@ -19905,14 +20187,14 @@ var _baseRandom = baseRandom;
  * @param {number} [size=array.length] The size of `array`.
  * @returns {Array} Returns `array`.
  */
-function shuffleSelf(array, size) {
+function shuffleSelf$2(array, size) {
   var index = -1,
       length = array.length,
       lastIndex = length - 1;
 
   size = size === undefined ? length : size;
   while (++index < size) {
-    var rand = _baseRandom(index, lastIndex),
+    var rand = baseRandom(index, lastIndex),
         value = array[rand];
 
     array[rand] = array[index];
@@ -19922,7 +20204,10 @@ function shuffleSelf(array, size) {
   return array;
 }
 
-var _shuffleSelf = shuffleSelf;
+var _shuffleSelf = shuffleSelf$2;
+
+var copyArray = _copyArray,
+    shuffleSelf$1 = _shuffleSelf;
 
 /**
  * A specialized version of `_.shuffle` for arrays.
@@ -19931,11 +20216,13 @@ var _shuffleSelf = shuffleSelf;
  * @param {Array} array The array to shuffle.
  * @returns {Array} Returns the new shuffled array.
  */
-function arrayShuffle(array) {
-  return _shuffleSelf(_copyArray(array));
+function arrayShuffle$1(array) {
+  return shuffleSelf$1(copyArray(array));
 }
 
-var _arrayShuffle = arrayShuffle;
+var _arrayShuffle = arrayShuffle$1;
+
+var arrayMap = _arrayMap;
 
 /**
  * The base implementation of `_.values` and `_.valuesIn` which creates an
@@ -19947,13 +20234,16 @@ var _arrayShuffle = arrayShuffle;
  * @param {Array} props The property names to get values for.
  * @returns {Object} Returns the array of property values.
  */
-function baseValues(object, props) {
-  return _arrayMap(props, function(key) {
+function baseValues$1(object, props) {
+  return arrayMap(props, function(key) {
     return object[key];
   });
 }
 
-var _baseValues = baseValues;
+var _baseValues = baseValues$1;
+
+var baseValues = _baseValues,
+    keys = keys_1;
 
 /**
  * Creates an array of the own enumerable string keyed property values of `object`.
@@ -19981,11 +20271,14 @@ var _baseValues = baseValues;
  * _.values('hi');
  * // => ['h', 'i']
  */
-function values(object) {
-  return object == null ? [] : _baseValues(object, keys_1(object));
+function values$1(object) {
+  return object == null ? [] : baseValues(object, keys(object));
 }
 
-var values_1 = values;
+var values_1 = values$1;
+
+var shuffleSelf = _shuffleSelf,
+    values = values_1;
 
 /**
  * The base implementation of `_.shuffle`.
@@ -19994,11 +20287,15 @@ var values_1 = values;
  * @param {Array|Object} collection The collection to shuffle.
  * @returns {Array} Returns the new shuffled array.
  */
-function baseShuffle(collection) {
-  return _shuffleSelf(values_1(collection));
+function baseShuffle$1(collection) {
+  return shuffleSelf(values(collection));
 }
 
-var _baseShuffle = baseShuffle;
+var _baseShuffle = baseShuffle$1;
+
+var arrayShuffle = _arrayShuffle,
+    baseShuffle = _baseShuffle,
+    isArray = isArray_1;
 
 /**
  * Creates an array of shuffled values, using a version of the
@@ -20016,7 +20313,7 @@ var _baseShuffle = baseShuffle;
  * // => [4, 1, 3, 2]
  */
 function shuffle(collection) {
-  var func = isArray_1(collection) ? _arrayShuffle : _baseShuffle;
+  var func = isArray(collection) ? arrayShuffle : baseShuffle;
   return func(collection);
 }
 
@@ -20039,6 +20336,7 @@ var shuffle_1 = shuffle;
  * _.isNull(void 0);
  * // => false
  */
+
 function isNull(value) {
   return value === null;
 }
@@ -20062,6 +20360,7 @@ var isNull_1 = isNull;
  * _.isUndefined(null);
  * // => false
  */
+
 function isUndefined(value) {
   return value === undefined;
 }
@@ -20177,7 +20476,7 @@ const prepareChoice = (model, env, defaultFeedback) => choice => {
     value: choice.value,
   };
 
-  if(model.accessibilityLabelsEnabled){
+  if (model.accessibilityLabelsEnabled) {
     out.accessibility = parseHTML(choice.accessibility).textContent || choice.value;
   }
 
@@ -20208,7 +20507,17 @@ function createDefaultModel(model = {}) {
   return new Promise(resolve => resolve({ ...defaults, ...model }));
 }
 
-const normalize = question => ({ ...defaults, ...question });
+const normalize = question => {
+  const { verticalMode, choicesLayout, ...questionProps } = question || {};
+
+  return {
+    ...defaults,
+    ...questionProps,
+    // This is used for offering support for old models which have the property verticalMode
+    // Same thing is set in authoring : packages/multiple-choice/configure/src/index.jsx - createDefaultModel
+    choicesLayout: choicesLayout || (verticalMode === false && 'horizontal') || defaults.choicesLayout
+  };
+};
 
 /**
  *
@@ -20219,6 +20528,7 @@ const normalize = question => ({ ...defaults, ...question });
  */
 async function model(question, session, env, updateSession) {
   const normalizedQuestion = normalize(question);
+
   const defaultFeedback = Object.assign(
     { correct: 'Correct', incorrect: 'Incorrect' },
     normalizedQuestion.defaultFeedback
@@ -20239,18 +20549,11 @@ async function model(question, session, env, updateSession) {
     );
   }
 
-  // This is used for offering support for old models which have the property verticalMode
-  // Same thing is set in authoring : packages/multiple-choice/configure/src/main.jsx - componentDidMount
-  let layout = '';
-  if(normalizedQuestion.verticalMode !== undefined) {
-    layout = normalizedQuestion.verticalMode === false ? 'horizontal': 'vertical';
-  }
-
   const out = {
     disabled: env.mode !== 'gather',
     mode: env.mode,
     prompt: normalizedQuestion.promptEnabled ? normalizedQuestion.prompt : null,
-    choicesLayout: normalizedQuestion.choicesLayout || layout,
+    choicesLayout: normalizedQuestion.choicesLayout,
     gridColumns: normalizedQuestion.gridColumns,
     choiceMode: normalizedQuestion.choiceMode,
     keyMode: normalizedQuestion.choicePrefix,