☰

bgm-wiki-rev-diff

显示条目信息版本差异, 可以在 https://github.com/trim21/bgm-tv-userscripts/tree/master/scripts/wiki-rev-diff#readme 查看效果图

  1. // ==UserScript==
  2. // @name                bgm-wiki-rev-diff
  3. // @name:zh             bangumi 显示 条目 wiki 版本差异
  4. // @name:zh-CN          bangumi 显示 条目 wiki 版本差异
  5. // @description         显示条目信息版本差异, 可以在 https://github.com/trim21/bgm-tv-userscripts/tree/master/scripts/wiki-rev-diff#readme 查看效果图
  6. // @description:zh-CN   显示条目信息版本差异, 可以在 https://github.com/trim21/bgm-tv-userscripts/tree/master/scripts/wiki-rev-diff#readme 查看效果图
  7. // @namespace           https://trim21.me/
  8. // @version             0.2.28
  9. // @source              https://github.com/trim21/bgm-tv-userscripts
  10. // @supportURL          https://github.com/trim21/bgm-tv-userscripts/issues
  11. // @license             MIT
  12. // @match               https://bgm.tv/subject/*/edit*
  13. // @match               https://bangumi.tv/subject/*/edit*
  14. // @match               https://chii.in/subject/*/edit*
  15. // @require             https://cdn.jsdelivr.net/npm/jquery@3.7.1/dist/jquery.min.js
  16. // @require             https://cdn.jsdelivr.net/npm/diff2html@3.4.51/bundles/js/diff2html.min.js
  17. // @require             https://cdn.jsdelivr.net/npm/diff@7.0.0/dist/diff.min.js
  18. // @require             https://cdn.jsdelivr.net/npm/lodash@4.17.21/lodash.min.js
  19. // @resource            diff2html https://cdn.jsdelivr.net/npm/diff2html@3.4.51/bundles/css/diff2html.min.css
  20. // @grant               GM.getResourceUrl
  21. // @grant               GM.registerMenuCommand
  22. // @grant               GM.setValue
  23. // @grant               GM.getValue
  24. // @run-at              document-end
  25. // @author              Trim21 <i@trim21.me>
  26. // ==/UserScript==
  27.  
  28. /******/ (() => { // webpackBootstrap
  29. /******/ 	"use strict";
  30.  
  31. ;// external "$"
  32. const external_$_namespaceObject = $;
  33. ;// ./node_modules/lodash-es/_listCacheClear.js
  34. /**
  35.  * Removes all key-value entries from the list cache.
  36.  *
  37.  * @private
  38.  * @name clear
  39.  * @memberOf ListCache
  40.  */
  41. function listCacheClear() {
  42.   this.__data__ = [];
  43.   this.size = 0;
  44. }
  45.  
  46. /* harmony default export */ const _listCacheClear = (listCacheClear);
  47.  
  48. ;// ./node_modules/lodash-es/eq.js
  49. /**
  50.  * Performs a
  51.  * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
  52.  * comparison between two values to determine if they are equivalent.
  53.  *
  54.  * @static
  55.  * @memberOf _
  56.  * @since 4.0.0
  57.  * @category Lang
  58.  * @param {*} value The value to compare.
  59.  * @param {*} other The other value to compare.
  60.  * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
  61.  * @example
  62.  *
  63.  * var object = { 'a': 1 };
  64.  * var other = { 'a': 1 };
  65.  *
  66.  * _.eq(object, object);
  67.  * // => true
  68.  *
  69.  * _.eq(object, other);
  70.  * // => false
  71.  *
  72.  * _.eq('a', 'a');
  73.  * // => true
  74.  *
  75.  * _.eq('a', Object('a'));
  76.  * // => false
  77.  *
  78.  * _.eq(NaN, NaN);
  79.  * // => true
  80.  */
  81. function eq(value, other) {
  82.   return value === other || (value !== value && other !== other);
  83. }
  84.  
  85. /* harmony default export */ const lodash_es_eq = (eq);
  86.  
  87. ;// ./node_modules/lodash-es/_assocIndexOf.js
  88.  
  89.  
  90. /**
  91.  * Gets the index at which the `key` is found in `array` of key-value pairs.
  92.  *
  93.  * @private
  94.  * @param {Array} array The array to inspect.
  95.  * @param {*} key The key to search for.
  96.  * @returns {number} Returns the index of the matched value, else `-1`.
  97.  */
  98. function assocIndexOf(array, key) {
  99.   var length = array.length;
  100.   while (length--) {
  101.     if (lodash_es_eq(array[length][0], key)) {
  102.       return length;
  103.     }
  104.   }
  105.   return -1;
  106. }
  107.  
  108. /* harmony default export */ const _assocIndexOf = (assocIndexOf);
  109.  
  110. ;// ./node_modules/lodash-es/_listCacheDelete.js
  111.  
  112.  
  113. /** Used for built-in method references. */
  114. var arrayProto = Array.prototype;
  115.  
  116. /** Built-in value references. */
  117. var splice = arrayProto.splice;
  118.  
  119. /**
  120.  * Removes `key` and its value from the list cache.
  121.  *
  122.  * @private
  123.  * @name delete
  124.  * @memberOf ListCache
  125.  * @param {string} key The key of the value to remove.
  126.  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  127.  */
  128. function listCacheDelete(key) {
  129.   var data = this.__data__,
  130.       index = _assocIndexOf(data, key);
  131.  
  132.   if (index < 0) {
  133.     return false;
  134.   }
  135.   var lastIndex = data.length - 1;
  136.   if (index == lastIndex) {
  137.     data.pop();
  138.   } else {
  139.     splice.call(data, index, 1);
  140.   }
  141.   --this.size;
  142.   return true;
  143. }
  144.  
  145. /* harmony default export */ const _listCacheDelete = (listCacheDelete);
  146.  
  147. ;// ./node_modules/lodash-es/_listCacheGet.js
  148.  
  149.  
  150. /**
  151.  * Gets the list cache value for `key`.
  152.  *
  153.  * @private
  154.  * @name get
  155.  * @memberOf ListCache
  156.  * @param {string} key The key of the value to get.
  157.  * @returns {*} Returns the entry value.
  158.  */
  159. function listCacheGet(key) {
  160.   var data = this.__data__,
  161.       index = _assocIndexOf(data, key);
  162.  
  163.   return index < 0 ? undefined : data[index][1];
  164. }
  165.  
  166. /* harmony default export */ const _listCacheGet = (listCacheGet);
  167.  
  168. ;// ./node_modules/lodash-es/_listCacheHas.js
  169.  
  170.  
  171. /**
  172.  * Checks if a list cache value for `key` exists.
  173.  *
  174.  * @private
  175.  * @name has
  176.  * @memberOf ListCache
  177.  * @param {string} key The key of the entry to check.
  178.  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  179.  */
  180. function listCacheHas(key) {
  181.   return _assocIndexOf(this.__data__, key) > -1;
  182. }
  183.  
  184. /* harmony default export */ const _listCacheHas = (listCacheHas);
  185.  
  186. ;// ./node_modules/lodash-es/_listCacheSet.js
  187.  
  188.  
  189. /**
  190.  * Sets the list cache `key` to `value`.
  191.  *
  192.  * @private
  193.  * @name set
  194.  * @memberOf ListCache
  195.  * @param {string} key The key of the value to set.
  196.  * @param {*} value The value to set.
  197.  * @returns {Object} Returns the list cache instance.
  198.  */
  199. function listCacheSet(key, value) {
  200.   var data = this.__data__,
  201.       index = _assocIndexOf(data, key);
  202.  
  203.   if (index < 0) {
  204.     ++this.size;
  205.     data.push([key, value]);
  206.   } else {
  207.     data[index][1] = value;
  208.   }
  209.   return this;
  210. }
  211.  
  212. /* harmony default export */ const _listCacheSet = (listCacheSet);
  213.  
  214. ;// ./node_modules/lodash-es/_ListCache.js
  215.  
  216.  
  217.  
  218.  
  219.  
  220.  
  221. /**
  222.  * Creates an list cache object.
  223.  *
  224.  * @private
  225.  * @constructor
  226.  * @param {Array} [entries] The key-value pairs to cache.
  227.  */
  228. function ListCache(entries) {
  229.   var index = -1,
  230.       length = entries == null ? 0 : entries.length;
  231.  
  232.   this.clear();
  233.   while (++index < length) {
  234.     var entry = entries[index];
  235.     this.set(entry[0], entry[1]);
  236.   }
  237. }
  238.  
  239. // Add methods to `ListCache`.
  240. ListCache.prototype.clear = _listCacheClear;
  241. ListCache.prototype['delete'] = _listCacheDelete;
  242. ListCache.prototype.get = _listCacheGet;
  243. ListCache.prototype.has = _listCacheHas;
  244. ListCache.prototype.set = _listCacheSet;
  245.  
  246. /* harmony default export */ const _ListCache = (ListCache);
  247.  
  248. ;// ./node_modules/lodash-es/_stackClear.js
  249.  
  250.  
  251. /**
  252.  * Removes all key-value entries from the stack.
  253.  *
  254.  * @private
  255.  * @name clear
  256.  * @memberOf Stack
  257.  */
  258. function stackClear() {
  259.   this.__data__ = new _ListCache;
  260.   this.size = 0;
  261. }
  262.  
  263. /* harmony default export */ const _stackClear = (stackClear);
  264.  
  265. ;// ./node_modules/lodash-es/_stackDelete.js
  266. /**
  267.  * Removes `key` and its value from the stack.
  268.  *
  269.  * @private
  270.  * @name delete
  271.  * @memberOf Stack
  272.  * @param {string} key The key of the value to remove.
  273.  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  274.  */
  275. function stackDelete(key) {
  276.   var data = this.__data__,
  277.       result = data['delete'](key);
  278.  
  279.   this.size = data.size;
  280.   return result;
  281. }
  282.  
  283. /* harmony default export */ const _stackDelete = (stackDelete);
  284.  
  285. ;// ./node_modules/lodash-es/_stackGet.js
  286. /**
  287.  * Gets the stack value for `key`.
  288.  *
  289.  * @private
  290.  * @name get
  291.  * @memberOf Stack
  292.  * @param {string} key The key of the value to get.
  293.  * @returns {*} Returns the entry value.
  294.  */
  295. function stackGet(key) {
  296.   return this.__data__.get(key);
  297. }
  298.  
  299. /* harmony default export */ const _stackGet = (stackGet);
  300.  
  301. ;// ./node_modules/lodash-es/_stackHas.js
  302. /**
  303.  * Checks if a stack value for `key` exists.
  304.  *
  305.  * @private
  306.  * @name has
  307.  * @memberOf Stack
  308.  * @param {string} key The key of the entry to check.
  309.  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  310.  */
  311. function stackHas(key) {
  312.   return this.__data__.has(key);
  313. }
  314.  
  315. /* harmony default export */ const _stackHas = (stackHas);
  316.  
  317. ;// ./node_modules/lodash-es/_freeGlobal.js
  318. /** Detect free variable `global` from Node.js. */
  319. var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  320.  
  321. /* harmony default export */ const _freeGlobal = (freeGlobal);
  322.  
  323. ;// ./node_modules/lodash-es/_root.js
  324.  
  325.  
  326. /** Detect free variable `self`. */
  327. var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  328.  
  329. /** Used as a reference to the global object. */
  330. var root = _freeGlobal || freeSelf || Function('return this')();
  331.  
  332. /* harmony default export */ const _root = (root);
  333.  
  334. ;// ./node_modules/lodash-es/_Symbol.js
  335.  
  336.  
  337. /** Built-in value references. */
  338. var _Symbol_Symbol = _root.Symbol;
  339.  
  340. /* harmony default export */ const _Symbol = (_Symbol_Symbol);
  341.  
  342. ;// ./node_modules/lodash-es/_getRawTag.js
  343.  
  344.  
  345. /** Used for built-in method references. */
  346. var objectProto = Object.prototype;
  347.  
  348. /** Used to check objects for own properties. */
  349. var _getRawTag_hasOwnProperty = objectProto.hasOwnProperty;
  350.  
  351. /**
  352.  * Used to resolve the
  353.  * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  354.  * of values.
  355.  */
  356. var nativeObjectToString = objectProto.toString;
  357.  
  358. /** Built-in value references. */
  359. var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
  360.  
  361. /**
  362.  * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
  363.  *
  364.  * @private
  365.  * @param {*} value The value to query.
  366.  * @returns {string} Returns the raw `toStringTag`.
  367.  */
  368. function getRawTag(value) {
  369.   var isOwn = _getRawTag_hasOwnProperty.call(value, symToStringTag),
  370.       tag = value[symToStringTag];
  371.  
  372.   try {
  373.     value[symToStringTag] = undefined;
  374.     var unmasked = true;
  375.   } catch (e) {}
  376.  
  377.   var result = nativeObjectToString.call(value);
  378.   if (unmasked) {
  379.     if (isOwn) {
  380.       value[symToStringTag] = tag;
  381.     } else {
  382.       delete value[symToStringTag];
  383.     }
  384.   }
  385.   return result;
  386. }
  387.  
  388. /* harmony default export */ const _getRawTag = (getRawTag);
  389.  
  390. ;// ./node_modules/lodash-es/_objectToString.js
  391. /** Used for built-in method references. */
  392. var _objectToString_objectProto = Object.prototype;
  393.  
  394. /**
  395.  * Used to resolve the
  396.  * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
  397.  * of values.
  398.  */
  399. var _objectToString_nativeObjectToString = _objectToString_objectProto.toString;
  400.  
  401. /**
  402.  * Converts `value` to a string using `Object.prototype.toString`.
  403.  *
  404.  * @private
  405.  * @param {*} value The value to convert.
  406.  * @returns {string} Returns the converted string.
  407.  */
  408. function objectToString(value) {
  409.   return _objectToString_nativeObjectToString.call(value);
  410. }
  411.  
  412. /* harmony default export */ const _objectToString = (objectToString);
  413.  
  414. ;// ./node_modules/lodash-es/_baseGetTag.js
  415.  
  416.  
  417.  
  418.  
  419. /** `Object#toString` result references. */
  420. var nullTag = '[object Null]',
  421.     undefinedTag = '[object Undefined]';
  422.  
  423. /** Built-in value references. */
  424. var _baseGetTag_symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
  425.  
  426. /**
  427.  * The base implementation of `getTag` without fallbacks for buggy environments.
  428.  *
  429.  * @private
  430.  * @param {*} value The value to query.
  431.  * @returns {string} Returns the `toStringTag`.
  432.  */
  433. function baseGetTag(value) {
  434.   if (value == null) {
  435.     return value === undefined ? undefinedTag : nullTag;
  436.   }
  437.   return (_baseGetTag_symToStringTag && _baseGetTag_symToStringTag in Object(value))
  438.     ? _getRawTag(value)
  439.     : _objectToString(value);
  440. }
  441.  
  442. /* harmony default export */ const _baseGetTag = (baseGetTag);
  443.  
  444. ;// ./node_modules/lodash-es/isObject.js
  445. /**
  446.  * Checks if `value` is the
  447.  * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
  448.  * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
  449.  *
  450.  * @static
  451.  * @memberOf _
  452.  * @since 0.1.0
  453.  * @category Lang
  454.  * @param {*} value The value to check.
  455.  * @returns {boolean} Returns `true` if `value` is an object, else `false`.
  456.  * @example
  457.  *
  458.  * _.isObject({});
  459.  * // => true
  460.  *
  461.  * _.isObject([1, 2, 3]);
  462.  * // => true
  463.  *
  464.  * _.isObject(_.noop);
  465.  * // => true
  466.  *
  467.  * _.isObject(null);
  468.  * // => false
  469.  */
  470. function isObject(value) {
  471.   var type = typeof value;
  472.   return value != null && (type == 'object' || type == 'function');
  473. }
  474.  
  475. /* harmony default export */ const lodash_es_isObject = (isObject);
  476.  
  477. ;// ./node_modules/lodash-es/isFunction.js
  478.  
  479.  
  480.  
  481. /** `Object#toString` result references. */
  482. var asyncTag = '[object AsyncFunction]',
  483.     funcTag = '[object Function]',
  484.     genTag = '[object GeneratorFunction]',
  485.     proxyTag = '[object Proxy]';
  486.  
  487. /**
  488.  * Checks if `value` is classified as a `Function` object.
  489.  *
  490.  * @static
  491.  * @memberOf _
  492.  * @since 0.1.0
  493.  * @category Lang
  494.  * @param {*} value The value to check.
  495.  * @returns {boolean} Returns `true` if `value` is a function, else `false`.
  496.  * @example
  497.  *
  498.  * _.isFunction(_);
  499.  * // => true
  500.  *
  501.  * _.isFunction(/abc/);
  502.  * // => false
  503.  */
  504. function isFunction(value) {
  505.   if (!lodash_es_isObject(value)) {
  506.     return false;
  507.   }
  508.   // The use of `Object#toString` avoids issues with the `typeof` operator
  509.   // in Safari 9 which returns 'object' for typed arrays and other constructors.
  510.   var tag = _baseGetTag(value);
  511.   return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
  512. }
  513.  
  514. /* harmony default export */ const lodash_es_isFunction = (isFunction);
  515.  
  516. ;// ./node_modules/lodash-es/_coreJsData.js
  517.  
  518.  
  519. /** Used to detect overreaching core-js shims. */
  520. var coreJsData = _root['__core-js_shared__'];
  521.  
  522. /* harmony default export */ const _coreJsData = (coreJsData);
  523.  
  524. ;// ./node_modules/lodash-es/_isMasked.js
  525.  
  526.  
  527. /** Used to detect methods masquerading as native. */
  528. var maskSrcKey = (function() {
  529.   var uid = /[^.]+$/.exec(_coreJsData && _coreJsData.keys && _coreJsData.keys.IE_PROTO || '');
  530.   return uid ? ('Symbol(src)_1.' + uid) : '';
  531. }());
  532.  
  533. /**
  534.  * Checks if `func` has its source masked.
  535.  *
  536.  * @private
  537.  * @param {Function} func The function to check.
  538.  * @returns {boolean} Returns `true` if `func` is masked, else `false`.
  539.  */
  540. function isMasked(func) {
  541.   return !!maskSrcKey && (maskSrcKey in func);
  542. }
  543.  
  544. /* harmony default export */ const _isMasked = (isMasked);
  545.  
  546. ;// ./node_modules/lodash-es/_toSource.js
  547. /** Used for built-in method references. */
  548. var funcProto = Function.prototype;
  549.  
  550. /** Used to resolve the decompiled source of functions. */
  551. var funcToString = funcProto.toString;
  552.  
  553. /**
  554.  * Converts `func` to its source code.
  555.  *
  556.  * @private
  557.  * @param {Function} func The function to convert.
  558.  * @returns {string} Returns the source code.
  559.  */
  560. function toSource(func) {
  561.   if (func != null) {
  562.     try {
  563.       return funcToString.call(func);
  564.     } catch (e) {}
  565.     try {
  566.       return (func + '');
  567.     } catch (e) {}
  568.   }
  569.   return '';
  570. }
  571.  
  572. /* harmony default export */ const _toSource = (toSource);
  573.  
  574. ;// ./node_modules/lodash-es/_baseIsNative.js
  575.  
  576.  
  577.  
  578.  
  579.  
  580. /**
  581.  * Used to match `RegExp`
  582.  * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
  583.  */
  584. var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  585.  
  586. /** Used to detect host constructors (Safari). */
  587. var reIsHostCtor = /^\[object .+?Constructor\]$/;
  588.  
  589. /** Used for built-in method references. */
  590. var _baseIsNative_funcProto = Function.prototype,
  591.     _baseIsNative_objectProto = Object.prototype;
  592.  
  593. /** Used to resolve the decompiled source of functions. */
  594. var _baseIsNative_funcToString = _baseIsNative_funcProto.toString;
  595.  
  596. /** Used to check objects for own properties. */
  597. var _baseIsNative_hasOwnProperty = _baseIsNative_objectProto.hasOwnProperty;
  598.  
  599. /** Used to detect if a method is native. */
  600. var reIsNative = RegExp('^' +
  601.   _baseIsNative_funcToString.call(_baseIsNative_hasOwnProperty).replace(reRegExpChar, '\\$&')
  602.   .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
  603. );
  604.  
  605. /**
  606.  * The base implementation of `_.isNative` without bad shim checks.
  607.  *
  608.  * @private
  609.  * @param {*} value The value to check.
  610.  * @returns {boolean} Returns `true` if `value` is a native function,
  611.  *  else `false`.
  612.  */
  613. function baseIsNative(value) {
  614.   if (!lodash_es_isObject(value) || _isMasked(value)) {
  615.     return false;
  616.   }
  617.   var pattern = lodash_es_isFunction(value) ? reIsNative : reIsHostCtor;
  618.   return pattern.test(_toSource(value));
  619. }
  620.  
  621. /* harmony default export */ const _baseIsNative = (baseIsNative);
  622.  
  623. ;// ./node_modules/lodash-es/_getValue.js
  624. /**
  625.  * Gets the value at `key` of `object`.
  626.  *
  627.  * @private
  628.  * @param {Object} [object] The object to query.
  629.  * @param {string} key The key of the property to get.
  630.  * @returns {*} Returns the property value.
  631.  */
  632. function getValue(object, key) {
  633.   return object == null ? undefined : object[key];
  634. }
  635.  
  636. /* harmony default export */ const _getValue = (getValue);
  637.  
  638. ;// ./node_modules/lodash-es/_getNative.js
  639.  
  640.  
  641.  
  642. /**
  643.  * Gets the native function at `key` of `object`.
  644.  *
  645.  * @private
  646.  * @param {Object} object The object to query.
  647.  * @param {string} key The key of the method to get.
  648.  * @returns {*} Returns the function if it's native, else `undefined`.
  649.  */
  650. function getNative(object, key) {
  651.   var value = _getValue(object, key);
  652.   return _baseIsNative(value) ? value : undefined;
  653. }
  654.  
  655. /* harmony default export */ const _getNative = (getNative);
  656.  
  657. ;// ./node_modules/lodash-es/_Map.js
  658.  
  659.  
  660.  
  661. /* Built-in method references that are verified to be native. */
  662. var Map = _getNative(_root, 'Map');
  663.  
  664. /* harmony default export */ const _Map = (Map);
  665.  
  666. ;// ./node_modules/lodash-es/_nativeCreate.js
  667.  
  668.  
  669. /* Built-in method references that are verified to be native. */
  670. var nativeCreate = _getNative(Object, 'create');
  671.  
  672. /* harmony default export */ const _nativeCreate = (nativeCreate);
  673.  
  674. ;// ./node_modules/lodash-es/_hashClear.js
  675.  
  676.  
  677. /**
  678.  * Removes all key-value entries from the hash.
  679.  *
  680.  * @private
  681.  * @name clear
  682.  * @memberOf Hash
  683.  */
  684. function hashClear() {
  685.   this.__data__ = _nativeCreate ? _nativeCreate(null) : {};
  686.   this.size = 0;
  687. }
  688.  
  689. /* harmony default export */ const _hashClear = (hashClear);
  690.  
  691. ;// ./node_modules/lodash-es/_hashDelete.js
  692. /**
  693.  * Removes `key` and its value from the hash.
  694.  *
  695.  * @private
  696.  * @name delete
  697.  * @memberOf Hash
  698.  * @param {Object} hash The hash to modify.
  699.  * @param {string} key The key of the value to remove.
  700.  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  701.  */
  702. function hashDelete(key) {
  703.   var result = this.has(key) && delete this.__data__[key];
  704.   this.size -= result ? 1 : 0;
  705.   return result;
  706. }
  707.  
  708. /* harmony default export */ const _hashDelete = (hashDelete);
  709.  
  710. ;// ./node_modules/lodash-es/_hashGet.js
  711.  
  712.  
  713. /** Used to stand-in for `undefined` hash values. */
  714. var HASH_UNDEFINED = '__lodash_hash_undefined__';
  715.  
  716. /** Used for built-in method references. */
  717. var _hashGet_objectProto = Object.prototype;
  718.  
  719. /** Used to check objects for own properties. */
  720. var _hashGet_hasOwnProperty = _hashGet_objectProto.hasOwnProperty;
  721.  
  722. /**
  723.  * Gets the hash value for `key`.
  724.  *
  725.  * @private
  726.  * @name get
  727.  * @memberOf Hash
  728.  * @param {string} key The key of the value to get.
  729.  * @returns {*} Returns the entry value.
  730.  */
  731. function hashGet(key) {
  732.   var data = this.__data__;
  733.   if (_nativeCreate) {
  734.     var result = data[key];
  735.     return result === HASH_UNDEFINED ? undefined : result;
  736.   }
  737.   return _hashGet_hasOwnProperty.call(data, key) ? data[key] : undefined;
  738. }
  739.  
  740. /* harmony default export */ const _hashGet = (hashGet);
  741.  
  742. ;// ./node_modules/lodash-es/_hashHas.js
  743.  
  744.  
  745. /** Used for built-in method references. */
  746. var _hashHas_objectProto = Object.prototype;
  747.  
  748. /** Used to check objects for own properties. */
  749. var _hashHas_hasOwnProperty = _hashHas_objectProto.hasOwnProperty;
  750.  
  751. /**
  752.  * Checks if a hash value for `key` exists.
  753.  *
  754.  * @private
  755.  * @name has
  756.  * @memberOf Hash
  757.  * @param {string} key The key of the entry to check.
  758.  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  759.  */
  760. function hashHas(key) {
  761.   var data = this.__data__;
  762.   return _nativeCreate ? (data[key] !== undefined) : _hashHas_hasOwnProperty.call(data, key);
  763. }
  764.  
  765. /* harmony default export */ const _hashHas = (hashHas);
  766.  
  767. ;// ./node_modules/lodash-es/_hashSet.js
  768.  
  769.  
  770. /** Used to stand-in for `undefined` hash values. */
  771. var _hashSet_HASH_UNDEFINED = '__lodash_hash_undefined__';
  772.  
  773. /**
  774.  * Sets the hash `key` to `value`.
  775.  *
  776.  * @private
  777.  * @name set
  778.  * @memberOf Hash
  779.  * @param {string} key The key of the value to set.
  780.  * @param {*} value The value to set.
  781.  * @returns {Object} Returns the hash instance.
  782.  */
  783. function hashSet(key, value) {
  784.   var data = this.__data__;
  785.   this.size += this.has(key) ? 0 : 1;
  786.   data[key] = (_nativeCreate && value === undefined) ? _hashSet_HASH_UNDEFINED : value;
  787.   return this;
  788. }
  789.  
  790. /* harmony default export */ const _hashSet = (hashSet);
  791.  
  792. ;// ./node_modules/lodash-es/_Hash.js
  793.  
  794.  
  795.  
  796.  
  797.  
  798.  
  799. /**
  800.  * Creates a hash object.
  801.  *
  802.  * @private
  803.  * @constructor
  804.  * @param {Array} [entries] The key-value pairs to cache.
  805.  */
  806. function Hash(entries) {
  807.   var index = -1,
  808.       length = entries == null ? 0 : entries.length;
  809.  
  810.   this.clear();
  811.   while (++index < length) {
  812.     var entry = entries[index];
  813.     this.set(entry[0], entry[1]);
  814.   }
  815. }
  816.  
  817. // Add methods to `Hash`.
  818. Hash.prototype.clear = _hashClear;
  819. Hash.prototype['delete'] = _hashDelete;
  820. Hash.prototype.get = _hashGet;
  821. Hash.prototype.has = _hashHas;
  822. Hash.prototype.set = _hashSet;
  823.  
  824. /* harmony default export */ const _Hash = (Hash);
  825.  
  826. ;// ./node_modules/lodash-es/_mapCacheClear.js
  827.  
  828.  
  829.  
  830.  
  831. /**
  832.  * Removes all key-value entries from the map.
  833.  *
  834.  * @private
  835.  * @name clear
  836.  * @memberOf MapCache
  837.  */
  838. function mapCacheClear() {
  839.   this.size = 0;
  840.   this.__data__ = {
  841.     'hash': new _Hash,
  842.     'map': new (_Map || _ListCache),
  843.     'string': new _Hash
  844.   };
  845. }
  846.  
  847. /* harmony default export */ const _mapCacheClear = (mapCacheClear);
  848.  
  849. ;// ./node_modules/lodash-es/_isKeyable.js
  850. /**
  851.  * Checks if `value` is suitable for use as unique object key.
  852.  *
  853.  * @private
  854.  * @param {*} value The value to check.
  855.  * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
  856.  */
  857. function isKeyable(value) {
  858.   var type = typeof value;
  859.   return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
  860.     ? (value !== '__proto__')
  861.     : (value === null);
  862. }
  863.  
  864. /* harmony default export */ const _isKeyable = (isKeyable);
  865.  
  866. ;// ./node_modules/lodash-es/_getMapData.js
  867.  
  868.  
  869. /**
  870.  * Gets the data for `map`.
  871.  *
  872.  * @private
  873.  * @param {Object} map The map to query.
  874.  * @param {string} key The reference key.
  875.  * @returns {*} Returns the map data.
  876.  */
  877. function getMapData(map, key) {
  878.   var data = map.__data__;
  879.   return _isKeyable(key)
  880.     ? data[typeof key == 'string' ? 'string' : 'hash']
  881.     : data.map;
  882. }
  883.  
  884. /* harmony default export */ const _getMapData = (getMapData);
  885.  
  886. ;// ./node_modules/lodash-es/_mapCacheDelete.js
  887.  
  888.  
  889. /**
  890.  * Removes `key` and its value from the map.
  891.  *
  892.  * @private
  893.  * @name delete
  894.  * @memberOf MapCache
  895.  * @param {string} key The key of the value to remove.
  896.  * @returns {boolean} Returns `true` if the entry was removed, else `false`.
  897.  */
  898. function mapCacheDelete(key) {
  899.   var result = _getMapData(this, key)['delete'](key);
  900.   this.size -= result ? 1 : 0;
  901.   return result;
  902. }
  903.  
  904. /* harmony default export */ const _mapCacheDelete = (mapCacheDelete);
  905.  
  906. ;// ./node_modules/lodash-es/_mapCacheGet.js
  907.  
  908.  
  909. /**
  910.  * Gets the map value for `key`.
  911.  *
  912.  * @private
  913.  * @name get
  914.  * @memberOf MapCache
  915.  * @param {string} key The key of the value to get.
  916.  * @returns {*} Returns the entry value.
  917.  */
  918. function mapCacheGet(key) {
  919.   return _getMapData(this, key).get(key);
  920. }
  921.  
  922. /* harmony default export */ const _mapCacheGet = (mapCacheGet);
  923.  
  924. ;// ./node_modules/lodash-es/_mapCacheHas.js
  925.  
  926.  
  927. /**
  928.  * Checks if a map value for `key` exists.
  929.  *
  930.  * @private
  931.  * @name has
  932.  * @memberOf MapCache
  933.  * @param {string} key The key of the entry to check.
  934.  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  935.  */
  936. function mapCacheHas(key) {
  937.   return _getMapData(this, key).has(key);
  938. }
  939.  
  940. /* harmony default export */ const _mapCacheHas = (mapCacheHas);
  941.  
  942. ;// ./node_modules/lodash-es/_mapCacheSet.js
  943.  
  944.  
  945. /**
  946.  * Sets the map `key` to `value`.
  947.  *
  948.  * @private
  949.  * @name set
  950.  * @memberOf MapCache
  951.  * @param {string} key The key of the value to set.
  952.  * @param {*} value The value to set.
  953.  * @returns {Object} Returns the map cache instance.
  954.  */
  955. function mapCacheSet(key, value) {
  956.   var data = _getMapData(this, key),
  957.       size = data.size;
  958.  
  959.   data.set(key, value);
  960.   this.size += data.size == size ? 0 : 1;
  961.   return this;
  962. }
  963.  
  964. /* harmony default export */ const _mapCacheSet = (mapCacheSet);
  965.  
  966. ;// ./node_modules/lodash-es/_MapCache.js
  967.  
  968.  
  969.  
  970.  
  971.  
  972.  
  973. /**
  974.  * Creates a map cache object to store key-value pairs.
  975.  *
  976.  * @private
  977.  * @constructor
  978.  * @param {Array} [entries] The key-value pairs to cache.
  979.  */
  980. function MapCache(entries) {
  981.   var index = -1,
  982.       length = entries == null ? 0 : entries.length;
  983.  
  984.   this.clear();
  985.   while (++index < length) {
  986.     var entry = entries[index];
  987.     this.set(entry[0], entry[1]);
  988.   }
  989. }
  990.  
  991. // Add methods to `MapCache`.
  992. MapCache.prototype.clear = _mapCacheClear;
  993. MapCache.prototype['delete'] = _mapCacheDelete;
  994. MapCache.prototype.get = _mapCacheGet;
  995. MapCache.prototype.has = _mapCacheHas;
  996. MapCache.prototype.set = _mapCacheSet;
  997.  
  998. /* harmony default export */ const _MapCache = (MapCache);
  999.  
  1000. ;// ./node_modules/lodash-es/_stackSet.js
  1001.  
  1002.  
  1003.  
  1004.  
  1005. /** Used as the size to enable large array optimizations. */
  1006. var LARGE_ARRAY_SIZE = 200;
  1007.  
  1008. /**
  1009.  * Sets the stack `key` to `value`.
  1010.  *
  1011.  * @private
  1012.  * @name set
  1013.  * @memberOf Stack
  1014.  * @param {string} key The key of the value to set.
  1015.  * @param {*} value The value to set.
  1016.  * @returns {Object} Returns the stack cache instance.
  1017.  */
  1018. function stackSet(key, value) {
  1019.   var data = this.__data__;
  1020.   if (data instanceof _ListCache) {
  1021.     var pairs = data.__data__;
  1022.     if (!_Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
  1023.       pairs.push([key, value]);
  1024.       this.size = ++data.size;
  1025.       return this;
  1026.     }
  1027.     data = this.__data__ = new _MapCache(pairs);
  1028.   }
  1029.   data.set(key, value);
  1030.   this.size = data.size;
  1031.   return this;
  1032. }
  1033.  
  1034. /* harmony default export */ const _stackSet = (stackSet);
  1035.  
  1036. ;// ./node_modules/lodash-es/_Stack.js
  1037.  
  1038.  
  1039.  
  1040.  
  1041.  
  1042.  
  1043.  
  1044. /**
  1045.  * Creates a stack cache object to store key-value pairs.
  1046.  *
  1047.  * @private
  1048.  * @constructor
  1049.  * @param {Array} [entries] The key-value pairs to cache.
  1050.  */
  1051. function Stack(entries) {
  1052.   var data = this.__data__ = new _ListCache(entries);
  1053.   this.size = data.size;
  1054. }
  1055.  
  1056. // Add methods to `Stack`.
  1057. Stack.prototype.clear = _stackClear;
  1058. Stack.prototype['delete'] = _stackDelete;
  1059. Stack.prototype.get = _stackGet;
  1060. Stack.prototype.has = _stackHas;
  1061. Stack.prototype.set = _stackSet;
  1062.  
  1063. /* harmony default export */ const _Stack = (Stack);
  1064.  
  1065. ;// ./node_modules/lodash-es/_setCacheAdd.js
  1066. /** Used to stand-in for `undefined` hash values. */
  1067. var _setCacheAdd_HASH_UNDEFINED = '__lodash_hash_undefined__';
  1068.  
  1069. /**
  1070.  * Adds `value` to the array cache.
  1071.  *
  1072.  * @private
  1073.  * @name add
  1074.  * @memberOf SetCache
  1075.  * @alias push
  1076.  * @param {*} value The value to cache.
  1077.  * @returns {Object} Returns the cache instance.
  1078.  */
  1079. function setCacheAdd(value) {
  1080.   this.__data__.set(value, _setCacheAdd_HASH_UNDEFINED);
  1081.   return this;
  1082. }
  1083.  
  1084. /* harmony default export */ const _setCacheAdd = (setCacheAdd);
  1085.  
  1086. ;// ./node_modules/lodash-es/_setCacheHas.js
  1087. /**
  1088.  * Checks if `value` is in the array cache.
  1089.  *
  1090.  * @private
  1091.  * @name has
  1092.  * @memberOf SetCache
  1093.  * @param {*} value The value to search for.
  1094.  * @returns {number} Returns `true` if `value` is found, else `false`.
  1095.  */
  1096. function setCacheHas(value) {
  1097.   return this.__data__.has(value);
  1098. }
  1099.  
  1100. /* harmony default export */ const _setCacheHas = (setCacheHas);
  1101.  
  1102. ;// ./node_modules/lodash-es/_SetCache.js
  1103.  
  1104.  
  1105.  
  1106.  
  1107. /**
  1108.  *
  1109.  * Creates an array cache object to store unique values.
  1110.  *
  1111.  * @private
  1112.  * @constructor
  1113.  * @param {Array} [values] The values to cache.
  1114.  */
  1115. function SetCache(values) {
  1116.   var index = -1,
  1117.       length = values == null ? 0 : values.length;
  1118.  
  1119.   this.__data__ = new _MapCache;
  1120.   while (++index < length) {
  1121.     this.add(values[index]);
  1122.   }
  1123. }
  1124.  
  1125. // Add methods to `SetCache`.
  1126. SetCache.prototype.add = SetCache.prototype.push = _setCacheAdd;
  1127. SetCache.prototype.has = _setCacheHas;
  1128.  
  1129. /* harmony default export */ const _SetCache = (SetCache);
  1130.  
  1131. ;// ./node_modules/lodash-es/_arraySome.js
  1132. /**
  1133.  * A specialized version of `_.some` for arrays without support for iteratee
  1134.  * shorthands.
  1135.  *
  1136.  * @private
  1137.  * @param {Array} [array] The array to iterate over.
  1138.  * @param {Function} predicate The function invoked per iteration.
  1139.  * @returns {boolean} Returns `true` if any element passes the predicate check,
  1140.  *  else `false`.
  1141.  */
  1142. function arraySome(array, predicate) {
  1143.   var index = -1,
  1144.       length = array == null ? 0 : array.length;
  1145.  
  1146.   while (++index < length) {
  1147.     if (predicate(array[index], index, array)) {
  1148.       return true;
  1149.     }
  1150.   }
  1151.   return false;
  1152. }
  1153.  
  1154. /* harmony default export */ const _arraySome = (arraySome);
  1155.  
  1156. ;// ./node_modules/lodash-es/_cacheHas.js
  1157. /**
  1158.  * Checks if a `cache` value for `key` exists.
  1159.  *
  1160.  * @private
  1161.  * @param {Object} cache The cache to query.
  1162.  * @param {string} key The key of the entry to check.
  1163.  * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
  1164.  */
  1165. function cacheHas(cache, key) {
  1166.   return cache.has(key);
  1167. }
  1168.  
  1169. /* harmony default export */ const _cacheHas = (cacheHas);
  1170.  
  1171. ;// ./node_modules/lodash-es/_equalArrays.js
  1172.  
  1173.  
  1174.  
  1175.  
  1176. /** Used to compose bitmasks for value comparisons. */
  1177. var COMPARE_PARTIAL_FLAG = 1,
  1178.     COMPARE_UNORDERED_FLAG = 2;
  1179.  
  1180. /**
  1181.  * A specialized version of `baseIsEqualDeep` for arrays with support for
  1182.  * partial deep comparisons.
  1183.  *
  1184.  * @private
  1185.  * @param {Array} array The array to compare.
  1186.  * @param {Array} other The other array to compare.
  1187.  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  1188.  * @param {Function} customizer The function to customize comparisons.
  1189.  * @param {Function} equalFunc The function to determine equivalents of values.
  1190.  * @param {Object} stack Tracks traversed `array` and `other` objects.
  1191.  * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
  1192.  */
  1193. function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
  1194.   var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
  1195.       arrLength = array.length,
  1196.       othLength = other.length;
  1197.  
  1198.   if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
  1199.     return false;
  1200.   }
  1201.   // Check that cyclic values are equal.
  1202.   var arrStacked = stack.get(array);
  1203.   var othStacked = stack.get(other);
  1204.   if (arrStacked && othStacked) {
  1205.     return arrStacked == other && othStacked == array;
  1206.   }
  1207.   var index = -1,
  1208.       result = true,
  1209.       seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new _SetCache : undefined;
  1210.  
  1211.   stack.set(array, other);
  1212.   stack.set(other, array);
  1213.  
  1214.   // Ignore non-index properties.
  1215.   while (++index < arrLength) {
  1216.     var arrValue = array[index],
  1217.         othValue = other[index];
  1218.  
  1219.     if (customizer) {
  1220.       var compared = isPartial
  1221.         ? customizer(othValue, arrValue, index, other, array, stack)
  1222.         : customizer(arrValue, othValue, index, array, other, stack);
  1223.     }
  1224.     if (compared !== undefined) {
  1225.       if (compared) {
  1226.         continue;
  1227.       }
  1228.       result = false;
  1229.       break;
  1230.     }
  1231.     // Recursively compare arrays (susceptible to call stack limits).
  1232.     if (seen) {
  1233.       if (!_arraySome(other, function(othValue, othIndex) {
  1234.             if (!_cacheHas(seen, othIndex) &&
  1235.                 (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
  1236.               return seen.push(othIndex);
  1237.             }
  1238.           })) {
  1239.         result = false;
  1240.         break;
  1241.       }
  1242.     } else if (!(
  1243.           arrValue === othValue ||
  1244.             equalFunc(arrValue, othValue, bitmask, customizer, stack)
  1245.         )) {
  1246.       result = false;
  1247.       break;
  1248.     }
  1249.   }
  1250.   stack['delete'](array);
  1251.   stack['delete'](other);
  1252.   return result;
  1253. }
  1254.  
  1255. /* harmony default export */ const _equalArrays = (equalArrays);
  1256.  
  1257. ;// ./node_modules/lodash-es/_Uint8Array.js
  1258.  
  1259.  
  1260. /** Built-in value references. */
  1261. var Uint8Array = _root.Uint8Array;
  1262.  
  1263. /* harmony default export */ const _Uint8Array = (Uint8Array);
  1264.  
  1265. ;// ./node_modules/lodash-es/_mapToArray.js
  1266. /**
  1267.  * Converts `map` to its key-value pairs.
  1268.  *
  1269.  * @private
  1270.  * @param {Object} map The map to convert.
  1271.  * @returns {Array} Returns the key-value pairs.
  1272.  */
  1273. function mapToArray(map) {
  1274.   var index = -1,
  1275.       result = Array(map.size);
  1276.  
  1277.   map.forEach(function(value, key) {
  1278.     result[++index] = [key, value];
  1279.   });
  1280.   return result;
  1281. }
  1282.  
  1283. /* harmony default export */ const _mapToArray = (mapToArray);
  1284.  
  1285. ;// ./node_modules/lodash-es/_setToArray.js
  1286. /**
  1287.  * Converts `set` to an array of its values.
  1288.  *
  1289.  * @private
  1290.  * @param {Object} set The set to convert.
  1291.  * @returns {Array} Returns the values.
  1292.  */
  1293. function setToArray(set) {
  1294.   var index = -1,
  1295.       result = Array(set.size);
  1296.  
  1297.   set.forEach(function(value) {
  1298.     result[++index] = value;
  1299.   });
  1300.   return result;
  1301. }
  1302.  
  1303. /* harmony default export */ const _setToArray = (setToArray);
  1304.  
  1305. ;// ./node_modules/lodash-es/_equalByTag.js
  1306.  
  1307.  
  1308.  
  1309.  
  1310.  
  1311.  
  1312.  
  1313. /** Used to compose bitmasks for value comparisons. */
  1314. var _equalByTag_COMPARE_PARTIAL_FLAG = 1,
  1315.     _equalByTag_COMPARE_UNORDERED_FLAG = 2;
  1316.  
  1317. /** `Object#toString` result references. */
  1318. var boolTag = '[object Boolean]',
  1319.     dateTag = '[object Date]',
  1320.     errorTag = '[object Error]',
  1321.     mapTag = '[object Map]',
  1322.     numberTag = '[object Number]',
  1323.     regexpTag = '[object RegExp]',
  1324.     setTag = '[object Set]',
  1325.     stringTag = '[object String]',
  1326.     symbolTag = '[object Symbol]';
  1327.  
  1328. var arrayBufferTag = '[object ArrayBuffer]',
  1329.     dataViewTag = '[object DataView]';
  1330.  
  1331. /** Used to convert symbols to primitives and strings. */
  1332. var symbolProto = _Symbol ? _Symbol.prototype : undefined,
  1333.     symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
  1334.  
  1335. /**
  1336.  * A specialized version of `baseIsEqualDeep` for comparing objects of
  1337.  * the same `toStringTag`.
  1338.  *
  1339.  * **Note:** This function only supports comparing values with tags of
  1340.  * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
  1341.  *
  1342.  * @private
  1343.  * @param {Object} object The object to compare.
  1344.  * @param {Object} other The other object to compare.
  1345.  * @param {string} tag The `toStringTag` of the objects to compare.
  1346.  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  1347.  * @param {Function} customizer The function to customize comparisons.
  1348.  * @param {Function} equalFunc The function to determine equivalents of values.
  1349.  * @param {Object} stack Tracks traversed `object` and `other` objects.
  1350.  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  1351.  */
  1352. function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
  1353.   switch (tag) {
  1354.     case dataViewTag:
  1355.       if ((object.byteLength != other.byteLength) ||
  1356.           (object.byteOffset != other.byteOffset)) {
  1357.         return false;
  1358.       }
  1359.       object = object.buffer;
  1360.       other = other.buffer;
  1361.  
  1362.     case arrayBufferTag:
  1363.       if ((object.byteLength != other.byteLength) ||
  1364.           !equalFunc(new _Uint8Array(object), new _Uint8Array(other))) {
  1365.         return false;
  1366.       }
  1367.       return true;
  1368.  
  1369.     case boolTag:
  1370.     case dateTag:
  1371.     case numberTag:
  1372.       // Coerce booleans to `1` or `0` and dates to milliseconds.
  1373.       // Invalid dates are coerced to `NaN`.
  1374.       return lodash_es_eq(+object, +other);
  1375.  
  1376.     case errorTag:
  1377.       return object.name == other.name && object.message == other.message;
  1378.  
  1379.     case regexpTag:
  1380.     case stringTag:
  1381.       // Coerce regexes to strings and treat strings, primitives and objects,
  1382.       // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
  1383.       // for more details.
  1384.       return object == (other + '');
  1385.  
  1386.     case mapTag:
  1387.       var convert = _mapToArray;
  1388.  
  1389.     case setTag:
  1390.       var isPartial = bitmask & _equalByTag_COMPARE_PARTIAL_FLAG;
  1391.       convert || (convert = _setToArray);
  1392.  
  1393.       if (object.size != other.size && !isPartial) {
  1394.         return false;
  1395.       }
  1396.       // Assume cyclic values are equal.
  1397.       var stacked = stack.get(object);
  1398.       if (stacked) {
  1399.         return stacked == other;
  1400.       }
  1401.       bitmask |= _equalByTag_COMPARE_UNORDERED_FLAG;
  1402.  
  1403.       // Recursively compare objects (susceptible to call stack limits).
  1404.       stack.set(object, other);
  1405.       var result = _equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
  1406.       stack['delete'](object);
  1407.       return result;
  1408.  
  1409.     case symbolTag:
  1410.       if (symbolValueOf) {
  1411.         return symbolValueOf.call(object) == symbolValueOf.call(other);
  1412.       }
  1413.   }
  1414.   return false;
  1415. }
  1416.  
  1417. /* harmony default export */ const _equalByTag = (equalByTag);
  1418.  
  1419. ;// ./node_modules/lodash-es/_arrayPush.js
  1420. /**
  1421.  * Appends the elements of `values` to `array`.
  1422.  *
  1423.  * @private
  1424.  * @param {Array} array The array to modify.
  1425.  * @param {Array} values The values to append.
  1426.  * @returns {Array} Returns `array`.
  1427.  */
  1428. function arrayPush(array, values) {
  1429.   var index = -1,
  1430.       length = values.length,
  1431.       offset = array.length;
  1432.  
  1433.   while (++index < length) {
  1434.     array[offset + index] = values[index];
  1435.   }
  1436.   return array;
  1437. }
  1438.  
  1439. /* harmony default export */ const _arrayPush = (arrayPush);
  1440.  
  1441. ;// ./node_modules/lodash-es/isArray.js
  1442. /**
  1443.  * Checks if `value` is classified as an `Array` object.
  1444.  *
  1445.  * @static
  1446.  * @memberOf _
  1447.  * @since 0.1.0
  1448.  * @category Lang
  1449.  * @param {*} value The value to check.
  1450.  * @returns {boolean} Returns `true` if `value` is an array, else `false`.
  1451.  * @example
  1452.  *
  1453.  * _.isArray([1, 2, 3]);
  1454.  * // => true
  1455.  *
  1456.  * _.isArray(document.body.children);
  1457.  * // => false
  1458.  *
  1459.  * _.isArray('abc');
  1460.  * // => false
  1461.  *
  1462.  * _.isArray(_.noop);
  1463.  * // => false
  1464.  */
  1465. var isArray = Array.isArray;
  1466.  
  1467. /* harmony default export */ const lodash_es_isArray = (isArray);
  1468.  
  1469. ;// ./node_modules/lodash-es/_baseGetAllKeys.js
  1470.  
  1471.  
  1472.  
  1473. /**
  1474.  * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
  1475.  * `keysFunc` and `symbolsFunc` to get the enumerable property names and
  1476.  * symbols of `object`.
  1477.  *
  1478.  * @private
  1479.  * @param {Object} object The object to query.
  1480.  * @param {Function} keysFunc The function to get the keys of `object`.
  1481.  * @param {Function} symbolsFunc The function to get the symbols of `object`.
  1482.  * @returns {Array} Returns the array of property names and symbols.
  1483.  */
  1484. function baseGetAllKeys(object, keysFunc, symbolsFunc) {
  1485.   var result = keysFunc(object);
  1486.   return lodash_es_isArray(object) ? result : _arrayPush(result, symbolsFunc(object));
  1487. }
  1488.  
  1489. /* harmony default export */ const _baseGetAllKeys = (baseGetAllKeys);
  1490.  
  1491. ;// ./node_modules/lodash-es/_arrayFilter.js
  1492. /**
  1493.  * A specialized version of `_.filter` for arrays without support for
  1494.  * iteratee shorthands.
  1495.  *
  1496.  * @private
  1497.  * @param {Array} [array] The array to iterate over.
  1498.  * @param {Function} predicate The function invoked per iteration.
  1499.  * @returns {Array} Returns the new filtered array.
  1500.  */
  1501. function arrayFilter(array, predicate) {
  1502.   var index = -1,
  1503.       length = array == null ? 0 : array.length,
  1504.       resIndex = 0,
  1505.       result = [];
  1506.  
  1507.   while (++index < length) {
  1508.     var value = array[index];
  1509.     if (predicate(value, index, array)) {
  1510.       result[resIndex++] = value;
  1511.     }
  1512.   }
  1513.   return result;
  1514. }
  1515.  
  1516. /* harmony default export */ const _arrayFilter = (arrayFilter);
  1517.  
  1518. ;// ./node_modules/lodash-es/stubArray.js
  1519. /**
  1520.  * This method returns a new empty array.
  1521.  *
  1522.  * @static
  1523.  * @memberOf _
  1524.  * @since 4.13.0
  1525.  * @category Util
  1526.  * @returns {Array} Returns the new empty array.
  1527.  * @example
  1528.  *
  1529.  * var arrays = _.times(2, _.stubArray);
  1530.  *
  1531.  * console.log(arrays);
  1532.  * // => [[], []]
  1533.  *
  1534.  * console.log(arrays[0] === arrays[1]);
  1535.  * // => false
  1536.  */
  1537. function stubArray() {
  1538.   return [];
  1539. }
  1540.  
  1541. /* harmony default export */ const lodash_es_stubArray = (stubArray);
  1542.  
  1543. ;// ./node_modules/lodash-es/_getSymbols.js
  1544.  
  1545.  
  1546.  
  1547. /** Used for built-in method references. */
  1548. var _getSymbols_objectProto = Object.prototype;
  1549.  
  1550. /** Built-in value references. */
  1551. var propertyIsEnumerable = _getSymbols_objectProto.propertyIsEnumerable;
  1552.  
  1553. /* Built-in method references for those with the same name as other `lodash` methods. */
  1554. var nativeGetSymbols = Object.getOwnPropertySymbols;
  1555.  
  1556. /**
  1557.  * Creates an array of the own enumerable symbols of `object`.
  1558.  *
  1559.  * @private
  1560.  * @param {Object} object The object to query.
  1561.  * @returns {Array} Returns the array of symbols.
  1562.  */
  1563. var getSymbols = !nativeGetSymbols ? lodash_es_stubArray : function(object) {
  1564.   if (object == null) {
  1565.     return [];
  1566.   }
  1567.   object = Object(object);
  1568.   return _arrayFilter(nativeGetSymbols(object), function(symbol) {
  1569.     return propertyIsEnumerable.call(object, symbol);
  1570.   });
  1571. };
  1572.  
  1573. /* harmony default export */ const _getSymbols = (getSymbols);
  1574.  
  1575. ;// ./node_modules/lodash-es/_baseTimes.js
  1576. /**
  1577.  * The base implementation of `_.times` without support for iteratee shorthands
  1578.  * or max array length checks.
  1579.  *
  1580.  * @private
  1581.  * @param {number} n The number of times to invoke `iteratee`.
  1582.  * @param {Function} iteratee The function invoked per iteration.
  1583.  * @returns {Array} Returns the array of results.
  1584.  */
  1585. function baseTimes(n, iteratee) {
  1586.   var index = -1,
  1587.       result = Array(n);
  1588.  
  1589.   while (++index < n) {
  1590.     result[index] = iteratee(index);
  1591.   }
  1592.   return result;
  1593. }
  1594.  
  1595. /* harmony default export */ const _baseTimes = (baseTimes);
  1596.  
  1597. ;// ./node_modules/lodash-es/isObjectLike.js
  1598. /**
  1599.  * Checks if `value` is object-like. A value is object-like if it's not `null`
  1600.  * and has a `typeof` result of "object".
  1601.  *
  1602.  * @static
  1603.  * @memberOf _
  1604.  * @since 4.0.0
  1605.  * @category Lang
  1606.  * @param {*} value The value to check.
  1607.  * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
  1608.  * @example
  1609.  *
  1610.  * _.isObjectLike({});
  1611.  * // => true
  1612.  *
  1613.  * _.isObjectLike([1, 2, 3]);
  1614.  * // => true
  1615.  *
  1616.  * _.isObjectLike(_.noop);
  1617.  * // => false
  1618.  *
  1619.  * _.isObjectLike(null);
  1620.  * // => false
  1621.  */
  1622. function isObjectLike(value) {
  1623.   return value != null && typeof value == 'object';
  1624. }
  1625.  
  1626. /* harmony default export */ const lodash_es_isObjectLike = (isObjectLike);
  1627.  
  1628. ;// ./node_modules/lodash-es/_baseIsArguments.js
  1629.  
  1630.  
  1631.  
  1632. /** `Object#toString` result references. */
  1633. var argsTag = '[object Arguments]';
  1634.  
  1635. /**
  1636.  * The base implementation of `_.isArguments`.
  1637.  *
  1638.  * @private
  1639.  * @param {*} value The value to check.
  1640.  * @returns {boolean} Returns `true` if `value` is an `arguments` object,
  1641.  */
  1642. function baseIsArguments(value) {
  1643.   return lodash_es_isObjectLike(value) && _baseGetTag(value) == argsTag;
  1644. }
  1645.  
  1646. /* harmony default export */ const _baseIsArguments = (baseIsArguments);
  1647.  
  1648. ;// ./node_modules/lodash-es/isArguments.js
  1649.  
  1650.  
  1651.  
  1652. /** Used for built-in method references. */
  1653. var isArguments_objectProto = Object.prototype;
  1654.  
  1655. /** Used to check objects for own properties. */
  1656. var isArguments_hasOwnProperty = isArguments_objectProto.hasOwnProperty;
  1657.  
  1658. /** Built-in value references. */
  1659. var isArguments_propertyIsEnumerable = isArguments_objectProto.propertyIsEnumerable;
  1660.  
  1661. /**
  1662.  * Checks if `value` is likely an `arguments` object.
  1663.  *
  1664.  * @static
  1665.  * @memberOf _
  1666.  * @since 0.1.0
  1667.  * @category Lang
  1668.  * @param {*} value The value to check.
  1669.  * @returns {boolean} Returns `true` if `value` is an `arguments` object,
  1670.  *  else `false`.
  1671.  * @example
  1672.  *
  1673.  * _.isArguments(function() { return arguments; }());
  1674.  * // => true
  1675.  *
  1676.  * _.isArguments([1, 2, 3]);
  1677.  * // => false
  1678.  */
  1679. var isArguments = _baseIsArguments(function() { return arguments; }()) ? _baseIsArguments : function(value) {
  1680.   return lodash_es_isObjectLike(value) && isArguments_hasOwnProperty.call(value, 'callee') &&
  1681.     !isArguments_propertyIsEnumerable.call(value, 'callee');
  1682. };
  1683.  
  1684. /* harmony default export */ const lodash_es_isArguments = (isArguments);
  1685.  
  1686. ;// ./node_modules/lodash-es/stubFalse.js
  1687. /**
  1688.  * This method returns `false`.
  1689.  *
  1690.  * @static
  1691.  * @memberOf _
  1692.  * @since 4.13.0
  1693.  * @category Util
  1694.  * @returns {boolean} Returns `false`.
  1695.  * @example
  1696.  *
  1697.  * _.times(2, _.stubFalse);
  1698.  * // => [false, false]
  1699.  */
  1700. function stubFalse() {
  1701.   return false;
  1702. }
  1703.  
  1704. /* harmony default export */ const lodash_es_stubFalse = (stubFalse);
  1705.  
  1706. ;// ./node_modules/lodash-es/isBuffer.js
  1707.  
  1708.  
  1709.  
  1710. /** Detect free variable `exports`. */
  1711. var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  1712.  
  1713. /** Detect free variable `module`. */
  1714. var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  1715.  
  1716. /** Detect the popular CommonJS extension `module.exports`. */
  1717. var moduleExports = freeModule && freeModule.exports === freeExports;
  1718.  
  1719. /** Built-in value references. */
  1720. var Buffer = moduleExports ? _root.Buffer : undefined;
  1721.  
  1722. /* Built-in method references for those with the same name as other `lodash` methods. */
  1723. var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
  1724.  
  1725. /**
  1726.  * Checks if `value` is a buffer.
  1727.  *
  1728.  * @static
  1729.  * @memberOf _
  1730.  * @since 4.3.0
  1731.  * @category Lang
  1732.  * @param {*} value The value to check.
  1733.  * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
  1734.  * @example
  1735.  *
  1736.  * _.isBuffer(new Buffer(2));
  1737.  * // => true
  1738.  *
  1739.  * _.isBuffer(new Uint8Array(2));
  1740.  * // => false
  1741.  */
  1742. var isBuffer = nativeIsBuffer || lodash_es_stubFalse;
  1743.  
  1744. /* harmony default export */ const lodash_es_isBuffer = (isBuffer);
  1745.  
  1746. ;// ./node_modules/lodash-es/_isIndex.js
  1747. /** Used as references for various `Number` constants. */
  1748. var MAX_SAFE_INTEGER = 9007199254740991;
  1749.  
  1750. /** Used to detect unsigned integer values. */
  1751. var reIsUint = /^(?:0|[1-9]\d*)$/;
  1752.  
  1753. /**
  1754.  * Checks if `value` is a valid array-like index.
  1755.  *
  1756.  * @private
  1757.  * @param {*} value The value to check.
  1758.  * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
  1759.  * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
  1760.  */
  1761. function isIndex(value, length) {
  1762.   var type = typeof value;
  1763.   length = length == null ? MAX_SAFE_INTEGER : length;
  1764.  
  1765.   return !!length &&
  1766.     (type == 'number' ||
  1767.       (type != 'symbol' && reIsUint.test(value))) &&
  1768.         (value > -1 && value % 1 == 0 && value < length);
  1769. }
  1770.  
  1771. /* harmony default export */ const _isIndex = (isIndex);
  1772.  
  1773. ;// ./node_modules/lodash-es/isLength.js
  1774. /** Used as references for various `Number` constants. */
  1775. var isLength_MAX_SAFE_INTEGER = 9007199254740991;
  1776.  
  1777. /**
  1778.  * Checks if `value` is a valid array-like length.
  1779.  *
  1780.  * **Note:** This method is loosely based on
  1781.  * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
  1782.  *
  1783.  * @static
  1784.  * @memberOf _
  1785.  * @since 4.0.0
  1786.  * @category Lang
  1787.  * @param {*} value The value to check.
  1788.  * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
  1789.  * @example
  1790.  *
  1791.  * _.isLength(3);
  1792.  * // => true
  1793.  *
  1794.  * _.isLength(Number.MIN_VALUE);
  1795.  * // => false
  1796.  *
  1797.  * _.isLength(Infinity);
  1798.  * // => false
  1799.  *
  1800.  * _.isLength('3');
  1801.  * // => false
  1802.  */
  1803. function isLength(value) {
  1804.   return typeof value == 'number' &&
  1805.     value > -1 && value % 1 == 0 && value <= isLength_MAX_SAFE_INTEGER;
  1806. }
  1807.  
  1808. /* harmony default export */ const lodash_es_isLength = (isLength);
  1809.  
  1810. ;// ./node_modules/lodash-es/_baseIsTypedArray.js
  1811.  
  1812.  
  1813.  
  1814.  
  1815. /** `Object#toString` result references. */
  1816. var _baseIsTypedArray_argsTag = '[object Arguments]',
  1817.     arrayTag = '[object Array]',
  1818.     _baseIsTypedArray_boolTag = '[object Boolean]',
  1819.     _baseIsTypedArray_dateTag = '[object Date]',
  1820.     _baseIsTypedArray_errorTag = '[object Error]',
  1821.     _baseIsTypedArray_funcTag = '[object Function]',
  1822.     _baseIsTypedArray_mapTag = '[object Map]',
  1823.     _baseIsTypedArray_numberTag = '[object Number]',
  1824.     objectTag = '[object Object]',
  1825.     _baseIsTypedArray_regexpTag = '[object RegExp]',
  1826.     _baseIsTypedArray_setTag = '[object Set]',
  1827.     _baseIsTypedArray_stringTag = '[object String]',
  1828.     weakMapTag = '[object WeakMap]';
  1829.  
  1830. var _baseIsTypedArray_arrayBufferTag = '[object ArrayBuffer]',
  1831.     _baseIsTypedArray_dataViewTag = '[object DataView]',
  1832.     float32Tag = '[object Float32Array]',
  1833.     float64Tag = '[object Float64Array]',
  1834.     int8Tag = '[object Int8Array]',
  1835.     int16Tag = '[object Int16Array]',
  1836.     int32Tag = '[object Int32Array]',
  1837.     uint8Tag = '[object Uint8Array]',
  1838.     uint8ClampedTag = '[object Uint8ClampedArray]',
  1839.     uint16Tag = '[object Uint16Array]',
  1840.     uint32Tag = '[object Uint32Array]';
  1841.  
  1842. /** Used to identify `toStringTag` values of typed arrays. */
  1843. var typedArrayTags = {};
  1844. typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
  1845. typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
  1846. typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
  1847. typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
  1848. typedArrayTags[uint32Tag] = true;
  1849. typedArrayTags[_baseIsTypedArray_argsTag] = typedArrayTags[arrayTag] =
  1850. typedArrayTags[_baseIsTypedArray_arrayBufferTag] = typedArrayTags[_baseIsTypedArray_boolTag] =
  1851. typedArrayTags[_baseIsTypedArray_dataViewTag] = typedArrayTags[_baseIsTypedArray_dateTag] =
  1852. typedArrayTags[_baseIsTypedArray_errorTag] = typedArrayTags[_baseIsTypedArray_funcTag] =
  1853. typedArrayTags[_baseIsTypedArray_mapTag] = typedArrayTags[_baseIsTypedArray_numberTag] =
  1854. typedArrayTags[objectTag] = typedArrayTags[_baseIsTypedArray_regexpTag] =
  1855. typedArrayTags[_baseIsTypedArray_setTag] = typedArrayTags[_baseIsTypedArray_stringTag] =
  1856. typedArrayTags[weakMapTag] = false;
  1857.  
  1858. /**
  1859.  * The base implementation of `_.isTypedArray` without Node.js optimizations.
  1860.  *
  1861.  * @private
  1862.  * @param {*} value The value to check.
  1863.  * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
  1864.  */
  1865. function baseIsTypedArray(value) {
  1866.   return lodash_es_isObjectLike(value) &&
  1867.     lodash_es_isLength(value.length) && !!typedArrayTags[_baseGetTag(value)];
  1868. }
  1869.  
  1870. /* harmony default export */ const _baseIsTypedArray = (baseIsTypedArray);
  1871.  
  1872. ;// ./node_modules/lodash-es/_baseUnary.js
  1873. /**
  1874.  * The base implementation of `_.unary` without support for storing metadata.
  1875.  *
  1876.  * @private
  1877.  * @param {Function} func The function to cap arguments for.
  1878.  * @returns {Function} Returns the new capped function.
  1879.  */
  1880. function baseUnary(func) {
  1881.   return function(value) {
  1882.     return func(value);
  1883.   };
  1884. }
  1885.  
  1886. /* harmony default export */ const _baseUnary = (baseUnary);
  1887.  
  1888. ;// ./node_modules/lodash-es/_nodeUtil.js
  1889.  
  1890.  
  1891. /** Detect free variable `exports`. */
  1892. var _nodeUtil_freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  1893.  
  1894. /** Detect free variable `module`. */
  1895. var _nodeUtil_freeModule = _nodeUtil_freeExports && typeof module == 'object' && module && !module.nodeType && module;
  1896.  
  1897. /** Detect the popular CommonJS extension `module.exports`. */
  1898. var _nodeUtil_moduleExports = _nodeUtil_freeModule && _nodeUtil_freeModule.exports === _nodeUtil_freeExports;
  1899.  
  1900. /** Detect free variable `process` from Node.js. */
  1901. var freeProcess = _nodeUtil_moduleExports && _freeGlobal.process;
  1902.  
  1903. /** Used to access faster Node.js helpers. */
  1904. var nodeUtil = (function() {
  1905.   try {
  1906.     // Use `util.types` for Node.js 10+.
  1907.     var types = _nodeUtil_freeModule && _nodeUtil_freeModule.require && _nodeUtil_freeModule.require('util').types;
  1908.  
  1909.     if (types) {
  1910.       return types;
  1911.     }
  1912.  
  1913.     // Legacy `process.binding('util')` for Node.js < 10.
  1914.     return freeProcess && freeProcess.binding && freeProcess.binding('util');
  1915.   } catch (e) {}
  1916. }());
  1917.  
  1918. /* harmony default export */ const _nodeUtil = (nodeUtil);
  1919.  
  1920. ;// ./node_modules/lodash-es/isTypedArray.js
  1921.  
  1922.  
  1923.  
  1924.  
  1925. /* Node.js helper references. */
  1926. var nodeIsTypedArray = _nodeUtil && _nodeUtil.isTypedArray;
  1927.  
  1928. /**
  1929.  * Checks if `value` is classified as a typed array.
  1930.  *
  1931.  * @static
  1932.  * @memberOf _
  1933.  * @since 3.0.0
  1934.  * @category Lang
  1935.  * @param {*} value The value to check.
  1936.  * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
  1937.  * @example
  1938.  *
  1939.  * _.isTypedArray(new Uint8Array);
  1940.  * // => true
  1941.  *
  1942.  * _.isTypedArray([]);
  1943.  * // => false
  1944.  */
  1945. var isTypedArray = nodeIsTypedArray ? _baseUnary(nodeIsTypedArray) : _baseIsTypedArray;
  1946.  
  1947. /* harmony default export */ const lodash_es_isTypedArray = (isTypedArray);
  1948.  
  1949. ;// ./node_modules/lodash-es/_arrayLikeKeys.js
  1950.  
  1951.  
  1952.  
  1953.  
  1954.  
  1955.  
  1956.  
  1957. /** Used for built-in method references. */
  1958. var _arrayLikeKeys_objectProto = Object.prototype;
  1959.  
  1960. /** Used to check objects for own properties. */
  1961. var _arrayLikeKeys_hasOwnProperty = _arrayLikeKeys_objectProto.hasOwnProperty;
  1962.  
  1963. /**
  1964.  * Creates an array of the enumerable property names of the array-like `value`.
  1965.  *
  1966.  * @private
  1967.  * @param {*} value The value to query.
  1968.  * @param {boolean} inherited Specify returning inherited property names.
  1969.  * @returns {Array} Returns the array of property names.
  1970.  */
  1971. function arrayLikeKeys(value, inherited) {
  1972.   var isArr = lodash_es_isArray(value),
  1973.       isArg = !isArr && lodash_es_isArguments(value),
  1974.       isBuff = !isArr && !isArg && lodash_es_isBuffer(value),
  1975.       isType = !isArr && !isArg && !isBuff && lodash_es_isTypedArray(value),
  1976.       skipIndexes = isArr || isArg || isBuff || isType,
  1977.       result = skipIndexes ? _baseTimes(value.length, String) : [],
  1978.       length = result.length;
  1979.  
  1980.   for (var key in value) {
  1981.     if ((inherited || _arrayLikeKeys_hasOwnProperty.call(value, key)) &&
  1982.         !(skipIndexes && (
  1983.            // Safari 9 has enumerable `arguments.length` in strict mode.
  1984.            key == 'length' ||
  1985.            // Node.js 0.10 has enumerable non-index properties on buffers.
  1986.            (isBuff && (key == 'offset' || key == 'parent')) ||
  1987.            // PhantomJS 2 has enumerable non-index properties on typed arrays.
  1988.            (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
  1989.            // Skip index properties.
  1990.            _isIndex(key, length)
  1991.         ))) {
  1992.       result.push(key);
  1993.     }
  1994.   }
  1995.   return result;
  1996. }
  1997.  
  1998. /* harmony default export */ const _arrayLikeKeys = (arrayLikeKeys);
  1999.  
  2000. ;// ./node_modules/lodash-es/_isPrototype.js
  2001. /** Used for built-in method references. */
  2002. var _isPrototype_objectProto = Object.prototype;
  2003.  
  2004. /**
  2005.  * Checks if `value` is likely a prototype object.
  2006.  *
  2007.  * @private
  2008.  * @param {*} value The value to check.
  2009.  * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
  2010.  */
  2011. function isPrototype(value) {
  2012.   var Ctor = value && value.constructor,
  2013.       proto = (typeof Ctor == 'function' && Ctor.prototype) || _isPrototype_objectProto;
  2014.  
  2015.   return value === proto;
  2016. }
  2017.  
  2018. /* harmony default export */ const _isPrototype = (isPrototype);
  2019.  
  2020. ;// ./node_modules/lodash-es/_overArg.js
  2021. /**
  2022.  * Creates a unary function that invokes `func` with its argument transformed.
  2023.  *
  2024.  * @private
  2025.  * @param {Function} func The function to wrap.
  2026.  * @param {Function} transform The argument transform.
  2027.  * @returns {Function} Returns the new function.
  2028.  */
  2029. function overArg(func, transform) {
  2030.   return function(arg) {
  2031.     return func(transform(arg));
  2032.   };
  2033. }
  2034.  
  2035. /* harmony default export */ const _overArg = (overArg);
  2036.  
  2037. ;// ./node_modules/lodash-es/_nativeKeys.js
  2038.  
  2039.  
  2040. /* Built-in method references for those with the same name as other `lodash` methods. */
  2041. var nativeKeys = _overArg(Object.keys, Object);
  2042.  
  2043. /* harmony default export */ const _nativeKeys = (nativeKeys);
  2044.  
  2045. ;// ./node_modules/lodash-es/_baseKeys.js
  2046.  
  2047.  
  2048.  
  2049. /** Used for built-in method references. */
  2050. var _baseKeys_objectProto = Object.prototype;
  2051.  
  2052. /** Used to check objects for own properties. */
  2053. var _baseKeys_hasOwnProperty = _baseKeys_objectProto.hasOwnProperty;
  2054.  
  2055. /**
  2056.  * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
  2057.  *
  2058.  * @private
  2059.  * @param {Object} object The object to query.
  2060.  * @returns {Array} Returns the array of property names.
  2061.  */
  2062. function baseKeys(object) {
  2063.   if (!_isPrototype(object)) {
  2064.     return _nativeKeys(object);
  2065.   }
  2066.   var result = [];
  2067.   for (var key in Object(object)) {
  2068.     if (_baseKeys_hasOwnProperty.call(object, key) && key != 'constructor') {
  2069.       result.push(key);
  2070.     }
  2071.   }
  2072.   return result;
  2073. }
  2074.  
  2075. /* harmony default export */ const _baseKeys = (baseKeys);
  2076.  
  2077. ;// ./node_modules/lodash-es/isArrayLike.js
  2078.  
  2079.  
  2080.  
  2081. /**
  2082.  * Checks if `value` is array-like. A value is considered array-like if it's
  2083.  * not a function and has a `value.length` that's an integer greater than or
  2084.  * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
  2085.  *
  2086.  * @static
  2087.  * @memberOf _
  2088.  * @since 4.0.0
  2089.  * @category Lang
  2090.  * @param {*} value The value to check.
  2091.  * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
  2092.  * @example
  2093.  *
  2094.  * _.isArrayLike([1, 2, 3]);
  2095.  * // => true
  2096.  *
  2097.  * _.isArrayLike(document.body.children);
  2098.  * // => true
  2099.  *
  2100.  * _.isArrayLike('abc');
  2101.  * // => true
  2102.  *
  2103.  * _.isArrayLike(_.noop);
  2104.  * // => false
  2105.  */
  2106. function isArrayLike(value) {
  2107.   return value != null && lodash_es_isLength(value.length) && !lodash_es_isFunction(value);
  2108. }
  2109.  
  2110. /* harmony default export */ const lodash_es_isArrayLike = (isArrayLike);
  2111.  
  2112. ;// ./node_modules/lodash-es/keys.js
  2113.  
  2114.  
  2115.  
  2116.  
  2117. /**
  2118.  * Creates an array of the own enumerable property names of `object`.
  2119.  *
  2120.  * **Note:** Non-object values are coerced to objects. See the
  2121.  * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
  2122.  * for more details.
  2123.  *
  2124.  * @static
  2125.  * @since 0.1.0
  2126.  * @memberOf _
  2127.  * @category Object
  2128.  * @param {Object} object The object to query.
  2129.  * @returns {Array} Returns the array of property names.
  2130.  * @example
  2131.  *
  2132.  * function Foo() {
  2133.  *   this.a = 1;
  2134.  *   this.b = 2;
  2135.  * }
  2136.  *
  2137.  * Foo.prototype.c = 3;
  2138.  *
  2139.  * _.keys(new Foo);
  2140.  * // => ['a', 'b'] (iteration order is not guaranteed)
  2141.  *
  2142.  * _.keys('hi');
  2143.  * // => ['0', '1']
  2144.  */
  2145. function keys(object) {
  2146.   return lodash_es_isArrayLike(object) ? _arrayLikeKeys(object) : _baseKeys(object);
  2147. }
  2148.  
  2149. /* harmony default export */ const lodash_es_keys = (keys);
  2150.  
  2151. ;// ./node_modules/lodash-es/_getAllKeys.js
  2152.  
  2153.  
  2154.  
  2155.  
  2156. /**
  2157.  * Creates an array of own enumerable property names and symbols of `object`.
  2158.  *
  2159.  * @private
  2160.  * @param {Object} object The object to query.
  2161.  * @returns {Array} Returns the array of property names and symbols.
  2162.  */
  2163. function getAllKeys(object) {
  2164.   return _baseGetAllKeys(object, lodash_es_keys, _getSymbols);
  2165. }
  2166.  
  2167. /* harmony default export */ const _getAllKeys = (getAllKeys);
  2168.  
  2169. ;// ./node_modules/lodash-es/_equalObjects.js
  2170.  
  2171.  
  2172. /** Used to compose bitmasks for value comparisons. */
  2173. var _equalObjects_COMPARE_PARTIAL_FLAG = 1;
  2174.  
  2175. /** Used for built-in method references. */
  2176. var _equalObjects_objectProto = Object.prototype;
  2177.  
  2178. /** Used to check objects for own properties. */
  2179. var _equalObjects_hasOwnProperty = _equalObjects_objectProto.hasOwnProperty;
  2180.  
  2181. /**
  2182.  * A specialized version of `baseIsEqualDeep` for objects with support for
  2183.  * partial deep comparisons.
  2184.  *
  2185.  * @private
  2186.  * @param {Object} object The object to compare.
  2187.  * @param {Object} other The other object to compare.
  2188.  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  2189.  * @param {Function} customizer The function to customize comparisons.
  2190.  * @param {Function} equalFunc The function to determine equivalents of values.
  2191.  * @param {Object} stack Tracks traversed `object` and `other` objects.
  2192.  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  2193.  */
  2194. function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
  2195.   var isPartial = bitmask & _equalObjects_COMPARE_PARTIAL_FLAG,
  2196.       objProps = _getAllKeys(object),
  2197.       objLength = objProps.length,
  2198.       othProps = _getAllKeys(other),
  2199.       othLength = othProps.length;
  2200.  
  2201.   if (objLength != othLength && !isPartial) {
  2202.     return false;
  2203.   }
  2204.   var index = objLength;
  2205.   while (index--) {
  2206.     var key = objProps[index];
  2207.     if (!(isPartial ? key in other : _equalObjects_hasOwnProperty.call(other, key))) {
  2208.       return false;
  2209.     }
  2210.   }
  2211.   // Check that cyclic values are equal.
  2212.   var objStacked = stack.get(object);
  2213.   var othStacked = stack.get(other);
  2214.   if (objStacked && othStacked) {
  2215.     return objStacked == other && othStacked == object;
  2216.   }
  2217.   var result = true;
  2218.   stack.set(object, other);
  2219.   stack.set(other, object);
  2220.  
  2221.   var skipCtor = isPartial;
  2222.   while (++index < objLength) {
  2223.     key = objProps[index];
  2224.     var objValue = object[key],
  2225.         othValue = other[key];
  2226.  
  2227.     if (customizer) {
  2228.       var compared = isPartial
  2229.         ? customizer(othValue, objValue, key, other, object, stack)
  2230.         : customizer(objValue, othValue, key, object, other, stack);
  2231.     }
  2232.     // Recursively compare objects (susceptible to call stack limits).
  2233.     if (!(compared === undefined
  2234.           ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))
  2235.           : compared
  2236.         )) {
  2237.       result = false;
  2238.       break;
  2239.     }
  2240.     skipCtor || (skipCtor = key == 'constructor');
  2241.   }
  2242.   if (result && !skipCtor) {
  2243.     var objCtor = object.constructor,
  2244.         othCtor = other.constructor;
  2245.  
  2246.     // Non `Object` object instances with different constructors are not equal.
  2247.     if (objCtor != othCtor &&
  2248.         ('constructor' in object && 'constructor' in other) &&
  2249.         !(typeof objCtor == 'function' && objCtor instanceof objCtor &&
  2250.           typeof othCtor == 'function' && othCtor instanceof othCtor)) {
  2251.       result = false;
  2252.     }
  2253.   }
  2254.   stack['delete'](object);
  2255.   stack['delete'](other);
  2256.   return result;
  2257. }
  2258.  
  2259. /* harmony default export */ const _equalObjects = (equalObjects);
  2260.  
  2261. ;// ./node_modules/lodash-es/_DataView.js
  2262.  
  2263.  
  2264.  
  2265. /* Built-in method references that are verified to be native. */
  2266. var DataView = _getNative(_root, 'DataView');
  2267.  
  2268. /* harmony default export */ const _DataView = (DataView);
  2269.  
  2270. ;// ./node_modules/lodash-es/_Promise.js
  2271.  
  2272.  
  2273.  
  2274. /* Built-in method references that are verified to be native. */
  2275. var _Promise_Promise = _getNative(_root, 'Promise');
  2276.  
  2277. /* harmony default export */ const _Promise = (_Promise_Promise);
  2278.  
  2279. ;// ./node_modules/lodash-es/_Set.js
  2280.  
  2281.  
  2282.  
  2283. /* Built-in method references that are verified to be native. */
  2284. var Set = _getNative(_root, 'Set');
  2285.  
  2286. /* harmony default export */ const _Set = (Set);
  2287.  
  2288. ;// ./node_modules/lodash-es/_WeakMap.js
  2289.  
  2290.  
  2291.  
  2292. /* Built-in method references that are verified to be native. */
  2293. var WeakMap = _getNative(_root, 'WeakMap');
  2294.  
  2295. /* harmony default export */ const _WeakMap = (WeakMap);
  2296.  
  2297. ;// ./node_modules/lodash-es/_getTag.js
  2298.  
  2299.  
  2300.  
  2301.  
  2302.  
  2303.  
  2304.  
  2305.  
  2306. /** `Object#toString` result references. */
  2307. var _getTag_mapTag = '[object Map]',
  2308.     _getTag_objectTag = '[object Object]',
  2309.     promiseTag = '[object Promise]',
  2310.     _getTag_setTag = '[object Set]',
  2311.     _getTag_weakMapTag = '[object WeakMap]';
  2312.  
  2313. var _getTag_dataViewTag = '[object DataView]';
  2314.  
  2315. /** Used to detect maps, sets, and weakmaps. */
  2316. var dataViewCtorString = _toSource(_DataView),
  2317.     mapCtorString = _toSource(_Map),
  2318.     promiseCtorString = _toSource(_Promise),
  2319.     setCtorString = _toSource(_Set),
  2320.     weakMapCtorString = _toSource(_WeakMap);
  2321.  
  2322. /**
  2323.  * Gets the `toStringTag` of `value`.
  2324.  *
  2325.  * @private
  2326.  * @param {*} value The value to query.
  2327.  * @returns {string} Returns the `toStringTag`.
  2328.  */
  2329. var getTag = _baseGetTag;
  2330.  
  2331. // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
  2332. if ((_DataView && getTag(new _DataView(new ArrayBuffer(1))) != _getTag_dataViewTag) ||
  2333.     (_Map && getTag(new _Map) != _getTag_mapTag) ||
  2334.     (_Promise && getTag(_Promise.resolve()) != promiseTag) ||
  2335.     (_Set && getTag(new _Set) != _getTag_setTag) ||
  2336.     (_WeakMap && getTag(new _WeakMap) != _getTag_weakMapTag)) {
  2337.   getTag = function(value) {
  2338.     var result = _baseGetTag(value),
  2339.         Ctor = result == _getTag_objectTag ? value.constructor : undefined,
  2340.         ctorString = Ctor ? _toSource(Ctor) : '';
  2341.  
  2342.     if (ctorString) {
  2343.       switch (ctorString) {
  2344.         case dataViewCtorString: return _getTag_dataViewTag;
  2345.         case mapCtorString: return _getTag_mapTag;
  2346.         case promiseCtorString: return promiseTag;
  2347.         case setCtorString: return _getTag_setTag;
  2348.         case weakMapCtorString: return _getTag_weakMapTag;
  2349.       }
  2350.     }
  2351.     return result;
  2352.   };
  2353. }
  2354.  
  2355. /* harmony default export */ const _getTag = (getTag);
  2356.  
  2357. ;// ./node_modules/lodash-es/_baseIsEqualDeep.js
  2358.  
  2359.  
  2360.  
  2361.  
  2362.  
  2363.  
  2364.  
  2365.  
  2366.  
  2367. /** Used to compose bitmasks for value comparisons. */
  2368. var _baseIsEqualDeep_COMPARE_PARTIAL_FLAG = 1;
  2369.  
  2370. /** `Object#toString` result references. */
  2371. var _baseIsEqualDeep_argsTag = '[object Arguments]',
  2372.     _baseIsEqualDeep_arrayTag = '[object Array]',
  2373.     _baseIsEqualDeep_objectTag = '[object Object]';
  2374.  
  2375. /** Used for built-in method references. */
  2376. var _baseIsEqualDeep_objectProto = Object.prototype;
  2377.  
  2378. /** Used to check objects for own properties. */
  2379. var _baseIsEqualDeep_hasOwnProperty = _baseIsEqualDeep_objectProto.hasOwnProperty;
  2380.  
  2381. /**
  2382.  * A specialized version of `baseIsEqual` for arrays and objects which performs
  2383.  * deep comparisons and tracks traversed objects enabling objects with circular
  2384.  * references to be compared.
  2385.  *
  2386.  * @private
  2387.  * @param {Object} object The object to compare.
  2388.  * @param {Object} other The other object to compare.
  2389.  * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
  2390.  * @param {Function} customizer The function to customize comparisons.
  2391.  * @param {Function} equalFunc The function to determine equivalents of values.
  2392.  * @param {Object} [stack] Tracks traversed `object` and `other` objects.
  2393.  * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
  2394.  */
  2395. function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
  2396.   var objIsArr = lodash_es_isArray(object),
  2397.       othIsArr = lodash_es_isArray(other),
  2398.       objTag = objIsArr ? _baseIsEqualDeep_arrayTag : _getTag(object),
  2399.       othTag = othIsArr ? _baseIsEqualDeep_arrayTag : _getTag(other);
  2400.  
  2401.   objTag = objTag == _baseIsEqualDeep_argsTag ? _baseIsEqualDeep_objectTag : objTag;
  2402.   othTag = othTag == _baseIsEqualDeep_argsTag ? _baseIsEqualDeep_objectTag : othTag;
  2403.  
  2404.   var objIsObj = objTag == _baseIsEqualDeep_objectTag,
  2405.       othIsObj = othTag == _baseIsEqualDeep_objectTag,
  2406.       isSameTag = objTag == othTag;
  2407.  
  2408.   if (isSameTag && lodash_es_isBuffer(object)) {
  2409.     if (!lodash_es_isBuffer(other)) {
  2410.       return false;
  2411.     }
  2412.     objIsArr = true;
  2413.     objIsObj = false;
  2414.   }
  2415.   if (isSameTag && !objIsObj) {
  2416.     stack || (stack = new _Stack);
  2417.     return (objIsArr || lodash_es_isTypedArray(object))
  2418.       ? _equalArrays(object, other, bitmask, customizer, equalFunc, stack)
  2419.       : _equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
  2420.   }
  2421.   if (!(bitmask & _baseIsEqualDeep_COMPARE_PARTIAL_FLAG)) {
  2422.     var objIsWrapped = objIsObj && _baseIsEqualDeep_hasOwnProperty.call(object, '__wrapped__'),
  2423.         othIsWrapped = othIsObj && _baseIsEqualDeep_hasOwnProperty.call(other, '__wrapped__');
  2424.  
  2425.     if (objIsWrapped || othIsWrapped) {
  2426.       var objUnwrapped = objIsWrapped ? object.value() : object,
  2427.           othUnwrapped = othIsWrapped ? other.value() : other;
  2428.  
  2429.       stack || (stack = new _Stack);
  2430.       return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
  2431.     }
  2432.   }
  2433.   if (!isSameTag) {
  2434.     return false;
  2435.   }
  2436.   stack || (stack = new _Stack);
  2437.   return _equalObjects(object, other, bitmask, customizer, equalFunc, stack);
  2438. }
  2439.  
  2440. /* harmony default export */ const _baseIsEqualDeep = (baseIsEqualDeep);
  2441.  
  2442. ;// ./node_modules/lodash-es/_baseIsEqual.js
  2443.  
  2444.  
  2445.  
  2446. /**
  2447.  * The base implementation of `_.isEqual` which supports partial comparisons
  2448.  * and tracks traversed objects.
  2449.  *
  2450.  * @private
  2451.  * @param {*} value The value to compare.
  2452.  * @param {*} other The other value to compare.
  2453.  * @param {boolean} bitmask The bitmask flags.
  2454.  *  1 - Unordered comparison
  2455.  *  2 - Partial comparison
  2456.  * @param {Function} [customizer] The function to customize comparisons.
  2457.  * @param {Object} [stack] Tracks traversed `value` and `other` objects.
  2458.  * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
  2459.  */
  2460. function baseIsEqual(value, other, bitmask, customizer, stack) {
  2461.   if (value === other) {
  2462.     return true;
  2463.   }
  2464.   if (value == null || other == null || (!lodash_es_isObjectLike(value) && !lodash_es_isObjectLike(other))) {
  2465.     return value !== value && other !== other;
  2466.   }
  2467.   return _baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
  2468. }
  2469.  
  2470. /* harmony default export */ const _baseIsEqual = (baseIsEqual);
  2471.  
  2472. ;// ./node_modules/lodash-es/_baseIsMatch.js
  2473.  
  2474.  
  2475.  
  2476. /** Used to compose bitmasks for value comparisons. */
  2477. var _baseIsMatch_COMPARE_PARTIAL_FLAG = 1,
  2478.     _baseIsMatch_COMPARE_UNORDERED_FLAG = 2;
  2479.  
  2480. /**
  2481.  * The base implementation of `_.isMatch` without support for iteratee shorthands.
  2482.  *
  2483.  * @private
  2484.  * @param {Object} object The object to inspect.
  2485.  * @param {Object} source The object of property values to match.
  2486.  * @param {Array} matchData The property names, values, and compare flags to match.
  2487.  * @param {Function} [customizer] The function to customize comparisons.
  2488.  * @returns {boolean} Returns `true` if `object` is a match, else `false`.
  2489.  */
  2490. function baseIsMatch(object, source, matchData, customizer) {
  2491.   var index = matchData.length,
  2492.       length = index,
  2493.       noCustomizer = !customizer;
  2494.  
  2495.   if (object == null) {
  2496.     return !length;
  2497.   }
  2498.   object = Object(object);
  2499.   while (index--) {
  2500.     var data = matchData[index];
  2501.     if ((noCustomizer && data[2])
  2502.           ? data[1] !== object[data[0]]
  2503.           : !(data[0] in object)
  2504.         ) {
  2505.       return false;
  2506.     }
  2507.   }
  2508.   while (++index < length) {
  2509.     data = matchData[index];
  2510.     var key = data[0],
  2511.         objValue = object[key],
  2512.         srcValue = data[1];
  2513.  
  2514.     if (noCustomizer && data[2]) {
  2515.       if (objValue === undefined && !(key in object)) {
  2516.         return false;
  2517.       }
  2518.     } else {
  2519.       var stack = new _Stack;
  2520.       if (customizer) {
  2521.         var result = customizer(objValue, srcValue, key, object, source, stack);
  2522.       }
  2523.       if (!(result === undefined
  2524.             ? _baseIsEqual(srcValue, objValue, _baseIsMatch_COMPARE_PARTIAL_FLAG | _baseIsMatch_COMPARE_UNORDERED_FLAG, customizer, stack)
  2525.             : result
  2526.           )) {
  2527.         return false;
  2528.       }
  2529.     }
  2530.   }
  2531.   return true;
  2532. }
  2533.  
  2534. /* harmony default export */ const _baseIsMatch = (baseIsMatch);
  2535.  
  2536. ;// ./node_modules/lodash-es/_isStrictComparable.js
  2537.  
  2538.  
  2539. /**
  2540.  * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.
  2541.  *
  2542.  * @private
  2543.  * @param {*} value The value to check.
  2544.  * @returns {boolean} Returns `true` if `value` if suitable for strict
  2545.  *  equality comparisons, else `false`.
  2546.  */
  2547. function isStrictComparable(value) {
  2548.   return value === value && !lodash_es_isObject(value);
  2549. }
  2550.  
  2551. /* harmony default export */ const _isStrictComparable = (isStrictComparable);
  2552.  
  2553. ;// ./node_modules/lodash-es/_getMatchData.js
  2554.  
  2555.  
  2556.  
  2557. /**
  2558.  * Gets the property names, values, and compare flags of `object`.
  2559.  *
  2560.  * @private
  2561.  * @param {Object} object The object to query.
  2562.  * @returns {Array} Returns the match data of `object`.
  2563.  */
  2564. function getMatchData(object) {
  2565.   var result = lodash_es_keys(object),
  2566.       length = result.length;
  2567.  
  2568.   while (length--) {
  2569.     var key = result[length],
  2570.         value = object[key];
  2571.  
  2572.     result[length] = [key, value, _isStrictComparable(value)];
  2573.   }
  2574.   return result;
  2575. }
  2576.  
  2577. /* harmony default export */ const _getMatchData = (getMatchData);
  2578.  
  2579. ;// ./node_modules/lodash-es/_matchesStrictComparable.js
  2580. /**
  2581.  * A specialized version of `matchesProperty` for source values suitable
  2582.  * for strict equality comparisons, i.e. `===`.
  2583.  *
  2584.  * @private
  2585.  * @param {string} key The key of the property to get.
  2586.  * @param {*} srcValue The value to match.
  2587.  * @returns {Function} Returns the new spec function.
  2588.  */
  2589. function matchesStrictComparable(key, srcValue) {
  2590.   return function(object) {
  2591.     if (object == null) {
  2592.       return false;
  2593.     }
  2594.     return object[key] === srcValue &&
  2595.       (srcValue !== undefined || (key in Object(object)));
  2596.   };
  2597. }
  2598.  
  2599. /* harmony default export */ const _matchesStrictComparable = (matchesStrictComparable);
  2600.  
  2601. ;// ./node_modules/lodash-es/_baseMatches.js
  2602.  
  2603.  
  2604.  
  2605.  
  2606. /**
  2607.  * The base implementation of `_.matches` which doesn't clone `source`.
  2608.  *
  2609.  * @private
  2610.  * @param {Object} source The object of property values to match.
  2611.  * @returns {Function} Returns the new spec function.
  2612.  */
  2613. function baseMatches(source) {
  2614.   var matchData = _getMatchData(source);
  2615.   if (matchData.length == 1 && matchData[0][2]) {
  2616.     return _matchesStrictComparable(matchData[0][0], matchData[0][1]);
  2617.   }
  2618.   return function(object) {
  2619.     return object === source || _baseIsMatch(object, source, matchData);
  2620.   };
  2621. }
  2622.  
  2623. /* harmony default export */ const _baseMatches = (baseMatches);
  2624.  
  2625. ;// ./node_modules/lodash-es/isSymbol.js
  2626.  
  2627.  
  2628.  
  2629. /** `Object#toString` result references. */
  2630. var isSymbol_symbolTag = '[object Symbol]';
  2631.  
  2632. /**
  2633.  * Checks if `value` is classified as a `Symbol` primitive or object.
  2634.  *
  2635.  * @static
  2636.  * @memberOf _
  2637.  * @since 4.0.0
  2638.  * @category Lang
  2639.  * @param {*} value The value to check.
  2640.  * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
  2641.  * @example
  2642.  *
  2643.  * _.isSymbol(Symbol.iterator);
  2644.  * // => true
  2645.  *
  2646.  * _.isSymbol('abc');
  2647.  * // => false
  2648.  */
  2649. function isSymbol(value) {
  2650.   return typeof value == 'symbol' ||
  2651.     (lodash_es_isObjectLike(value) && _baseGetTag(value) == isSymbol_symbolTag);
  2652. }
  2653.  
  2654. /* harmony default export */ const lodash_es_isSymbol = (isSymbol);
  2655.  
  2656. ;// ./node_modules/lodash-es/_isKey.js
  2657.  
  2658.  
  2659.  
  2660. /** Used to match property names within property paths. */
  2661. var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
  2662.     reIsPlainProp = /^\w*$/;
  2663.  
  2664. /**
  2665.  * Checks if `value` is a property name and not a property path.
  2666.  *
  2667.  * @private
  2668.  * @param {*} value The value to check.
  2669.  * @param {Object} [object] The object to query keys on.
  2670.  * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
  2671.  */
  2672. function isKey(value, object) {
  2673.   if (lodash_es_isArray(value)) {
  2674.     return false;
  2675.   }
  2676.   var type = typeof value;
  2677.   if (type == 'number' || type == 'symbol' || type == 'boolean' ||
  2678.       value == null || lodash_es_isSymbol(value)) {
  2679.     return true;
  2680.   }
  2681.   return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
  2682.     (object != null && value in Object(object));
  2683. }
  2684.  
  2685. /* harmony default export */ const _isKey = (isKey);
  2686.  
  2687. ;// ./node_modules/lodash-es/memoize.js
  2688.  
  2689.  
  2690. /** Error message constants. */
  2691. var FUNC_ERROR_TEXT = 'Expected a function';
  2692.  
  2693. /**
  2694.  * Creates a function that memoizes the result of `func`. If `resolver` is
  2695.  * provided, it determines the cache key for storing the result based on the
  2696.  * arguments provided to the memoized function. By default, the first argument
  2697.  * provided to the memoized function is used as the map cache key. The `func`
  2698.  * is invoked with the `this` binding of the memoized function.
  2699.  *
  2700.  * **Note:** The cache is exposed as the `cache` property on the memoized
  2701.  * function. Its creation may be customized by replacing the `_.memoize.Cache`
  2702.  * constructor with one whose instances implement the
  2703.  * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
  2704.  * method interface of `clear`, `delete`, `get`, `has`, and `set`.
  2705.  *
  2706.  * @static
  2707.  * @memberOf _
  2708.  * @since 0.1.0
  2709.  * @category Function
  2710.  * @param {Function} func The function to have its output memoized.
  2711.  * @param {Function} [resolver] The function to resolve the cache key.
  2712.  * @returns {Function} Returns the new memoized function.
  2713.  * @example
  2714.  *
  2715.  * var object = { 'a': 1, 'b': 2 };
  2716.  * var other = { 'c': 3, 'd': 4 };
  2717.  *
  2718.  * var values = _.memoize(_.values);
  2719.  * values(object);
  2720.  * // => [1, 2]
  2721.  *
  2722.  * values(other);
  2723.  * // => [3, 4]
  2724.  *
  2725.  * object.a = 2;
  2726.  * values(object);
  2727.  * // => [1, 2]
  2728.  *
  2729.  * // Modify the result cache.
  2730.  * values.cache.set(object, ['a', 'b']);
  2731.  * values(object);
  2732.  * // => ['a', 'b']
  2733.  *
  2734.  * // Replace `_.memoize.Cache`.
  2735.  * _.memoize.Cache = WeakMap;
  2736.  */
  2737. function memoize(func, resolver) {
  2738.   if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
  2739.     throw new TypeError(FUNC_ERROR_TEXT);
  2740.   }
  2741.   var memoized = function() {
  2742.     var args = arguments,
  2743.         key = resolver ? resolver.apply(this, args) : args[0],
  2744.         cache = memoized.cache;
  2745.  
  2746.     if (cache.has(key)) {
  2747.       return cache.get(key);
  2748.     }
  2749.     var result = func.apply(this, args);
  2750.     memoized.cache = cache.set(key, result) || cache;
  2751.     return result;
  2752.   };
  2753.   memoized.cache = new (memoize.Cache || _MapCache);
  2754.   return memoized;
  2755. }
  2756.  
  2757. // Expose `MapCache`.
  2758. memoize.Cache = _MapCache;
  2759.  
  2760. /* harmony default export */ const lodash_es_memoize = (memoize);
  2761.  
  2762. ;// ./node_modules/lodash-es/_memoizeCapped.js
  2763.  
  2764.  
  2765. /** Used as the maximum memoize cache size. */
  2766. var MAX_MEMOIZE_SIZE = 500;
  2767.  
  2768. /**
  2769.  * A specialized version of `_.memoize` which clears the memoized function's
  2770.  * cache when it exceeds `MAX_MEMOIZE_SIZE`.
  2771.  *
  2772.  * @private
  2773.  * @param {Function} func The function to have its output memoized.
  2774.  * @returns {Function} Returns the new memoized function.
  2775.  */
  2776. function memoizeCapped(func) {
  2777.   var result = lodash_es_memoize(func, function(key) {
  2778.     if (cache.size === MAX_MEMOIZE_SIZE) {
  2779.       cache.clear();
  2780.     }
  2781.     return key;
  2782.   });
  2783.  
  2784.   var cache = result.cache;
  2785.   return result;
  2786. }
  2787.  
  2788. /* harmony default export */ const _memoizeCapped = (memoizeCapped);
  2789.  
  2790. ;// ./node_modules/lodash-es/_stringToPath.js
  2791.  
  2792.  
  2793. /** Used to match property names within property paths. */
  2794. var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  2795.  
  2796. /** Used to match backslashes in property paths. */
  2797. var reEscapeChar = /\\(\\)?/g;
  2798.  
  2799. /**
  2800.  * Converts `string` to a property path array.
  2801.  *
  2802.  * @private
  2803.  * @param {string} string The string to convert.
  2804.  * @returns {Array} Returns the property path array.
  2805.  */
  2806. var stringToPath = _memoizeCapped(function(string) {
  2807.   var result = [];
  2808.   if (string.charCodeAt(0) === 46 /* . */) {
  2809.     result.push('');
  2810.   }
  2811.   string.replace(rePropName, function(match, number, quote, subString) {
  2812.     result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));
  2813.   });
  2814.   return result;
  2815. });
  2816.  
  2817. /* harmony default export */ const _stringToPath = (stringToPath);
  2818.  
  2819. ;// ./node_modules/lodash-es/_arrayMap.js
  2820. /**
  2821.  * A specialized version of `_.map` for arrays without support for iteratee
  2822.  * shorthands.
  2823.  *
  2824.  * @private
  2825.  * @param {Array} [array] The array to iterate over.
  2826.  * @param {Function} iteratee The function invoked per iteration.
  2827.  * @returns {Array} Returns the new mapped array.
  2828.  */
  2829. function arrayMap(array, iteratee) {
  2830.   var index = -1,
  2831.       length = array == null ? 0 : array.length,
  2832.       result = Array(length);
  2833.  
  2834.   while (++index < length) {
  2835.     result[index] = iteratee(array[index], index, array);
  2836.   }
  2837.   return result;
  2838. }
  2839.  
  2840. /* harmony default export */ const _arrayMap = (arrayMap);
  2841.  
  2842. ;// ./node_modules/lodash-es/_baseToString.js
  2843.  
  2844.  
  2845.  
  2846.  
  2847.  
  2848. /** Used as references for various `Number` constants. */
  2849. var INFINITY = 1 / 0;
  2850.  
  2851. /** Used to convert symbols to primitives and strings. */
  2852. var _baseToString_symbolProto = _Symbol ? _Symbol.prototype : undefined,
  2853.     symbolToString = _baseToString_symbolProto ? _baseToString_symbolProto.toString : undefined;
  2854.  
  2855. /**
  2856.  * The base implementation of `_.toString` which doesn't convert nullish
  2857.  * values to empty strings.
  2858.  *
  2859.  * @private
  2860.  * @param {*} value The value to process.
  2861.  * @returns {string} Returns the string.
  2862.  */
  2863. function baseToString(value) {
  2864.   // Exit early for strings to avoid a performance hit in some environments.
  2865.   if (typeof value == 'string') {
  2866.     return value;
  2867.   }
  2868.   if (lodash_es_isArray(value)) {
  2869.     // Recursively convert values (susceptible to call stack limits).
  2870.     return _arrayMap(value, baseToString) + '';
  2871.   }
  2872.   if (lodash_es_isSymbol(value)) {
  2873.     return symbolToString ? symbolToString.call(value) : '';
  2874.   }
  2875.   var result = (value + '');
  2876.   return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
  2877. }
  2878.  
  2879. /* harmony default export */ const _baseToString = (baseToString);
  2880.  
  2881. ;// ./node_modules/lodash-es/toString.js
  2882.  
  2883.  
  2884. /**
  2885.  * Converts `value` to a string. An empty string is returned for `null`
  2886.  * and `undefined` values. The sign of `-0` is preserved.
  2887.  *
  2888.  * @static
  2889.  * @memberOf _
  2890.  * @since 4.0.0
  2891.  * @category Lang
  2892.  * @param {*} value The value to convert.
  2893.  * @returns {string} Returns the converted string.
  2894.  * @example
  2895.  *
  2896.  * _.toString(null);
  2897.  * // => ''
  2898.  *
  2899.  * _.toString(-0);
  2900.  * // => '-0'
  2901.  *
  2902.  * _.toString([1, 2, 3]);
  2903.  * // => '1,2,3'
  2904.  */
  2905. function toString_toString(value) {
  2906.   return value == null ? '' : _baseToString(value);
  2907. }
  2908.  
  2909. /* harmony default export */ const lodash_es_toString = (toString_toString);
  2910.  
  2911. ;// ./node_modules/lodash-es/_castPath.js
  2912.  
  2913.  
  2914.  
  2915.  
  2916.  
  2917. /**
  2918.  * Casts `value` to a path array if it's not one.
  2919.  *
  2920.  * @private
  2921.  * @param {*} value The value to inspect.
  2922.  * @param {Object} [object] The object to query keys on.
  2923.  * @returns {Array} Returns the cast property path array.
  2924.  */
  2925. function castPath(value, object) {
  2926.   if (lodash_es_isArray(value)) {
  2927.     return value;
  2928.   }
  2929.   return _isKey(value, object) ? [value] : _stringToPath(lodash_es_toString(value));
  2930. }
  2931.  
  2932. /* harmony default export */ const _castPath = (castPath);
  2933.  
  2934. ;// ./node_modules/lodash-es/_toKey.js
  2935.  
  2936.  
  2937. /** Used as references for various `Number` constants. */
  2938. var _toKey_INFINITY = 1 / 0;
  2939.  
  2940. /**
  2941.  * Converts `value` to a string key if it's not a string or symbol.
  2942.  *
  2943.  * @private
  2944.  * @param {*} value The value to inspect.
  2945.  * @returns {string|symbol} Returns the key.
  2946.  */
  2947. function toKey(value) {
  2948.   if (typeof value == 'string' || lodash_es_isSymbol(value)) {
  2949.     return value;
  2950.   }
  2951.   var result = (value + '');
  2952.   return (result == '0' && (1 / value) == -_toKey_INFINITY) ? '-0' : result;
  2953. }
  2954.  
  2955. /* harmony default export */ const _toKey = (toKey);
  2956.  
  2957. ;// ./node_modules/lodash-es/_baseGet.js
  2958.  
  2959.  
  2960.  
  2961. /**
  2962.  * The base implementation of `_.get` without support for default values.
  2963.  *
  2964.  * @private
  2965.  * @param {Object} object The object to query.
  2966.  * @param {Array|string} path The path of the property to get.
  2967.  * @returns {*} Returns the resolved value.
  2968.  */
  2969. function baseGet(object, path) {
  2970.   path = _castPath(path, object);
  2971.  
  2972.   var index = 0,
  2973.       length = path.length;
  2974.  
  2975.   while (object != null && index < length) {
  2976.     object = object[_toKey(path[index++])];
  2977.   }
  2978.   return (index && index == length) ? object : undefined;
  2979. }
  2980.  
  2981. /* harmony default export */ const _baseGet = (baseGet);
  2982.  
  2983. ;// ./node_modules/lodash-es/get.js
  2984.  
  2985.  
  2986. /**
  2987.  * Gets the value at `path` of `object`. If the resolved value is
  2988.  * `undefined`, the `defaultValue` is returned in its place.
  2989.  *
  2990.  * @static
  2991.  * @memberOf _
  2992.  * @since 3.7.0
  2993.  * @category Object
  2994.  * @param {Object} object The object to query.
  2995.  * @param {Array|string} path The path of the property to get.
  2996.  * @param {*} [defaultValue] The value returned for `undefined` resolved values.
  2997.  * @returns {*} Returns the resolved value.
  2998.  * @example
  2999.  *
  3000.  * var object = { 'a': [{ 'b': { 'c': 3 } }] };
  3001.  *
  3002.  * _.get(object, 'a[0].b.c');
  3003.  * // => 3
  3004.  *
  3005.  * _.get(object, ['a', '0', 'b', 'c']);
  3006.  * // => 3
  3007.  *
  3008.  * _.get(object, 'a.b.c', 'default');
  3009.  * // => 'default'
  3010.  */
  3011. function get(object, path, defaultValue) {
  3012.   var result = object == null ? undefined : _baseGet(object, path);
  3013.   return result === undefined ? defaultValue : result;
  3014. }
  3015.  
  3016. /* harmony default export */ const lodash_es_get = (get);
  3017.  
  3018. ;// ./node_modules/lodash-es/_baseHasIn.js
  3019. /**
  3020.  * The base implementation of `_.hasIn` without support for deep paths.
  3021.  *
  3022.  * @private
  3023.  * @param {Object} [object] The object to query.
  3024.  * @param {Array|string} key The key to check.
  3025.  * @returns {boolean} Returns `true` if `key` exists, else `false`.
  3026.  */
  3027. function baseHasIn(object, key) {
  3028.   return object != null && key in Object(object);
  3029. }
  3030.  
  3031. /* harmony default export */ const _baseHasIn = (baseHasIn);
  3032.  
  3033. ;// ./node_modules/lodash-es/_hasPath.js
  3034.  
  3035.  
  3036.  
  3037.  
  3038.  
  3039.  
  3040.  
  3041. /**
  3042.  * Checks if `path` exists on `object`.
  3043.  *
  3044.  * @private
  3045.  * @param {Object} object The object to query.
  3046.  * @param {Array|string} path The path to check.
  3047.  * @param {Function} hasFunc The function to check properties.
  3048.  * @returns {boolean} Returns `true` if `path` exists, else `false`.
  3049.  */
  3050. function hasPath(object, path, hasFunc) {
  3051.   path = _castPath(path, object);
  3052.  
  3053.   var index = -1,
  3054.       length = path.length,
  3055.       result = false;
  3056.  
  3057.   while (++index < length) {
  3058.     var key = _toKey(path[index]);
  3059.     if (!(result = object != null && hasFunc(object, key))) {
  3060.       break;
  3061.     }
  3062.     object = object[key];
  3063.   }
  3064.   if (result || ++index != length) {
  3065.     return result;
  3066.   }
  3067.   length = object == null ? 0 : object.length;
  3068.   return !!length && lodash_es_isLength(length) && _isIndex(key, length) &&
  3069.     (lodash_es_isArray(object) || lodash_es_isArguments(object));
  3070. }
  3071.  
  3072. /* harmony default export */ const _hasPath = (hasPath);
  3073.  
  3074. ;// ./node_modules/lodash-es/hasIn.js
  3075.  
  3076.  
  3077.  
  3078. /**
  3079.  * Checks if `path` is a direct or inherited property of `object`.
  3080.  *
  3081.  * @static
  3082.  * @memberOf _
  3083.  * @since 4.0.0
  3084.  * @category Object
  3085.  * @param {Object} object The object to query.
  3086.  * @param {Array|string} path The path to check.
  3087.  * @returns {boolean} Returns `true` if `path` exists, else `false`.
  3088.  * @example
  3089.  *
  3090.  * var object = _.create({ 'a': _.create({ 'b': 2 }) });
  3091.  *
  3092.  * _.hasIn(object, 'a');
  3093.  * // => true
  3094.  *
  3095.  * _.hasIn(object, 'a.b');
  3096.  * // => true
  3097.  *
  3098.  * _.hasIn(object, ['a', 'b']);
  3099.  * // => true
  3100.  *
  3101.  * _.hasIn(object, 'b');
  3102.  * // => false
  3103.  */
  3104. function hasIn(object, path) {
  3105.   return object != null && _hasPath(object, path, _baseHasIn);
  3106. }
  3107.  
  3108. /* harmony default export */ const lodash_es_hasIn = (hasIn);
  3109.  
  3110. ;// ./node_modules/lodash-es/_baseMatchesProperty.js
  3111.  
  3112.  
  3113.  
  3114.  
  3115.  
  3116.  
  3117.  
  3118.  
  3119. /** Used to compose bitmasks for value comparisons. */
  3120. var _baseMatchesProperty_COMPARE_PARTIAL_FLAG = 1,
  3121.     _baseMatchesProperty_COMPARE_UNORDERED_FLAG = 2;
  3122.  
  3123. /**
  3124.  * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.
  3125.  *
  3126.  * @private
  3127.  * @param {string} path The path of the property to get.
  3128.  * @param {*} srcValue The value to match.
  3129.  * @returns {Function} Returns the new spec function.
  3130.  */
  3131. function baseMatchesProperty(path, srcValue) {
  3132.   if (_isKey(path) && _isStrictComparable(srcValue)) {
  3133.     return _matchesStrictComparable(_toKey(path), srcValue);
  3134.   }
  3135.   return function(object) {
  3136.     var objValue = lodash_es_get(object, path);
  3137.     return (objValue === undefined && objValue === srcValue)
  3138.       ? lodash_es_hasIn(object, path)
  3139.       : _baseIsEqual(srcValue, objValue, _baseMatchesProperty_COMPARE_PARTIAL_FLAG | _baseMatchesProperty_COMPARE_UNORDERED_FLAG);
  3140.   };
  3141. }
  3142.  
  3143. /* harmony default export */ const _baseMatchesProperty = (baseMatchesProperty);
  3144.  
  3145. ;// ./node_modules/lodash-es/identity.js
  3146. /**
  3147.  * This method returns the first argument it receives.
  3148.  *
  3149.  * @static
  3150.  * @since 0.1.0
  3151.  * @memberOf _
  3152.  * @category Util
  3153.  * @param {*} value Any value.
  3154.  * @returns {*} Returns `value`.
  3155.  * @example
  3156.  *
  3157.  * var object = { 'a': 1 };
  3158.  *
  3159.  * console.log(_.identity(object) === object);
  3160.  * // => true
  3161.  */
  3162. function identity(value) {
  3163.   return value;
  3164. }
  3165.  
  3166. /* harmony default export */ const lodash_es_identity = (identity);
  3167.  
  3168. ;// ./node_modules/lodash-es/_baseProperty.js
  3169. /**
  3170.  * The base implementation of `_.property` without support for deep paths.
  3171.  *
  3172.  * @private
  3173.  * @param {string} key The key of the property to get.
  3174.  * @returns {Function} Returns the new accessor function.
  3175.  */
  3176. function baseProperty(key) {
  3177.   return function(object) {
  3178.     return object == null ? undefined : object[key];
  3179.   };
  3180. }
  3181.  
  3182. /* harmony default export */ const _baseProperty = (baseProperty);
  3183.  
  3184. ;// ./node_modules/lodash-es/_basePropertyDeep.js
  3185.  
  3186.  
  3187. /**
  3188.  * A specialized version of `baseProperty` which supports deep paths.
  3189.  *
  3190.  * @private
  3191.  * @param {Array|string} path The path of the property to get.
  3192.  * @returns {Function} Returns the new accessor function.
  3193.  */
  3194. function basePropertyDeep(path) {
  3195.   return function(object) {
  3196.     return _baseGet(object, path);
  3197.   };
  3198. }
  3199.  
  3200. /* harmony default export */ const _basePropertyDeep = (basePropertyDeep);
  3201.  
  3202. ;// ./node_modules/lodash-es/property.js
  3203.  
  3204.  
  3205.  
  3206.  
  3207.  
  3208. /**
  3209.  * Creates a function that returns the value at `path` of a given object.
  3210.  *
  3211.  * @static
  3212.  * @memberOf _
  3213.  * @since 2.4.0
  3214.  * @category Util
  3215.  * @param {Array|string} path The path of the property to get.
  3216.  * @returns {Function} Returns the new accessor function.
  3217.  * @example
  3218.  *
  3219.  * var objects = [
  3220.  *   { 'a': { 'b': 2 } },
  3221.  *   { 'a': { 'b': 1 } }
  3222.  * ];
  3223.  *
  3224.  * _.map(objects, _.property('a.b'));
  3225.  * // => [2, 1]
  3226.  *
  3227.  * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
  3228.  * // => [1, 2]
  3229.  */
  3230. function property(path) {
  3231.   return _isKey(path) ? _baseProperty(_toKey(path)) : _basePropertyDeep(path);
  3232. }
  3233.  
  3234. /* harmony default export */ const lodash_es_property = (property);
  3235.  
  3236. ;// ./node_modules/lodash-es/_baseIteratee.js
  3237.  
  3238.  
  3239.  
  3240.  
  3241.  
  3242.  
  3243. /**
  3244.  * The base implementation of `_.iteratee`.
  3245.  *
  3246.  * @private
  3247.  * @param {*} [value=_.identity] The value to convert to an iteratee.
  3248.  * @returns {Function} Returns the iteratee.
  3249.  */
  3250. function baseIteratee(value) {
  3251.   // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.
  3252.   // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.
  3253.   if (typeof value == 'function') {
  3254.     return value;
  3255.   }
  3256.   if (value == null) {
  3257.     return lodash_es_identity;
  3258.   }
  3259.   if (typeof value == 'object') {
  3260.     return lodash_es_isArray(value)
  3261.       ? _baseMatchesProperty(value[0], value[1])
  3262.       : _baseMatches(value);
  3263.   }
  3264.   return lodash_es_property(value);
  3265. }
  3266.  
  3267. /* harmony default export */ const _baseIteratee = (baseIteratee);
  3268.  
  3269. ;// ./node_modules/lodash-es/_createFind.js
  3270.  
  3271.  
  3272.  
  3273.  
  3274. /**
  3275.  * Creates a `_.find` or `_.findLast` function.
  3276.  *
  3277.  * @private
  3278.  * @param {Function} findIndexFunc The function to find the collection index.
  3279.  * @returns {Function} Returns the new find function.
  3280.  */
  3281. function createFind(findIndexFunc) {
  3282.   return function(collection, predicate, fromIndex) {
  3283.     var iterable = Object(collection);
  3284.     if (!lodash_es_isArrayLike(collection)) {
  3285.       var iteratee = _baseIteratee(predicate, 3);
  3286.       collection = lodash_es_keys(collection);
  3287.       predicate = function(key) { return iteratee(iterable[key], key, iterable); };
  3288.     }
  3289.     var index = findIndexFunc(collection, predicate, fromIndex);
  3290.     return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
  3291.   };
  3292. }
  3293.  
  3294. /* harmony default export */ const _createFind = (createFind);
  3295.  
  3296. ;// ./node_modules/lodash-es/_baseFindIndex.js
  3297. /**
  3298.  * The base implementation of `_.findIndex` and `_.findLastIndex` without
  3299.  * support for iteratee shorthands.
  3300.  *
  3301.  * @private
  3302.  * @param {Array} array The array to inspect.
  3303.  * @param {Function} predicate The function invoked per iteration.
  3304.  * @param {number} fromIndex The index to search from.
  3305.  * @param {boolean} [fromRight] Specify iterating from right to left.
  3306.  * @returns {number} Returns the index of the matched value, else `-1`.
  3307.  */
  3308. function baseFindIndex(array, predicate, fromIndex, fromRight) {
  3309.   var length = array.length,
  3310.       index = fromIndex + (fromRight ? 1 : -1);
  3311.  
  3312.   while ((fromRight ? index-- : ++index < length)) {
  3313.     if (predicate(array[index], index, array)) {
  3314.       return index;
  3315.     }
  3316.   }
  3317.   return -1;
  3318. }
  3319.  
  3320. /* harmony default export */ const _baseFindIndex = (baseFindIndex);
  3321.  
  3322. ;// ./node_modules/lodash-es/_trimmedEndIndex.js
  3323. /** Used to match a single whitespace character. */
  3324. var reWhitespace = /\s/;
  3325.  
  3326. /**
  3327.  * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace
  3328.  * character of `string`.
  3329.  *
  3330.  * @private
  3331.  * @param {string} string The string to inspect.
  3332.  * @returns {number} Returns the index of the last non-whitespace character.
  3333.  */
  3334. function trimmedEndIndex(string) {
  3335.   var index = string.length;
  3336.  
  3337.   while (index-- && reWhitespace.test(string.charAt(index))) {}
  3338.   return index;
  3339. }
  3340.  
  3341. /* harmony default export */ const _trimmedEndIndex = (trimmedEndIndex);
  3342.  
  3343. ;// ./node_modules/lodash-es/_baseTrim.js
  3344.  
  3345.  
  3346. /** Used to match leading whitespace. */
  3347. var reTrimStart = /^\s+/;
  3348.  
  3349. /**
  3350.  * The base implementation of `_.trim`.
  3351.  *
  3352.  * @private
  3353.  * @param {string} string The string to trim.
  3354.  * @returns {string} Returns the trimmed string.
  3355.  */
  3356. function baseTrim(string) {
  3357.   return string
  3358.     ? string.slice(0, _trimmedEndIndex(string) + 1).replace(reTrimStart, '')
  3359.     : string;
  3360. }
  3361.  
  3362. /* harmony default export */ const _baseTrim = (baseTrim);
  3363.  
  3364. ;// ./node_modules/lodash-es/toNumber.js
  3365.  
  3366.  
  3367.  
  3368.  
  3369. /** Used as references for various `Number` constants. */
  3370. var NAN = 0 / 0;
  3371.  
  3372. /** Used to detect bad signed hexadecimal string values. */
  3373. var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
  3374.  
  3375. /** Used to detect binary string values. */
  3376. var reIsBinary = /^0b[01]+$/i;
  3377.  
  3378. /** Used to detect octal string values. */
  3379. var reIsOctal = /^0o[0-7]+$/i;
  3380.  
  3381. /** Built-in method references without a dependency on `root`. */
  3382. var freeParseInt = parseInt;
  3383.  
  3384. /**
  3385.  * Converts `value` to a number.
  3386.  *
  3387.  * @static
  3388.  * @memberOf _
  3389.  * @since 4.0.0
  3390.  * @category Lang
  3391.  * @param {*} value The value to process.
  3392.  * @returns {number} Returns the number.
  3393.  * @example
  3394.  *
  3395.  * _.toNumber(3.2);
  3396.  * // => 3.2
  3397.  *
  3398.  * _.toNumber(Number.MIN_VALUE);
  3399.  * // => 5e-324
  3400.  *
  3401.  * _.toNumber(Infinity);
  3402.  * // => Infinity
  3403.  *
  3404.  * _.toNumber('3.2');
  3405.  * // => 3.2
  3406.  */
  3407. function toNumber(value) {
  3408.   if (typeof value == 'number') {
  3409.     return value;
  3410.   }
  3411.   if (lodash_es_isSymbol(value)) {
  3412.     return NAN;
  3413.   }
  3414.   if (lodash_es_isObject(value)) {
  3415.     var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
  3416.     value = lodash_es_isObject(other) ? (other + '') : other;
  3417.   }
  3418.   if (typeof value != 'string') {
  3419.     return value === 0 ? value : +value;
  3420.   }
  3421.   value = _baseTrim(value);
  3422.   var isBinary = reIsBinary.test(value);
  3423.   return (isBinary || reIsOctal.test(value))
  3424.     ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
  3425.     : (reIsBadHex.test(value) ? NAN : +value);
  3426. }
  3427.  
  3428. /* harmony default export */ const lodash_es_toNumber = (toNumber);
  3429.  
  3430. ;// ./node_modules/lodash-es/toFinite.js
  3431.  
  3432.  
  3433. /** Used as references for various `Number` constants. */
  3434. var toFinite_INFINITY = 1 / 0,
  3435.     MAX_INTEGER = 1.7976931348623157e+308;
  3436.  
  3437. /**
  3438.  * Converts `value` to a finite number.
  3439.  *
  3440.  * @static
  3441.  * @memberOf _
  3442.  * @since 4.12.0
  3443.  * @category Lang
  3444.  * @param {*} value The value to convert.
  3445.  * @returns {number} Returns the converted number.
  3446.  * @example
  3447.  *
  3448.  * _.toFinite(3.2);
  3449.  * // => 3.2
  3450.  *
  3451.  * _.toFinite(Number.MIN_VALUE);
  3452.  * // => 5e-324
  3453.  *
  3454.  * _.toFinite(Infinity);
  3455.  * // => 1.7976931348623157e+308
  3456.  *
  3457.  * _.toFinite('3.2');
  3458.  * // => 3.2
  3459.  */
  3460. function toFinite(value) {
  3461.   if (!value) {
  3462.     return value === 0 ? value : 0;
  3463.   }
  3464.   value = lodash_es_toNumber(value);
  3465.   if (value === toFinite_INFINITY || value === -toFinite_INFINITY) {
  3466.     var sign = (value < 0 ? -1 : 1);
  3467.     return sign * MAX_INTEGER;
  3468.   }
  3469.   return value === value ? value : 0;
  3470. }
  3471.  
  3472. /* harmony default export */ const lodash_es_toFinite = (toFinite);
  3473.  
  3474. ;// ./node_modules/lodash-es/toInteger.js
  3475.  
  3476.  
  3477. /**
  3478.  * Converts `value` to an integer.
  3479.  *
  3480.  * **Note:** This method is loosely based on
  3481.  * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
  3482.  *
  3483.  * @static
  3484.  * @memberOf _
  3485.  * @since 4.0.0
  3486.  * @category Lang
  3487.  * @param {*} value The value to convert.
  3488.  * @returns {number} Returns the converted integer.
  3489.  * @example
  3490.  *
  3491.  * _.toInteger(3.2);
  3492.  * // => 3
  3493.  *
  3494.  * _.toInteger(Number.MIN_VALUE);
  3495.  * // => 0
  3496.  *
  3497.  * _.toInteger(Infinity);
  3498.  * // => 1.7976931348623157e+308
  3499.  *
  3500.  * _.toInteger('3.2');
  3501.  * // => 3
  3502.  */
  3503. function toInteger(value) {
  3504.   var result = lodash_es_toFinite(value),
  3505.       remainder = result % 1;
  3506.  
  3507.   return result === result ? (remainder ? result - remainder : result) : 0;
  3508. }
  3509.  
  3510. /* harmony default export */ const lodash_es_toInteger = (toInteger);
  3511.  
  3512. ;// ./node_modules/lodash-es/findIndex.js
  3513.  
  3514.  
  3515.  
  3516.  
  3517. /* Built-in method references for those with the same name as other `lodash` methods. */
  3518. var nativeMax = Math.max;
  3519.  
  3520. /**
  3521.  * This method is like `_.find` except that it returns the index of the first
  3522.  * element `predicate` returns truthy for instead of the element itself.
  3523.  *
  3524.  * @static
  3525.  * @memberOf _
  3526.  * @since 1.1.0
  3527.  * @category Array
  3528.  * @param {Array} array The array to inspect.
  3529.  * @param {Function} [predicate=_.identity] The function invoked per iteration.
  3530.  * @param {number} [fromIndex=0] The index to search from.
  3531.  * @returns {number} Returns the index of the found element, else `-1`.
  3532.  * @example
  3533.  *
  3534.  * var users = [
  3535.  *   { 'user': 'barney',  'active': false },
  3536.  *   { 'user': 'fred',    'active': false },
  3537.  *   { 'user': 'pebbles', 'active': true }
  3538.  * ];
  3539.  *
  3540.  * _.findIndex(users, function(o) { return o.user == 'barney'; });
  3541.  * // => 0
  3542.  *
  3543.  * // The `_.matches` iteratee shorthand.
  3544.  * _.findIndex(users, { 'user': 'fred', 'active': false });
  3545.  * // => 1
  3546.  *
  3547.  * // The `_.matchesProperty` iteratee shorthand.
  3548.  * _.findIndex(users, ['active', false]);
  3549.  * // => 0
  3550.  *
  3551.  * // The `_.property` iteratee shorthand.
  3552.  * _.findIndex(users, 'active');
  3553.  * // => 2
  3554.  */
  3555. function findIndex(array, predicate, fromIndex) {
  3556.   var length = array == null ? 0 : array.length;
  3557.   if (!length) {
  3558.     return -1;
  3559.   }
  3560.   var index = fromIndex == null ? 0 : lodash_es_toInteger(fromIndex);
  3561.   if (index < 0) {
  3562.     index = nativeMax(length + index, 0);
  3563.   }
  3564.   return _baseFindIndex(array, _baseIteratee(predicate, 3), index);
  3565. }
  3566.  
  3567. /* harmony default export */ const lodash_es_findIndex = (findIndex);
  3568.  
  3569. ;// ./node_modules/lodash-es/find.js
  3570.  
  3571.  
  3572.  
  3573. /**
  3574.  * Iterates over elements of `collection`, returning the first element
  3575.  * `predicate` returns truthy for. The predicate is invoked with three
  3576.  * arguments: (value, index|key, collection).
  3577.  *
  3578.  * @static
  3579.  * @memberOf _
  3580.  * @since 0.1.0
  3581.  * @category Collection
  3582.  * @param {Array|Object} collection The collection to inspect.
  3583.  * @param {Function} [predicate=_.identity] The function invoked per iteration.
  3584.  * @param {number} [fromIndex=0] The index to search from.
  3585.  * @returns {*} Returns the matched element, else `undefined`.
  3586.  * @example
  3587.  *
  3588.  * var users = [
  3589.  *   { 'user': 'barney',  'age': 36, 'active': true },
  3590.  *   { 'user': 'fred',    'age': 40, 'active': false },
  3591.  *   { 'user': 'pebbles', 'age': 1,  'active': true }
  3592.  * ];
  3593.  *
  3594.  * _.find(users, function(o) { return o.age < 40; });
  3595.  * // => object for 'barney'
  3596.  *
  3597.  * // The `_.matches` iteratee shorthand.
  3598.  * _.find(users, { 'age': 1, 'active': true });
  3599.  * // => object for 'pebbles'
  3600.  *
  3601.  * // The `_.matchesProperty` iteratee shorthand.
  3602.  * _.find(users, ['active', false]);
  3603.  * // => object for 'fred'
  3604.  *
  3605.  * // The `_.property` iteratee shorthand.
  3606.  * _.find(users, 'active');
  3607.  * // => object for 'barney'
  3608.  */
  3609. var find = _createFind(lodash_es_findIndex);
  3610.  
  3611. /* harmony default export */ const lodash_es_find = (find);
  3612.  
  3613. ;// ./scripts/wiki-rev-diff/src/parser.ts
  3614.  
  3615. function parseRevDetails(html) {
  3616.   const jq = external_$_namespaceObject(html);
  3617.   const rawInfo = jq.find('#subject_infobox').val()?.toString() ?? '';
  3618.   const title = jq.find('input[name="subject_title"]').val()?.toString() ?? '';
  3619.   const description = jq.find('textarea#subject_summary').val()?.toString() ?? '';
  3620.   const metaTags = jq.find('input#tags').val()?.toString() ?? '';
  3621.   return {
  3622.     title,
  3623.     rawInfo,
  3624.     description,
  3625.     metaTags
  3626.   };
  3627. }
  3628. function parseRevEl(el) {
  3629.   const date = el.find('a:not(.compare-previous-trim21-cn)').first().html();
  3630.   const revEL = el.find('a.l:contains("恢复")');
  3631.   const revCommentEl = el.find('span.comment');
  3632.   let comment = '';
  3633.   if (revCommentEl.length > 0) {
  3634.     comment = revCommentEl.html();
  3635.     comment = comment.substring(1, comment.length - 1);
  3636.   }
  3637.   const revHref = revEL.attr('href');
  3638.   if (!revHref) {
  3639.     // this is a merge commit, can't know what's really info
  3640.     return undefined;
  3641.   }
  3642.   const revID = revHref.split('/').pop();
  3643.   if (!revID) {
  3644.     throw new Error(`can't parse rev id from ${revHref}`);
  3645.   }
  3646.   return {
  3647.     id: revID,
  3648.     comment,
  3649.     date,
  3650.     url: revHref
  3651.   };
  3652. }
  3653. function getRevs() {
  3654.   const revs = [];
  3655.   external_$_namespaceObject('#pagehistory li').each(function () {
  3656.     const rev = parseRevEl(external_$_namespaceObject(this));
  3657.     if (rev != null) {
  3658.       revs.push(rev);
  3659.     }
  3660.   });
  3661.   return revs;
  3662. }
  3663. function getRevInfo(revID) {
  3664.   for (const rev of getRevs()) {
  3665.     if (rev.id === revID) {
  3666.       return rev;
  3667.     }
  3668.   }
  3669. }
  3670. ;// external "Diff2Html"
  3671. const external_Diff2Html_namespaceObject = Diff2Html;
  3672. ;// ./scripts/wiki-rev-diff/src/config.ts
  3673. const configKey = 'view-mode';
  3674. ;// external "Diff"
  3675. const external_Diff_namespaceObject = Diff;
  3676. ;// ./scripts/wiki-rev-diff/src/differ.ts
  3677.  
  3678. const pattern = /(?![\t\r\n])(\p{Cf}|\p{Cc}|\p{Co})/gu;
  3679. function escapeInvisible(s) {
  3680.   return s.replaceAll(pattern, function (match) {
  3681.     const u = match.codePointAt(0);
  3682.     if (u === undefined) {
  3683.       return '';
  3684.     }
  3685.     return '\\u' + u.toString(16).toLowerCase();
  3686.   });
  3687. }
  3688. function diff(revOld, revNew, style) {
  3689.   const options = {
  3690.     context: 100
  3691.   };
  3692.   if (style === 'line-by-line') {
  3693.     options.context = 4;
  3694.   }
  3695.   return [oneLineDiff('标题', revOld.details.title, revNew.details.title, revOld.rev.date, revNew.rev.date, options), oneLineDiff('标签', revOld.details.metaTags, revNew.details.metaTags, revOld.rev.date, revNew.rev.date, options), infoDiff(revOld, revNew, options), descriptionDiff(revOld, revNew, options)].join('\n');
  3696. }
  3697. function oneLineDiff(name, s1, s2, oldDate, newDate, options) {
  3698.   if (s1 === s2) {
  3699.     return '';
  3700.   }
  3701.   return external_Diff_namespaceObject.createPatch(name, escapeInvisible(s1), escapeInvisible(s2), oldDate, newDate, options);
  3702. }
  3703. function infoDiff(rev1, rev2, options) {
  3704.   if (rev1.details.rawInfo === rev2.details.rawInfo) {
  3705.     return '';
  3706.   }
  3707.   return external_Diff_namespaceObject.createPatch('相关信息', escapeInvisible(rev1.details.rawInfo), escapeInvisible(rev2.details.rawInfo), rev1.rev.date, rev2.rev.date, options);
  3708. }
  3709. function descriptionDiff(rev1, rev2, options) {
  3710.   if (rev1.details.description === rev2.details.description) {
  3711.     return '';
  3712.   }
  3713.   return external_Diff_namespaceObject.createPatch('简介', escapeInvisible(rev1.details.description), escapeInvisible(rev2.details.description), rev1.rev.date, rev2.rev.date, options);
  3714. }
  3715. ;// ./scripts/wiki-rev-diff/src/utils.ts
  3716. function getCookie(name) {
  3717.   const value = '; ' + document.cookie;
  3718.   const parts = value.split('; ' + name + '=');
  3719.   if (parts.length === 2) return parts.pop()?.split(';').shift();
  3720.   return undefined;
  3721. }
  3722. ;// ./scripts/wiki-rev-diff/src/ui.ts
  3723.  
  3724.  
  3725.  
  3726.  
  3727.  
  3728. async function render(revOld, revNew) {
  3729.   let outputFormat = await GM.getValue(configKey);
  3730.   if (!outputFormat) {
  3731.     outputFormat = 'line-by-line';
  3732.   }
  3733.   const colorScheme = getCookie('chii_theme');
  3734.   const patch = diff(revOld, revNew, outputFormat);
  3735.   const html = external_Diff2Html_namespaceObject.html(patch, {
  3736.     outputFormat,
  3737.     colorScheme,
  3738.     drawFileList: false
  3739.   });
  3740.   const elID = `show-diff-view-${outputFormat}`;
  3741.   show('');
  3742.   if (patch.trim()) {
  3743.     external_$_namespaceObject(`#${elID}`).html(html);
  3744.   } else {
  3745.     external_$_namespaceObject(`#${elID}`).html('<h1>选中的版本之间没有修改</h1>');
  3746.   }
  3747.   document.getElementById(elID)?.scrollIntoView({
  3748.     behavior: 'smooth'
  3749.   });
  3750. }
  3751. function show(html) {
  3752.   external_$_namespaceObject('#show-diff-info').html(html);
  3753. }
  3754. function clear() {
  3755.   external_$_namespaceObject('#show-diff-view-line-by-line').html('');
  3756.   external_$_namespaceObject('#show-diff-view-side-by-side').html('');
  3757.   show('');
  3758. }
  3759. ;// ./scripts/wiki-rev-diff/src/model.ts
  3760. class Commit {
  3761.   constructor(rev, detail) {
  3762.     this.rev = rev;
  3763.     this.details = detail;
  3764.   }
  3765. }
  3766. ;// ./scripts/wiki-rev-diff/src/compare.ts
  3767.  
  3768.  
  3769.  
  3770. function compare(revID1, revID2) {
  3771.   clear();
  3772.   show('<h2>loading versions...</h2>');
  3773.   const rev1 = getRevInfo(revID1);
  3774.   const rev2 = getRevInfo(revID2);
  3775.   if (rev1 == null) {
  3776.     throw new Error(`error finding ${revID1}`);
  3777.   }
  3778.   const ps = [fetchRev(rev1), fetchRev(rev2)];
  3779.   Promise.all(ps).then(async values => {
  3780.     await render(values[1], values[0]);
  3781.   }).catch(e => {
  3782.     console.error(e);
  3783.     show('<div style="color: red">获取历史修改失败，请刷新页面后重试</div>');
  3784.   });
  3785. }
  3786. const _cache = {};
  3787. async function fetchRev(rev) {
  3788.   if (rev == null) {
  3789.     return new Commit({
  3790.       id: '0',
  3791.       comment: '',
  3792.       date: '',
  3793.       url: ''
  3794.     }, {
  3795.       title: '',
  3796.       rawInfo: '',
  3797.       description: '',
  3798.       metaTags: ''
  3799.     });
  3800.   }
  3801.   if (!_cache[rev.id]) {
  3802.     const res = await fetch(rev.url);
  3803.     _cache[rev.id] = new Commit(rev, parseRevDetails(await res.text()));
  3804.   }
  3805.   return _cache[rev.id];
  3806. }
  3807. ;// ./scripts/wiki-rev-diff/src/index.ts
  3808.  
  3809.  
  3810.  
  3811.  
  3812.  
  3813. async function main() {
  3814.   console.log('start bgm-wiki-rev-diff UserScript');
  3815.   await initUI();
  3816. }
  3817. const style = `
  3818. <style>
  3819. #show-diff-view-side-by-side {
  3820.   margin:0 auto;
  3821.   max-width: 100em;
  3822. }
  3823.  
  3824. .show-version-diff .d2h-code-line, .show-version-diff .d2h-code-side-line {
  3825.   width: calc(100% - 8em);
  3826.   padding-right: 0;
  3827. }
  3828.  
  3829. .show-version-diff .d2h-code-line-ctn {
  3830.   width: calc(100% - 8em);
  3831. }
  3832.  
  3833. #columnInSubjectA .rev-trim21-cn {
  3834.   margin: 0 0.2em;
  3835. }
  3836.  
  3837. ul#pagehistory > li > * {
  3838.   vertical-align: middle;
  3839. }
  3840. </style>
  3841. `;
  3842. async function initUI() {
  3843.   GM.registerMenuCommand('切换diff视图', function () {
  3844.     void (async () => {
  3845.       let outputFormat = await GM.getValue(configKey);
  3846.       if (!outputFormat || outputFormat === 'side-by-side') {
  3847.         outputFormat = 'line-by-line';
  3848.       } else {
  3849.         outputFormat = 'side-by-side';
  3850.       }
  3851.       await GM.setValue(configKey, outputFormat);
  3852.     })();
  3853.   });
  3854.   external_$_namespaceObject('#headerSubject').after('<div id="show-diff-view-side-by-side" class="show-version-diff"></div>');
  3855.   external_$_namespaceObject('#columnInSubjectA > hr.board').after(style + '<div id="show-diff-view-line-by-line" class="show-version-diff"></div>');
  3856.   external_$_namespaceObject('#columnInSubjectA .subtitle').after('<div id="show-diff-info"></div>');
  3857.   const diff2htmlStyle = await GM.getResourceUrl('diff2html');
  3858.   external_$_namespaceObject('head').append(style).append(`<link rel='stylesheet' type='text/css' href='${diff2htmlStyle}' />`);
  3859.   const s = external_$_namespaceObject('#pagehistory li');
  3860.   const revs = Array.from(s).map(function (e) {
  3861.     return parseRevEl(external_$_namespaceObject(e))?.id;
  3862.   });
  3863.   s.each(function (index) {
  3864.     const el = external_$_namespaceObject(this);
  3865.     const id = revs[index];
  3866.     if (!id) {
  3867.       el.prepend('<span style="padding-right: 1.4em"> 无法参与比较 </span>');
  3868.       return;
  3869.     }
  3870.     el.prepend(`<input type='radio' class='rev-trim21-cn' name='rev-right' label='select to compare' value='${id}'>`);
  3871.     el.prepend(`<input type='radio' class='rev-trim21-cn' name='rev-left' label='select to compare' value='${id}'>`);
  3872.     const previous = lodash_es_find(revs, Boolean, index + 1) ?? '';
  3873.     el.prepend(`(<a href='#' data-rev='${id}' data-previous='${previous}' class='l compare-previous-trim21-cn'>显示修改</a>) `);
  3874.   });
  3875.   const typeRevert = {
  3876.     'rev-left': 'rev-right',
  3877.     'rev-right': 'rev-left'
  3878.   };
  3879.   external_$_namespaceObject('input[type="radio"]').on('change', function (e) {
  3880.     const name = e.target.getAttribute('name');
  3881.     if (!name) {
  3882.       return;
  3883.     }
  3884.     const selectName = typeRevert[name];
  3885.     const rev = e.target.getAttribute('value');
  3886.     if (rev) {
  3887.       external_$_namespaceObject(`input[name="${selectName}"][value="${rev}"]`).css('visibility', 'hidden');
  3888.       external_$_namespaceObject(`input[name="${selectName}"][value!="${rev}"]`).css('visibility', 'visible');
  3889.     }
  3890.   });
  3891.   external_$_namespaceObject('.compare-previous-trim21-cn').on('click', function () {
  3892.     const el = external_$_namespaceObject(this);
  3893.     const left = String(el.data('rev'));
  3894.     const right = String(el.data('previous'));
  3895.     compare(left, right);
  3896.     external_$_namespaceObject(`input[name="rev-left"][value="${left}"]`).prop('checked', true);
  3897.     external_$_namespaceObject(`input[name="rev-left"][value!="${left}"]`).prop('checked', null);
  3898.     external_$_namespaceObject(`input[name="rev-right"][value="${left}"]`).css('visibility', 'hidden');
  3899.     external_$_namespaceObject(`input[name="rev-right"][value!="${left}"]`).css('visibility', 'visible');
  3900.     external_$_namespaceObject('input[name="rev-left"]').css('visibility', 'visible');
  3901.     external_$_namespaceObject('input[name="rev-right"]').prop('checked', null);
  3902.     if (right) {
  3903.       external_$_namespaceObject(`input[name="rev-right"][value="${right}"]`).prop('checked', true);
  3904.       external_$_namespaceObject(`input[name="rev-left"][value="${right}"]`).css('visibility', 'hidden');
  3905.     }
  3906.   });
  3907.   external_$_namespaceObject('#columnInSubjectA span.text').append('<a href="#" id="compare-trim21-cn" class="l"> > 比较选中的版本</a>');
  3908.   external_$_namespaceObject('#compare-trim21-cn').on('click', function () {
  3909.     const selectedRevs = getSelectedVersion();
  3910.     compare(selectedRevs[0], selectedRevs[1]);
  3911.   });
  3912. }
  3913. function getSelectedVersion() {
  3914.   const selectedVersion = [];
  3915.   const selectedRev = external_$_namespaceObject('.rev-trim21-cn:checked');
  3916.   if (selectedRev.length < 2) {
  3917.     window.alert('请选中两个版本进行比较');
  3918.     throw new Error();
  3919.   }
  3920.   selectedRev.each(function () {
  3921.     const val = external_$_namespaceObject(this).val();
  3922.     selectedVersion.push(val);
  3923.   });
  3924.   selectedVersion.sort((a, b) => parseInt(b) - parseInt(a));
  3925.   return selectedVersion;
  3926. }
  3927. main().catch(console.error);
  3928. /******/ })()
  3929. ;

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址