https://www.kcl.ac.uk/_GhbZtw_8fe3d6e8-6c75-4fc9-88ef-46b7f2723b06…/modern/js/811.f7447c5f3b6f71adc002.mjs

1(self["__LOADABLE_LOADED_CHUNKS__"] = self["__LOADABLE_LOADED_CHUNKS__"] || []).push([[811],{
2
3/***/ 59449
4(module) {
5
6function arraySome(array, predicate) {
7  var index = -1, length = array == null ? 0 : array.length;
8  while (++index < length) {
9    if (predicate(array[index], index, array)) {
10      return true;
11    }
12  }
13  return false;
14}
15module.exports = arraySome;
16
17
18/***/ },
19
20/***/ 6994
21(module, __unused_webpack_exports, __webpack_require__) {
22
23var baseForOwn = __webpack_require__(80250), createBaseEach = __webpack_require__(25922);
24var baseEach = createBaseEach(baseForOwn);
25module.exports = baseEach;
26
27
28/***/ },
29
30/***/ 74913
31(module, __unused_webpack_exports, __webpack_require__) {
32
33var arrayPush = __webpack_require__(91217), isFlattenable = __webpack_require__(29186);
34function baseFlatten(array, depth, predicate, isStrict, result) {
35  var index = -1, length = array.length;
36  predicate || (predicate = isFlattenable);
37  result || (result = []);
38  while (++index < length) {
39    var value = array[index];
40    if (depth > 0 && predicate(value)) {
41      if (depth > 1) {
42        baseFlatten(value, depth - 1, predicate, isStrict, result);
43      } else {
44        arrayPush(result, value);
45      }
46    } else if (!isStrict) {
47      result[result.length] = value;
48    }
49  }
50  return result;
51}
52module.exports = baseFlatten;
53
54
55/***/ },
56
57/***/ 80250
58(module, __unused_webpack_exports, __webpack_require__) {
59
60var baseFor = __webpack_require__(17948), keys = __webpack_require__(93187);
61function baseForOwn(object, iteratee) {
62  return object && baseFor(object, iteratee, keys);
63}
64module.exports = baseForOwn;
65
66
67/***/ },
68
69/***/ 34556
70(module) {
71
72function baseHasIn(object, key) {
73  return object != null && key in Object(object);
74}
75module.exports = baseHasIn;
76
77
78/***/ },
79
80/***/ 3735
81(module, __unused_webpack_exports, __webpack_require__) {
82
83var baseIsEqualDeep = __webpack_require__(74249), isObjectLike = __webpack_require__(73131);
84function baseIsEqual(value, other, bitmask, customizer, stack) {
85  if (value === other) {
86    return true;
87  }
88  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
89    return value !== value && other !== other;
90  }
91  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
92}
93module.exports = baseIsEqual;
94
95
96/***/ },
97
98/***/ 74249
99(module, __unused_webpack_exports, __webpack_require__) {
100
101var Stack = __webpack_require__(99764), equalArrays = __webpack_require__(18182), equalByTag = __webpack_require__(60325), equalObjects = __webpack_require__(36646), getTag = __webpack_require__(20750), isArray = __webpack_require__(12321), isBuffer = __webpack_require__(13893), isTypedArray = __webpack_require__(40690);
102var COMPARE_PARTIAL_FLAG = 1;
103var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
104var objectProto = Object.prototype;
105var hasOwnProperty = objectProto.hasOwnProperty;
106function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
107  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
108  objTag = objTag == argsTag ? objectTag : objTag;
109  othTag = othTag == argsTag ? objectTag : othTag;
110  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
111  if (isSameTag && isBuffer(object)) {
112    if (!isBuffer(other)) {
113      return false;
114    }
115    objIsArr = true;
116    objIsObj = false;
117  }
118  if (isSameTag && !objIsObj) {
119    stack || (stack = new Stack());
120    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
121  }
122  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
123    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
124    if (objIsWrapped || othIsWrapped) {
125      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
126      stack || (stack = new Stack());
127      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
128    }
129  }
130  if (!isSameTag) {
131    return false;

132  }
133  stack || (stack = new Stack());
134  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
135}
136module.exports = baseIsEqualDeep;
137
138
139/***/ },
140
141/***/ 24290
142(module, __unused_webpack_exports, __webpack_require__) {
143
144var Stack = __webpack_require__(99764), baseIsEqual = __webpack_require__(3735);
145var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
146function baseIsMatch(object, source, matchData, customizer) {
147  var index = matchData.length, length = index, noCustomizer = !customizer;
148  if (object == null) {
149    return !length;
150  }
151  object = Object(object);
152  while (index--) {
153    var data = matchData[index];
154    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
155      return false;
156    }
157  }
158  while (++index < length) {
159    data = matchData[index];
160    var key = data[0], objValue = object[key], srcValue = data[1];
161    if (noCustomizer && data[2]) {
162      if (objValue === void 0 && !(key in object)) {
163        return false;
164      }
165    } else {
166      var stack = new Stack();
167      if (customizer) {
168        var result = customizer(objValue, srcValue, key, object, source, stack);
169      }
170      if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) {
171        return false;
172      }
173    }
174  }
175  return true;
176}
177module.exports = baseIsMatch;
178
179
180/***/ },
181
182/***/ 9214
183(module, __unused_webpack_exports, __webpack_require__) {
184
185var baseMatches = __webpack_require__(28070), baseMatchesProperty = __webpack_require__(56527), identity = __webpack_require__(35501), isArray = __webpack_require__(12321), property = __webpack_require__(22426);
186function baseIteratee(value) {
187  if (typeof value == "function") {
188    return value;
189  }
190  if (value == null) {
191    return identity;
192  }
193  if (typeof value == "object") {
194    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
195  }
196  return property(value);
197}
198module.exports = baseIteratee;
199
200
201/***/ },
202
203/***/ 5977
204(module, __unused_webpack_exports, __webpack_require__) {
205
206var baseEach = __webpack_require__(6994), isArrayLike = __webpack_require__(10969);
207function baseMap(collection, iteratee) {
208  var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
209  baseEach(collection, function(value, key, collection2) {
210    result[++index] = iteratee(value, key, collection2);
211  });
212  return result;
213}
214module.exports = baseMap;
215
216
217/***/ },
218
219/***/ 28070
220(module, __unused_webpack_exports, __webpack_require__) {
221
222var baseIsMatch = __webpack_require__(24290), getMatchData = __webpack_require__(51255), matchesStrictComparable = __webpack_require__(12952);
223function baseMatches(source) {
224  var matchData = getMatchData(source);
225  if (matchData.length == 1 && matchData[0][2]) {
226    return matchesStrictComparable(matchData[0][0], matchData[0][1]);
227  }
228  return function(object) {
229    return object === source || baseIsMatch(object, source, matchData);
230  };
231}
232module.exports = baseMatches;
233
234
235/***/ },
236
237/***/ 56527
238(module, __unused_webpack_exports, __webpack_require__) {
239
240var baseIsEqual = __webpack_require__(3735), get = __webpack_require__(84867), hasIn = __webpack_require__(62804), isKey = __webpack_require__(88555), isStrictComparable = __webpack_require__(12507), matchesStrictComparable = __webpack_require__(12952), toKey = __webpack_require__(72544);
241var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
242function baseMatchesProperty(path, srcValue) {
243  if (isKey(path) && isStrictComparable(srcValue)) {
244    return matchesStrictComparable(toKey(path), srcValue);
245  }
246  return function(object) {
247    var objValue = get(object, path);
248    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
249  };
250}
251module.exports = baseMatchesProperty;
252
253
254/***/ },
255
256/***/ 68318
257(module, __unused_webpack_exports, __webpack_require__) {
258
259var arrayMap = __webpack_require__(29695), baseGet = __webpack_require__(52283), baseIteratee = __webpack_require__(9214), baseMap = __webpack_require__(5977), baseSortBy = __webpack_require__(986), baseUnary = __webpack_require__(61932), compareMultiple = __webpack_require__(92687), identity = __webpack_require__(35501), isArray = __webpack_require__(12321);
260function baseOrderBy(collection, iteratees, orders) {
261  if (iteratees.length) {
262    iteratees = arrayMap(iteratees, function(iteratee) {
263      if (isArray(iteratee)) {
264        return function(value) {
265          return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
266        };
267      }
268      return iteratee;
269    });
270  } else {
271    iteratees = [identity];
272  }
273  var index = -1;
274  iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
275  var result = baseMap(collection, function(value, key, collection2) {
276    var criteria = arrayMap(iteratees, function(iteratee) {
277      return iteratee(value);
278    });
279    return { "criteria": criteria, "index": ++index, "value": value };
280  });
281  return baseSortBy(result, function(object, other) {
282    return compareMultiple(object, other, orders);
283  });
284}
285module.exports = baseOrderBy;
286
287
288/***/ },
289
290/***/ 45224
291(module, __unused_webpack_exports, __webpack_require__) {
292
293var baseGet = __webpack_require__(52283);
294function basePropertyDeep(path) {
295  return function(object) {
296    return baseGet(object, path);
297  };
298}
299module.exports = basePropertyDeep;
300
301
302/***/ },
303
304/***/ 986
305(module) {
306
307function baseSortBy(array, comparer) {
308  var length = array.length;
309  array.sort(comparer);
310  while (length--) {
311    array[length] = array[length].value;
312  }
313  return array;
314}
315module.exports = baseSortBy;
316
317
318/***/ },
319
320/***/ 53529
321(module, __unused_webpack_exports, __webpack_require__) {
322
323var isSymbol = __webpack_require__(79083);
324function compareAscending(value, other) {
325  if (value !== other) {
326    var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
327    var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
328    if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
329      return 1;
330    }
331    if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
332      return -1;
333    }
334  }
335  return 0;
336}
337module.exports = compareAscending;
338
339
340/***/ },
341
342/***/ 92687
343(module, __unused_webpack_exports, __webpack_require__) {
344
345var compareAscending = __webpack_require__(53529);
346function compareMultiple(object, other, orders) {
347  var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
348  while (++index < length) {
349    var result = compareAscending(objCriteria[index], othCriteria[index]);
350    if (result) {
351      if (index >= ordersLength) {
352        return result;
353      }
354      var order = orders[index];
355      return result * (order == "desc" ? -1 : 1);
356    }
357  }
358  return object.index - other.index;
359}
360module.exports = compareMultiple;
361
362
363/***/ },
364
365/***/ 25922
366(module, __unused_webpack_exports, __webpack_require__) {
367
368var isArrayLike = __webpack_require__(10969);
369function createBaseEach(eachFunc, fromRight) {
370  return function(collection, iteratee) {
371    if (collection == null) {
372      return collection;
373    }
374    if (!isArrayLike(collection)) {
375      return eachFunc(collection, iteratee);
376    }
377    var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
378    while (fromRight ? index-- : ++index < length) {
379      if (iteratee(iterable[index], index, iterable) === false) {
380        break;
381      }
382    }
383    return collection;
384  };
385}
386module.exports = createBaseEach;
387
388
389/***/ },
390
391/***/ 18182
392(module, __unused_webpack_exports, __webpack_require__) {
393
394var SetCache = __webpack_require__(33156), arraySome = __webpack_require__(59449), cacheHas = __webpack_require__(59272);
395var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
396function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
397  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, arrLength = array.length, othLength = other.length;
398  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
399    return false;
400  }
401  var arrStacked = stack.get(array);
402  var othStacked = stack.get(other);
403  if (arrStacked && othStacked) {
404    return arrStacked == other && othStacked == array;
405  }
406  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : void 0;
407  stack.set(array, other);
408  stack.set(other, array);
409  while (++index < arrLength) {
410    var arrValue = array[index], othValue = other[index];
411    if (customizer) {
412      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
413    }
414    if (compared !== void 0) {
415      if (compared) {
416        continue;
417      }
418      result = false;
419      break;
420    }
421    if (seen) {
422      if (!arraySome(other, function(othValue2, othIndex) {
423        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
424          return seen.push(othIndex);
425        }
426      })) {
427        result = false;
428        break;
429      }
430    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
431      result = false;
432      break;
433    }
434  }
435  stack["delete"](array);
436  stack["delete"](other);
437  return result;
438}
439module.exports = equalArrays;
440
441
442/***/ },
443
444/***/ 60325
445(module, __unused_webpack_exports, __webpack_require__) {
446
447var Symbol = __webpack_require__(30074), Uint8Array = __webpack_require__(27631), eq = __webpack_require__(15669), equalArrays = __webpack_require__(18182), mapToArray = __webpack_require__(83758), setToArray = __webpack_require__(74220);
448var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
449var boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", mapTag = "[object Map]", numberTag = "[object Number]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]";
450var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]";
451var symbolProto = Symbol ? Symbol.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
452function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
453  switch (tag) {
454    case dataViewTag:
455      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
456        return false;
457      }
458      object = object.buffer;
459      other = other.buffer;
460    case arrayBufferTag:
461      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
462        return false;
463      }
464      return true;
465    case boolTag:
466    case dateTag:
467    case numberTag:
468      return eq(+object, +other);
469    case errorTag:
470      return object.name == other.name && object.message == other.message;
471    case regexpTag:
472    case stringTag:
473      return object == other + "";
474    case mapTag:
475      var convert = mapToArray;
476    case setTag:
477      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
478      convert || (convert = setToArray);
479      if (object.size != other.size && !isPartial) {
480        return false;
481      }
482      var stacked = stack.get(object);
483      if (stacked) {
484        return stacked == other;
485      }
486      bitmask |= COMPARE_UNORDERED_FLAG;
487      stack.set(object, other);
488      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
489      stack["delete"](object);
490      return result;
491    case symbolTag:
492      if (symbolValueOf) {
493        return symbolValueOf.call(object) == symbolValueOf.call(other);
494      }
495  }
496  return false;
497}
498module.exports = equalByTag;
499
500
501/***/ },
502
503/***/ 36646
504(module, __unused_webpack_exports, __webpack_require__) {
505
506var getAllKeys = __webpack_require__(41233);
507var COMPARE_PARTIAL_FLAG = 1;
508var objectProto = Object.prototype;
509var hasOwnProperty = objectProto.hasOwnProperty;
510function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
511  var isPartial = bitmask & COMPARE_PARTIAL_FLAG, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
512  if (objLength != othLength && !isPartial) {
513    return false;
514  }
515  var index = objLength;
516  while (index--) {
517    var key = objProps[index];
518    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
519      return false;
520    }
521  }
522  var objStacked = stack.get(object);
523  var othStacked = stack.get(other);
524  if (objStacked && othStacked) {
525    return objStacked == other && othStacked == object;
526  }
527  var result = true;
528  stack.set(object, other);
529  stack.set(other, object);
530  var skipCtor = isPartial;
531  while (++index < objLength) {
532    key = objProps[index];
533    var objValue = object[key], othValue = other[key];
534    if (customizer) {
535      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
536    }
537    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
538      result = false;